1#[allow(
798 non_camel_case_types,
799 non_snake_case,
800 clippy::pub_underscore_fields,
801 clippy::style,
802 clippy::empty_structs_with_brackets
803)]
804pub mod HoprNetworkRegistry {
805 use super::*;
806 use alloy::sol_types as alloy_sol_types;
807 #[rustfmt::skip]
813 #[allow(clippy::all)]
814 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
815 b"`\x80`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0\x1E?8\x03\x80b\0\x1E?\x839\x81\x01`@\x81\x90Rb\0\x004\x91b\0\x02jV[b\0\0A`\0\x83b\0\x01\0V[b\0\0\\`\0\x80Q` b\0\x1E\x1F\x839\x81Q\x91R\x83b\0\x01\0V[b\0\0w`\0\x80Q` b\0\x1E\x1F\x839\x81Q\x91R\x82b\0\x01\0V[`\x02\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x81\x17\x90\x91U`\x05\x80T`\xFF\x19\x16`\x01\x17\x90U`@Q\x7F\x8A\xC4\xB2\xEBwI\xF7\\[\x99\xB8\x98\xE5G\xFDa]\xD7\xA4$\xE6\x83V\xEA\x19k}\xAEt-l2\x90`\0\x90\xA2`@Q`\x01\x90\x7F\x8B\xC8_%\xE3\xE93\x97\x8F\t\x94\x08\xB3\xBB>\xB7c\x0Bv\xF7E_. [\xCB\xC0\xA7\x80\xE1~r\x90`\0\x90\xA2PPPb\0\x02\xB4V[b\0\x01\x0C\x82\x82b\0\x01\x10V[PPV[b\0\x01\x1C\x82\x82b\0\x01;V[`\0\x82\x81R`\x01` R`@\x90 b\0\x016\x90\x82b\0\x01\xDBV[PPPV[`\0\x82\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x90 T`\xFF\x16b\0\x01\x0CW`\0\x82\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x90 \x80T`\xFF\x19\x16`\x01\x17\x90Ub\0\x01\x973\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x83\x7F/\x87\x88\x11~~\xFF\x1D\x82\xE9&\xECyI\x01\xD1|x\x02JP'\t@0E@\xA73eo\r`@Q`@Q\x80\x91\x03\x90\xA4PPV[`\0b\0\x01\xF2\x83`\x01`\x01`\xA0\x1B\x03\x84\x16b\0\x01\xFBV[\x90P[\x92\x91PPV[`\0\x81\x81R`\x01\x83\x01` R`@\x81 Tb\0\x02DWP\x81T`\x01\x81\x81\x01\x84U`\0\x84\x81R` \x80\x82 \x90\x93\x01\x84\x90U\x84T\x84\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ub\0\x01\xF5V[P`\0b\0\x01\xF5V[\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x02eW`\0\x80\xFD[\x91\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15b\0\x02\x80W`\0\x80\xFD[b\0\x02\x8B\x84b\0\x02MV[\x92Pb\0\x02\x9B` \x85\x01b\0\x02MV[\x91Pb\0\x02\xAB`@\x85\x01b\0\x02MV[\x90P\x92P\x92P\x92V[a\x1B[\x80b\0\x02\xC4`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x01\xC4W`\x005`\xE0\x1C\x80c\x90\x10\xD0|\x11a\0\xF9W\x80c\xCA\x15\xC8s\x11a\0\x97W\x80c\xCF\xB3s_\x11a\0qW\x80c\xCF\xB3s_\x14a\x03\xDAW\x80c\xD5Gt\x1F\x14a\x03\xE2W\x80c\xE3\xD2\xA0q\x14a\x03\xF5W\x80c\xEC\x87b\x1C\x14a\x04\x08W`\0\x80\xFD[\x80c\xCA\x15\xC8s\x14a\x03\xACW\x80c\xCA\xF5\xF5\x01\x14a\x03\xBFW\x80c\xCB\xEB\xAF\xE0\x14a\x03\xD2W`\0\x80\xFD[\x80c\xA0^\x0Fm\x11a\0\xD3W\x80c\xA0^\x0Fm\x14a\x03UW\x80c\xA2\x17\xFD\xDF\x14a\x03hW\x80c\xA5`]\xA5\x14a\x03pW\x80c\xC7\xEC\xAB\x8F\x14a\x03\x83W`\0\x80\xFD[\x80c\x90\x10\xD0|\x14a\x03\x0FW\x80c\x91\xD1HT\x14a\x03:W\x80c\x9C\x7Fd;\x14a\x03MW`\0\x80\xFD[\x80c6V\x8A\xBE\x11a\x01fW\x80cN\xB1\x80\\\x11a\x01@W\x80cN\xB1\x80\\\x14a\x02\xC3W\x80co\xFB\xF9\x88\x14a\x02\xD6W\x80cvY:9\x14a\x02\xE9W\x80c\x8Du;-\x14a\x02\xFCW`\0\x80\xFD[\x80c6V\x8A\xBE\x14a\x02}W\x80c?\xA5\x84W\x14a\x02\x90W\x80cA\xB6Ie\x14a\x02\xB0W`\0\x80\xFD[\x80c'\xB0@\xA1\x11a\x01\xA2W\x80c'\xB0@\xA1\x14a\x02/W\x80c*-\xEE\xE2\x14a\x02DW\x80c,3\xCA\xFB\x14a\x02WW\x80c//\xF1]\x14a\x02jW`\0\x80\xFD[\x80c\x01\xFF\xC9\xA7\x14a\x01\xC9W\x80c#\x8D\xAF\xE0\x14a\x01\xF1W\x80c$\x8A\x9C\xA3\x14a\x01\xFEW[`\0\x80\xFD[a\x01\xDCa\x01\xD76`\x04a\x16+V[a\x04\x1DV[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[`\x05Ta\x01\xDC\x90`\xFF\x16\x81V[a\x02!a\x02\x0C6`\x04a\x16UV[`\0\x90\x81R` \x81\x90R`@\x90 `\x01\x01T\x90V[`@Q\x90\x81R` \x01a\x01\xE8V[a\x02Ba\x02=6`\x04a\x16\x8AV[a\x04HV[\0[a\x02!a\x02R6`\x04a\x16\x8AV[a\x04\xABV[a\x02Ba\x02e6`\x04a\x16\xF1V[a\x05]V[a\x02Ba\x02x6`\x04a\x173V[a\x05\xC7V[a\x02Ba\x02\x8B6`\x04a\x173V[a\x05\xF1V[a\x02!a\x02\x9E6`\x04a\x16\x8AV[`\x03` R`\0\x90\x81R`@\x90 T\x81V[a\x02Ba\x02\xBE6`\x04a\x16\xF1V[a\x06tV[a\x01\xDCa\x02\xD16`\x04a\x16\x8AV[a\x07\x97V[a\x01\xDCa\x02\xE46`\x04a\x16\x8AV[a\x07\xE8V[a\x02Ba\x02\xF76`\x04a\x16\xF1V[a\x07\xF3V[a\x02Ba\x03\n6`\x04a\x17_V[a\t\x88V[a\x03\"a\x03\x1D6`\x04a\x17\xCBV[a\x0B\x02V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\xE8V[a\x01\xDCa\x03H6`\x04a\x173V[a\x0B\x1AV[a\x02Ba\x0BCV[a\x02Ba\x03c6`\x04a\x16\xF1V[a\x0BqV[a\x02!`\0\x81V[a\x01\xDCa\x03~6`\x04a\x17\xEDV[a\x0C\xC4V[a\x03\"a\x03\x916`\x04a\x16\x8AV[`\x04` R`\0\x90\x81R`@\x90 T`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x02!a\x03\xBA6`\x04a\x16UV[a\r\x13V[a\x02Ba\x03\xCD6`\x04a\x18FV[a\r*V[a\x02Ba\x0EDV[a\x02Ba\x0E\xB7V[a\x02Ba\x03\xF06`\x04a\x173V[a\x0F/V[`\x02Ta\x03\"\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x02!`\0\x80Q` a\x1A\xE6\x839\x81Q\x91R\x81V[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cZ\x05\x18\x0F`\xE0\x1B\x14\x80a\x04BWPa\x04B\x82a\x0FTV[\x92\x91PPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x04`\x81a\x0F\x89V[`\x02\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x84\x16\x90\x81\x17\x90\x91U`@Q\x7F\x8A\xC4\xB2\xEBwI\xF7\\[\x99\xB8\x98\xE5G\xFDa]\xD7\xA4$\xE6\x83V\xEA\x19k}\xAEt-l2\x90`\0\x90\xA2PPV[`\x02T`@QcY\xAA'A`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R`\0\x92\x83\x92\x91\x16\x90c\xB3TN\x82\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xF9W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x1D\x91\x90a\x194V[`\x01`\x01`\xA0\x1B\x03\x84\x16`\0\x90\x81R`\x03` R`@\x90 T\x90\x91P\x80\x82\x11\x15a\x05SWa\x05K\x81\x83a\x19cV[\x94\x93PPPPV[P`\0\x93\x92PPPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x05u\x81a\x0F\x89V[`\0[\x82\x81\x10\x15a\x05\xC1Wa\x05\xAF\x84\x84\x83\x81\x81\x10a\x05\x95Wa\x05\x95a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x05\xAA\x91\x90a\x16\x8AV[a\x0F\x96V[\x80a\x05\xB9\x81a\x19\x8CV[\x91PPa\x05xV[PPPPV[`\0\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x05\xE2\x81a\x0F\x89V[a\x05\xEC\x83\x83a\x0F\xF3V[PPPV[`\x01`\x01`\xA0\x1B\x03\x81\x163\x14a\x06fW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`/`$\x82\x01R\x7FAccessControl: can only renounce`D\x82\x01Rn\x1097\xB62\xB9\x9037\xB9\x109\xB2\xB63`\x89\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[a\x06p\x82\x82a\x10\x15V[PPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x06\x8C\x81a\x0F\x89V[`\0[\x82\x81\x10\x15a\x05\xC1W`\0\x84\x84\x83\x81\x81\x10a\x06\xABWa\x06\xABa\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x06\xC0\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x80\x82\x16`\0\x90\x81R`\x04` R`@\x90 T\x91\x92P\x16\x80a\x07\x07W`@Qc\x168y\x15`\xE3\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x03` R`@\x81 \x80T\x91a\x07+\x83a\x19\xA5V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\0\x81\x81R`\x04` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90UQ\x91\x92\x84\x16\x91\x7F\x91v\n\x10\x01\xF51\xEC+\xEE\x86\x02\xBEU\xAD+\x11YF^\xDF\xF5\xBB\xCDA\xD2\x07\x03t*MB\x91\x90\xA3PP\x80\x80a\x07\x8F\x90a\x19\x8CV[\x91PPa\x06\x8FV[`\0`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xAFWP`\0\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\0\x90\x81R`\x04` R`@\x90 T\x16\x80a\x07\xD8WP`\0\x92\x91PPV[a\x07\xE1\x81a\x107V[\x93\x92PPPV[`\0a\x04B\x82a\x107V[`\x05T`\xFF\x16a\x08\x16W`@Qc\xC4&8\xBB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0[\x81\x81\x10\x15a\tAW`\0\x83\x83\x83\x81\x81\x10a\x085Wa\x085a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x08J\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x80\x82\x16`\0\x90\x81R`\x04` R`@\x90 T\x91\x92P\x16a\x08r3\x83a\x10\xEDV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x08\xF8W3`\0\x90\x81R`\x03` R`@\x81 \x80T\x91a\x08\x9B\x83a\x19\x8CV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x81\x81R`\x04` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x163\x90\x81\x17\x90\x91U\x90Q\x90\x91\x7F\n1\xEE\x9DF\xA8(\x88K\x81\0<\x84\x98\x15n\xA6\xAA\x15\xB9\xB5K\xDD\x0E\xF0\xB53\xD9\xEB\xA5~U\x91\xA3a\t,V[`\x01`\x01`\xA0\x1B\x03\x81\x163\x14a\t,W`@Qc[S;\xA1`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[PP\x80\x80a\t9\x90a\x19\x8CV[\x91PPa\x08\x19V[Pa\tK3a\x107V[a\thW`@Qc\x03\xEEoW`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q`\x01\x903\x90`\0\x80Q` a\x1B\x06\x839\x81Q\x91R\x90`\0\x90\xA3PPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\t\xA0\x81a\x0F\x89V[\x83\x82\x14a\t\xC0W`@Qc\xED\x88/q`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0[\x84\x81\x10\x15a\n\xFAW`\0\x84\x84\x83\x81\x81\x10a\t\xDFWa\t\xDFa\x19vV[\x90P` \x02\x01` \x81\x01\x90a\t\xF4\x91\x90a\x16\x8AV[\x90P`\0\x87\x87\x84\x81\x81\x10a\n\nWa\n\na\x19vV[\x90P` \x02\x01` \x81\x01\x90a\n\x1F\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\0\x90\x81R`\x04` R`@\x90 T\x91\x92P\x16\x15a\nfW`@Qc[S;\xA1`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x03` R`@\x81 \x80T\x91a\n\x8A\x83a\x19\x8CV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\0\x81\x81R`\x04` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x94\x86\x16\x94\x85\x17\x90UQ\x91\x92\x91\x7F\x04\xE1\xEA\xA4\xDA\x18\xF7\xE7B\xA4\xED\xBB\xE9\xED\xE3l\xDFu\xF7\x93\xBB\x03\xAB!X\xC0\x87\x7F\x1C\xAF+\x93\x91\x90\xA3PP\x80\x80a\n\xF2\x90a\x19\x8CV[\x91PPa\t\xC3V[PPPPPPV[`\0\x82\x81R`\x01` R`@\x81 a\x07\xE1\x90\x83a\x11\x8FV[`\0\x91\x82R` \x82\x81R`@\x80\x84 `\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16\x84R\x91\x90R\x90 T`\xFF\x16\x90V[`\x05T`\xFF\x16a\x0BfW`@Qc\xC4&8\xBB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0Bo3a\x0F\x96V[V[`\x05T`\xFF\x16a\x0B\x94W`@Qc\xC4&8\xBB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0[\x81\x81\x10\x15a\x0C\xBAW`\0\x83\x83\x83\x81\x81\x10a\x0B\xB3Wa\x0B\xB3a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x0B\xC8\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x80\x82\x16`\0\x90\x81R`\x04` R`@\x90 T\x91\x92P\x16a\x0B\xF03\x83a\x10\xEDV[3`\x01`\x01`\xA0\x1B\x03\x82\x16\x03a\x0CrW3`\0\x90\x81R`\x03` R`@\x81 \x80T\x91a\x0C\x1B\x83a\x19\xA5V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x81\x81R`\x04` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90UQ3\x91\x7F\x15\x9A\x8A\xE9H\xFC\xC6\xE7\xF8\xB5I\\\rs\xE9\x15\x98D\n\xF8\xA6(\x17$l\t\xED\xC2\xC2\x8D\xBA\x8A\x91\xA3a\x0C\xA5V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a\x0C\xA5W`@Qc\xBFO\xDDs`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[PP\x80\x80a\x0C\xB2\x90a\x19\x8CV[\x91PPa\x0B\x97V[Pa\x06p3a\x0F\x96V[`\0`\x01`\x01`\xA0\x1B\x03\x83\x16\x15\x80a\x0C\xE3WP`\x01`\x01`\xA0\x1B\x03\x82\x16\x15[\x15a\x0C\xF0WP`\0a\x04BV[P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x04` R`@\x90 T\x82\x16\x91\x16\x14\x90V[`\0\x81\x81R`\x01` R`@\x81 a\x04B\x90a\x11\x9BV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\rB\x81a\x0F\x89V[\x81Q\x83\x14a\rcW`@Qc\xED\x88/q`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0[\x83\x81\x10\x15a\x0E=W\x82\x81\x81Q\x81\x10a\r\x80Wa\r\x80a\x19vV[` \x02` \x01\x01Q\x15a\r\xDEW`\x01\x85\x85\x83\x81\x81\x10a\r\xA1Wa\r\xA1a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\r\xB6\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x80Q` a\x1B\x06\x839\x81Q\x91R`@Q`@Q\x80\x91\x03\x90\xA3a\x0E+V[`\0\x85\x85\x83\x81\x81\x10a\r\xF2Wa\r\xF2a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x0E\x07\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x80Q` a\x1B\x06\x839\x81Q\x91R`@Q`@Q\x80\x91\x03\x90\xA3[\x80a\x0E5\x81a\x19\x8CV[\x91PPa\rfV[PPPPPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x0E\\\x81a\x0F\x89V[`\x05T`\xFF\x16a\x0E\x7FW`@Qc\xC4&8\xBB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x05\x80T`\xFF\x19\x16\x90U`@Q`\0\x90\x7F\x8B\xC8_%\xE3\xE93\x97\x8F\t\x94\x08\xB3\xBB>\xB7c\x0Bv\xF7E_. [\xCB\xC0\xA7\x80\xE1~r\x90\x82\x90\xA2PV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x0E\xCF\x81a\x0F\x89V[`\x05T`\xFF\x16\x15a\x0E\xF3W`@Qc\xED\x1A\x0Cw`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x05\x80T`\xFF\x19\x16`\x01\x90\x81\x17\x90\x91U`@Q\x7F\x8B\xC8_%\xE3\xE93\x97\x8F\t\x94\x08\xB3\xBB>\xB7c\x0Bv\xF7E_. [\xCB\xC0\xA7\x80\xE1~r\x90`\0\x90\xA2PV[`\0\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x0FJ\x81a\x0F\x89V[a\x05\xEC\x83\x83a\x10\x15V[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cye\xDB\x0B`\xE0\x1B\x14\x80a\x04BWPc\x01\xFF\xC9\xA7`\xE0\x1B`\x01`\x01`\xE0\x1B\x03\x19\x83\x16\x14a\x04BV[a\x0F\x93\x813a\x11\xA5V[PV[a\x0F\x9F\x81a\x107V[\x15a\x0F\xCCW`@Q`\x01\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90`\0\x80Q` a\x1B\x06\x839\x81Q\x91R\x90`\0\x90\xA3PV[`@Q`\0\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90`\0\x80Q` a\x1B\x06\x839\x81Q\x91R\x90\x83\x90\xA3PV[a\x0F\xFD\x82\x82a\x11\xFEV[`\0\x82\x81R`\x01` R`@\x90 a\x05\xEC\x90\x82a\x12\x82V[a\x10\x1F\x82\x82a\x12\x97V[`\0\x82\x81R`\x01` R`@\x90 a\x05\xEC\x90\x82a\x12\xFCV[`\x02T`@QcY\xAA'A`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R`\0\x92\x83\x92\x91\x16\x90c\xB3TN\x82\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x85W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xA9\x91\x90a\x194V[\x90P\x80`\0\x03a\x10\xBCWP`\0\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x90\x81R`\x03` R`@\x90 T\x81\x10a\x10\xE4WP`\x01\x92\x91PPV[P`\0\x92\x91PPV[`\x02T`@Qc6\x16\xB4\x11`\xE2\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x81\x16`\x04\x83\x01R\x83\x81\x16`$\x83\x01R`\0\x92\x16\x90c\xD8Z\xD0D\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11@W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11d\x91\x90a\x19\xBCV[\x90P\x80a\x05\xECW`@Qc\x07AIg`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[`\0a\x07\xE1\x83\x83a\x13\x11V[`\0a\x04B\x82T\x90V[a\x11\xAF\x82\x82a\x0B\x1AV[a\x06pWa\x11\xBC\x81a\x13;V[a\x11\xC7\x83` a\x13MV[`@Q` \x01a\x11\xD8\x92\x91\x90a\x19\xFDV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90RbF\x1B\xCD`\xE5\x1B\x82Ra\x06]\x91`\x04\x01a\x1ArV[a\x12\x08\x82\x82a\x0B\x1AV[a\x06pW`\0\x82\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x90 \x80T`\xFF\x19\x16`\x01\x17\x90Ua\x12>3\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x83\x7F/\x87\x88\x11~~\xFF\x1D\x82\xE9&\xECyI\x01\xD1|x\x02JP'\t@0E@\xA73eo\r`@Q`@Q\x80\x91\x03\x90\xA4PPV[`\0a\x07\xE1\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x14\xE9V[a\x12\xA1\x82\x82a\x0B\x1AV[\x15a\x06pW`\0\x82\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x80\x85R\x92R\x80\x83 \x80T`\xFF\x19\x16\x90UQ3\x92\x85\x91\x7F\xF69\x1F\\2\xD9\xC6\x9D*G\xEAg\x0BD)t\xB595\xD1\xED\xC7\xFDd\xEB!\xE0G\xA89\x17\x1B\x91\x90\xA4PPV[`\0a\x07\xE1\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x158V[`\0\x82`\0\x01\x82\x81T\x81\x10a\x13(Wa\x13(a\x19vV[\x90`\0R` `\0 \x01T\x90P\x92\x91PPV[``a\x04B`\x01`\x01`\xA0\x1B\x03\x83\x16`\x14[```\0a\x13\\\x83`\x02a\x1A\xA5V[a\x13g\x90`\x02a\x1A\xBCV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\x7FWa\x13\x7Fa\x18\x17V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x13\xA9W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P`\x03`\xFC\x1B\x81`\0\x81Q\x81\x10a\x13\xC4Wa\x13\xC4a\x19vV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\x0F`\xFB\x1B\x81`\x01\x81Q\x81\x10a\x13\xF3Wa\x13\xF3a\x19vV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\0a\x14\x17\x84`\x02a\x1A\xA5V[a\x14\"\x90`\x01a\x1A\xBCV[\x90P[`\x01\x81\x11\x15a\x14\x9AWo\x18\x18\x99\x19\x9A\x1A\x9B\x1B\x9C\x1C\xB0\xB11\xB22\xB3`\x81\x1B\x85`\x0F\x16`\x10\x81\x10a\x14VWa\x14Va\x19vV[\x1A`\xF8\x1B\x82\x82\x81Q\x81\x10a\x14lWa\x14la\x19vV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\x04\x94\x90\x94\x1C\x93a\x14\x93\x81a\x19\xA5V[\x90Pa\x14%V[P\x83\x15a\x07\xE1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FStrings: hex length insufficient`D\x82\x01R`d\x01a\x06]V[`\0\x81\x81R`\x01\x83\x01` R`@\x81 Ta\x150WP\x81T`\x01\x81\x81\x01\x84U`\0\x84\x81R` \x80\x82 \x90\x93\x01\x84\x90U\x84T\x84\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x04BV[P`\0a\x04BV[`\0\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a\x16!W`\0a\x15\\`\x01\x83a\x19cV[\x85T\x90\x91P`\0\x90a\x15p\x90`\x01\x90a\x19cV[\x90P\x81\x81\x14a\x15\xD5W`\0\x86`\0\x01\x82\x81T\x81\x10a\x15\x90Wa\x15\x90a\x19vV[\x90`\0R` `\0 \x01T\x90P\x80\x87`\0\x01\x84\x81T\x81\x10a\x15\xB3Wa\x15\xB3a\x19vV[`\0\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80a\x15\xE6Wa\x15\xE6a\x1A\xCFV[`\x01\x90\x03\x81\x81\x90`\0R` `\0 \x01`\0\x90U\x90U\x85`\x01\x01`\0\x86\x81R` \x01\x90\x81R` \x01`\0 `\0\x90U`\x01\x93PPPPa\x04BV[`\0\x91PPa\x04BV[`\0` \x82\x84\x03\x12\x15a\x16=W`\0\x80\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x07\xE1W`\0\x80\xFD[`\0` \x82\x84\x03\x12\x15a\x16gW`\0\x80\xFD[P5\x91\x90PV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\x85W`\0\x80\xFD[\x91\x90PV[`\0` \x82\x84\x03\x12\x15a\x16\x9CW`\0\x80\xFD[a\x07\xE1\x82a\x16nV[`\0\x80\x83`\x1F\x84\x01\x12a\x16\xB7W`\0\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xCFW`\0\x80\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x16\xEAW`\0\x80\xFD[\x92P\x92\x90PV[`\0\x80` \x83\x85\x03\x12\x15a\x17\x04W`\0\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\x1BW`\0\x80\xFD[a\x17'\x85\x82\x86\x01a\x16\xA5V[\x90\x96\x90\x95P\x93PPPPV[`\0\x80`@\x83\x85\x03\x12\x15a\x17FW`\0\x80\xFD[\x825\x91Pa\x17V` \x84\x01a\x16nV[\x90P\x92P\x92\x90PV[`\0\x80`\0\x80`@\x85\x87\x03\x12\x15a\x17uW`\0\x80\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x17\x8DW`\0\x80\xFD[a\x17\x99\x88\x83\x89\x01a\x16\xA5V[\x90\x96P\x94P` \x87\x015\x91P\x80\x82\x11\x15a\x17\xB2W`\0\x80\xFD[Pa\x17\xBF\x87\x82\x88\x01a\x16\xA5V[\x95\x98\x94\x97P\x95PPPPV[`\0\x80`@\x83\x85\x03\x12\x15a\x17\xDEW`\0\x80\xFD[PP\x805\x92` \x90\x91\x015\x91PV[`\0\x80`@\x83\x85\x03\x12\x15a\x18\0W`\0\x80\xFD[a\x18\t\x83a\x16nV[\x91Pa\x17V` \x84\x01a\x16nV[cNH{q`\xE0\x1B`\0R`A`\x04R`$`\0\xFD[\x80\x15\x15\x81\x14a\x0F\x93W`\0\x80\xFD[\x805a\x16\x85\x81a\x18-V[`\0\x80`\0`@\x84\x86\x03\x12\x15a\x18[W`\0\x80\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18sW`\0\x80\xFD[a\x18\x7F\x87\x83\x88\x01a\x16\xA5V[\x90\x95P\x93P` \x91P\x85\x82\x015\x81\x81\x11\x15a\x18\x99W`\0\x80\xFD[\x86\x01`\x1F\x81\x01\x88\x13a\x18\xAAW`\0\x80\xFD[\x805\x82\x81\x11\x15a\x18\xBCWa\x18\xBCa\x18\x17V[\x80`\x05\x1B`@Q`\x1F\x19`?\x83\x01\x16\x81\x01\x81\x81\x10\x86\x82\x11\x17\x15a\x18\xE1Wa\x18\xE1a\x18\x17V[`@R\x91\x82R\x84\x82\x01\x93P\x82\x81\x01\x85\x01\x91\x8A\x83\x11\x15a\x18\xFFW`\0\x80\xFD[\x92\x85\x01\x92[\x82\x84\x10\x15a\x19$Wa\x19\x15\x84a\x18;V[\x85R\x93\x85\x01\x93\x92\x85\x01\x92a\x19\x04V[\x80\x96PPPPPPP\x92P\x92P\x92V[`\0` \x82\x84\x03\x12\x15a\x19FW`\0\x80\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[\x81\x81\x03\x81\x81\x11\x15a\x04BWa\x04Ba\x19MV[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[`\0`\x01\x82\x01a\x19\x9EWa\x19\x9Ea\x19MV[P`\x01\x01\x90V[`\0\x81a\x19\xB4Wa\x19\xB4a\x19MV[P`\0\x19\x01\x90V[`\0` \x82\x84\x03\x12\x15a\x19\xCEW`\0\x80\xFD[\x81Qa\x07\xE1\x81a\x18-V[`\0[\x83\x81\x10\x15a\x19\xF4W\x81\x81\x01Q\x83\x82\x01R` \x01a\x19\xDCV[PP`\0\x91\x01RV[\x7FAccessControl: account \0\0\0\0\0\0\0\0\0\x81R`\0\x83Qa\x1A5\x81`\x17\x85\x01` \x88\x01a\x19\xD9V[p\x01\x03K\x99\x03kK\x9B\x9BKs9\x03\x93{c)`}\x1B`\x17\x91\x84\x01\x91\x82\x01R\x83Qa\x1Af\x81`(\x84\x01` \x88\x01a\x19\xD9V[\x01`(\x01\x94\x93PPPPV[` \x81R`\0\x82Q\x80` \x84\x01Ra\x1A\x91\x81`@\x85\x01` \x87\x01a\x19\xD9V[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x04BWa\x04Ba\x19MV[\x80\x82\x01\x80\x82\x11\x15a\x04BWa\x04Ba\x19MV[cNH{q`\xE0\x1B`\0R`1`\x04R`$`\0\xFD\xFE$\x1E\xCF\x16\xD7\x9D\x0F\x8D\xBF\xB9,\xBC\x07\xFE\x17\x84\x04%\x97l\xF0f\x7F\x02/\xE9\x87|\xAA\x83\x1B\x08\xE2\x99O\x8Do`\n\xD4s\xDB\xA8,\n\x89\n\xB7\xAF\xFA\xCB\x86\r3e\xF4t\xBA\xA3\xDC\x04\xA2\xE5W\xA2dipfsX\"\x12 \xEF\xA4.A\xA8\x01\x8Ezx\xD1D\x0FA\\X\x0C\xEB\xAF\xEEu\xB4<\x89B\xFEPg\xDA\xC9\xDC\x19#dsolcC\0\x08\x13\x003$\x1E\xCF\x16\xD7\x9D\x0F\x8D\xBF\xB9,\xBC\x07\xFE\x17\x84\x04%\x97l\xF0f\x7F\x02/\xE9\x87|\xAA\x83\x1B\x08",
816 );
817 #[rustfmt::skip]
823 #[allow(clippy::all)]
824 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
825 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x01\xC4W`\x005`\xE0\x1C\x80c\x90\x10\xD0|\x11a\0\xF9W\x80c\xCA\x15\xC8s\x11a\0\x97W\x80c\xCF\xB3s_\x11a\0qW\x80c\xCF\xB3s_\x14a\x03\xDAW\x80c\xD5Gt\x1F\x14a\x03\xE2W\x80c\xE3\xD2\xA0q\x14a\x03\xF5W\x80c\xEC\x87b\x1C\x14a\x04\x08W`\0\x80\xFD[\x80c\xCA\x15\xC8s\x14a\x03\xACW\x80c\xCA\xF5\xF5\x01\x14a\x03\xBFW\x80c\xCB\xEB\xAF\xE0\x14a\x03\xD2W`\0\x80\xFD[\x80c\xA0^\x0Fm\x11a\0\xD3W\x80c\xA0^\x0Fm\x14a\x03UW\x80c\xA2\x17\xFD\xDF\x14a\x03hW\x80c\xA5`]\xA5\x14a\x03pW\x80c\xC7\xEC\xAB\x8F\x14a\x03\x83W`\0\x80\xFD[\x80c\x90\x10\xD0|\x14a\x03\x0FW\x80c\x91\xD1HT\x14a\x03:W\x80c\x9C\x7Fd;\x14a\x03MW`\0\x80\xFD[\x80c6V\x8A\xBE\x11a\x01fW\x80cN\xB1\x80\\\x11a\x01@W\x80cN\xB1\x80\\\x14a\x02\xC3W\x80co\xFB\xF9\x88\x14a\x02\xD6W\x80cvY:9\x14a\x02\xE9W\x80c\x8Du;-\x14a\x02\xFCW`\0\x80\xFD[\x80c6V\x8A\xBE\x14a\x02}W\x80c?\xA5\x84W\x14a\x02\x90W\x80cA\xB6Ie\x14a\x02\xB0W`\0\x80\xFD[\x80c'\xB0@\xA1\x11a\x01\xA2W\x80c'\xB0@\xA1\x14a\x02/W\x80c*-\xEE\xE2\x14a\x02DW\x80c,3\xCA\xFB\x14a\x02WW\x80c//\xF1]\x14a\x02jW`\0\x80\xFD[\x80c\x01\xFF\xC9\xA7\x14a\x01\xC9W\x80c#\x8D\xAF\xE0\x14a\x01\xF1W\x80c$\x8A\x9C\xA3\x14a\x01\xFEW[`\0\x80\xFD[a\x01\xDCa\x01\xD76`\x04a\x16+V[a\x04\x1DV[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[`\x05Ta\x01\xDC\x90`\xFF\x16\x81V[a\x02!a\x02\x0C6`\x04a\x16UV[`\0\x90\x81R` \x81\x90R`@\x90 `\x01\x01T\x90V[`@Q\x90\x81R` \x01a\x01\xE8V[a\x02Ba\x02=6`\x04a\x16\x8AV[a\x04HV[\0[a\x02!a\x02R6`\x04a\x16\x8AV[a\x04\xABV[a\x02Ba\x02e6`\x04a\x16\xF1V[a\x05]V[a\x02Ba\x02x6`\x04a\x173V[a\x05\xC7V[a\x02Ba\x02\x8B6`\x04a\x173V[a\x05\xF1V[a\x02!a\x02\x9E6`\x04a\x16\x8AV[`\x03` R`\0\x90\x81R`@\x90 T\x81V[a\x02Ba\x02\xBE6`\x04a\x16\xF1V[a\x06tV[a\x01\xDCa\x02\xD16`\x04a\x16\x8AV[a\x07\x97V[a\x01\xDCa\x02\xE46`\x04a\x16\x8AV[a\x07\xE8V[a\x02Ba\x02\xF76`\x04a\x16\xF1V[a\x07\xF3V[a\x02Ba\x03\n6`\x04a\x17_V[a\t\x88V[a\x03\"a\x03\x1D6`\x04a\x17\xCBV[a\x0B\x02V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\xE8V[a\x01\xDCa\x03H6`\x04a\x173V[a\x0B\x1AV[a\x02Ba\x0BCV[a\x02Ba\x03c6`\x04a\x16\xF1V[a\x0BqV[a\x02!`\0\x81V[a\x01\xDCa\x03~6`\x04a\x17\xEDV[a\x0C\xC4V[a\x03\"a\x03\x916`\x04a\x16\x8AV[`\x04` R`\0\x90\x81R`@\x90 T`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x02!a\x03\xBA6`\x04a\x16UV[a\r\x13V[a\x02Ba\x03\xCD6`\x04a\x18FV[a\r*V[a\x02Ba\x0EDV[a\x02Ba\x0E\xB7V[a\x02Ba\x03\xF06`\x04a\x173V[a\x0F/V[`\x02Ta\x03\"\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x02!`\0\x80Q` a\x1A\xE6\x839\x81Q\x91R\x81V[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cZ\x05\x18\x0F`\xE0\x1B\x14\x80a\x04BWPa\x04B\x82a\x0FTV[\x92\x91PPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x04`\x81a\x0F\x89V[`\x02\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x84\x16\x90\x81\x17\x90\x91U`@Q\x7F\x8A\xC4\xB2\xEBwI\xF7\\[\x99\xB8\x98\xE5G\xFDa]\xD7\xA4$\xE6\x83V\xEA\x19k}\xAEt-l2\x90`\0\x90\xA2PPV[`\x02T`@QcY\xAA'A`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R`\0\x92\x83\x92\x91\x16\x90c\xB3TN\x82\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xF9W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x1D\x91\x90a\x194V[`\x01`\x01`\xA0\x1B\x03\x84\x16`\0\x90\x81R`\x03` R`@\x90 T\x90\x91P\x80\x82\x11\x15a\x05SWa\x05K\x81\x83a\x19cV[\x94\x93PPPPV[P`\0\x93\x92PPPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x05u\x81a\x0F\x89V[`\0[\x82\x81\x10\x15a\x05\xC1Wa\x05\xAF\x84\x84\x83\x81\x81\x10a\x05\x95Wa\x05\x95a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x05\xAA\x91\x90a\x16\x8AV[a\x0F\x96V[\x80a\x05\xB9\x81a\x19\x8CV[\x91PPa\x05xV[PPPPV[`\0\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x05\xE2\x81a\x0F\x89V[a\x05\xEC\x83\x83a\x0F\xF3V[PPPV[`\x01`\x01`\xA0\x1B\x03\x81\x163\x14a\x06fW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`/`$\x82\x01R\x7FAccessControl: can only renounce`D\x82\x01Rn\x1097\xB62\xB9\x9037\xB9\x109\xB2\xB63`\x89\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[a\x06p\x82\x82a\x10\x15V[PPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x06\x8C\x81a\x0F\x89V[`\0[\x82\x81\x10\x15a\x05\xC1W`\0\x84\x84\x83\x81\x81\x10a\x06\xABWa\x06\xABa\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x06\xC0\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x80\x82\x16`\0\x90\x81R`\x04` R`@\x90 T\x91\x92P\x16\x80a\x07\x07W`@Qc\x168y\x15`\xE3\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x03` R`@\x81 \x80T\x91a\x07+\x83a\x19\xA5V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\0\x81\x81R`\x04` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90UQ\x91\x92\x84\x16\x91\x7F\x91v\n\x10\x01\xF51\xEC+\xEE\x86\x02\xBEU\xAD+\x11YF^\xDF\xF5\xBB\xCDA\xD2\x07\x03t*MB\x91\x90\xA3PP\x80\x80a\x07\x8F\x90a\x19\x8CV[\x91PPa\x06\x8FV[`\0`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xAFWP`\0\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\0\x90\x81R`\x04` R`@\x90 T\x16\x80a\x07\xD8WP`\0\x92\x91PPV[a\x07\xE1\x81a\x107V[\x93\x92PPPV[`\0a\x04B\x82a\x107V[`\x05T`\xFF\x16a\x08\x16W`@Qc\xC4&8\xBB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0[\x81\x81\x10\x15a\tAW`\0\x83\x83\x83\x81\x81\x10a\x085Wa\x085a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x08J\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x80\x82\x16`\0\x90\x81R`\x04` R`@\x90 T\x91\x92P\x16a\x08r3\x83a\x10\xEDV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x08\xF8W3`\0\x90\x81R`\x03` R`@\x81 \x80T\x91a\x08\x9B\x83a\x19\x8CV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x81\x81R`\x04` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x163\x90\x81\x17\x90\x91U\x90Q\x90\x91\x7F\n1\xEE\x9DF\xA8(\x88K\x81\0<\x84\x98\x15n\xA6\xAA\x15\xB9\xB5K\xDD\x0E\xF0\xB53\xD9\xEB\xA5~U\x91\xA3a\t,V[`\x01`\x01`\xA0\x1B\x03\x81\x163\x14a\t,W`@Qc[S;\xA1`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[PP\x80\x80a\t9\x90a\x19\x8CV[\x91PPa\x08\x19V[Pa\tK3a\x107V[a\thW`@Qc\x03\xEEoW`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q`\x01\x903\x90`\0\x80Q` a\x1B\x06\x839\x81Q\x91R\x90`\0\x90\xA3PPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\t\xA0\x81a\x0F\x89V[\x83\x82\x14a\t\xC0W`@Qc\xED\x88/q`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0[\x84\x81\x10\x15a\n\xFAW`\0\x84\x84\x83\x81\x81\x10a\t\xDFWa\t\xDFa\x19vV[\x90P` \x02\x01` \x81\x01\x90a\t\xF4\x91\x90a\x16\x8AV[\x90P`\0\x87\x87\x84\x81\x81\x10a\n\nWa\n\na\x19vV[\x90P` \x02\x01` \x81\x01\x90a\n\x1F\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\0\x90\x81R`\x04` R`@\x90 T\x91\x92P\x16\x15a\nfW`@Qc[S;\xA1`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x03` R`@\x81 \x80T\x91a\n\x8A\x83a\x19\x8CV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\0\x81\x81R`\x04` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x94\x86\x16\x94\x85\x17\x90UQ\x91\x92\x91\x7F\x04\xE1\xEA\xA4\xDA\x18\xF7\xE7B\xA4\xED\xBB\xE9\xED\xE3l\xDFu\xF7\x93\xBB\x03\xAB!X\xC0\x87\x7F\x1C\xAF+\x93\x91\x90\xA3PP\x80\x80a\n\xF2\x90a\x19\x8CV[\x91PPa\t\xC3V[PPPPPPV[`\0\x82\x81R`\x01` R`@\x81 a\x07\xE1\x90\x83a\x11\x8FV[`\0\x91\x82R` \x82\x81R`@\x80\x84 `\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16\x84R\x91\x90R\x90 T`\xFF\x16\x90V[`\x05T`\xFF\x16a\x0BfW`@Qc\xC4&8\xBB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0Bo3a\x0F\x96V[V[`\x05T`\xFF\x16a\x0B\x94W`@Qc\xC4&8\xBB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0[\x81\x81\x10\x15a\x0C\xBAW`\0\x83\x83\x83\x81\x81\x10a\x0B\xB3Wa\x0B\xB3a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x0B\xC8\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x80\x82\x16`\0\x90\x81R`\x04` R`@\x90 T\x91\x92P\x16a\x0B\xF03\x83a\x10\xEDV[3`\x01`\x01`\xA0\x1B\x03\x82\x16\x03a\x0CrW3`\0\x90\x81R`\x03` R`@\x81 \x80T\x91a\x0C\x1B\x83a\x19\xA5V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x81\x81R`\x04` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90UQ3\x91\x7F\x15\x9A\x8A\xE9H\xFC\xC6\xE7\xF8\xB5I\\\rs\xE9\x15\x98D\n\xF8\xA6(\x17$l\t\xED\xC2\xC2\x8D\xBA\x8A\x91\xA3a\x0C\xA5V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a\x0C\xA5W`@Qc\xBFO\xDDs`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[PP\x80\x80a\x0C\xB2\x90a\x19\x8CV[\x91PPa\x0B\x97V[Pa\x06p3a\x0F\x96V[`\0`\x01`\x01`\xA0\x1B\x03\x83\x16\x15\x80a\x0C\xE3WP`\x01`\x01`\xA0\x1B\x03\x82\x16\x15[\x15a\x0C\xF0WP`\0a\x04BV[P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x04` R`@\x90 T\x82\x16\x91\x16\x14\x90V[`\0\x81\x81R`\x01` R`@\x81 a\x04B\x90a\x11\x9BV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\rB\x81a\x0F\x89V[\x81Q\x83\x14a\rcW`@Qc\xED\x88/q`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0[\x83\x81\x10\x15a\x0E=W\x82\x81\x81Q\x81\x10a\r\x80Wa\r\x80a\x19vV[` \x02` \x01\x01Q\x15a\r\xDEW`\x01\x85\x85\x83\x81\x81\x10a\r\xA1Wa\r\xA1a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\r\xB6\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x80Q` a\x1B\x06\x839\x81Q\x91R`@Q`@Q\x80\x91\x03\x90\xA3a\x0E+V[`\0\x85\x85\x83\x81\x81\x10a\r\xF2Wa\r\xF2a\x19vV[\x90P` \x02\x01` \x81\x01\x90a\x0E\x07\x91\x90a\x16\x8AV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x80Q` a\x1B\x06\x839\x81Q\x91R`@Q`@Q\x80\x91\x03\x90\xA3[\x80a\x0E5\x81a\x19\x8CV[\x91PPa\rfV[PPPPPV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x0E\\\x81a\x0F\x89V[`\x05T`\xFF\x16a\x0E\x7FW`@Qc\xC4&8\xBB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x05\x80T`\xFF\x19\x16\x90U`@Q`\0\x90\x7F\x8B\xC8_%\xE3\xE93\x97\x8F\t\x94\x08\xB3\xBB>\xB7c\x0Bv\xF7E_. [\xCB\xC0\xA7\x80\xE1~r\x90\x82\x90\xA2PV[`\0\x80Q` a\x1A\xE6\x839\x81Q\x91Ra\x0E\xCF\x81a\x0F\x89V[`\x05T`\xFF\x16\x15a\x0E\xF3W`@Qc\xED\x1A\x0Cw`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x05\x80T`\xFF\x19\x16`\x01\x90\x81\x17\x90\x91U`@Q\x7F\x8B\xC8_%\xE3\xE93\x97\x8F\t\x94\x08\xB3\xBB>\xB7c\x0Bv\xF7E_. [\xCB\xC0\xA7\x80\xE1~r\x90`\0\x90\xA2PV[`\0\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x0FJ\x81a\x0F\x89V[a\x05\xEC\x83\x83a\x10\x15V[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cye\xDB\x0B`\xE0\x1B\x14\x80a\x04BWPc\x01\xFF\xC9\xA7`\xE0\x1B`\x01`\x01`\xE0\x1B\x03\x19\x83\x16\x14a\x04BV[a\x0F\x93\x813a\x11\xA5V[PV[a\x0F\x9F\x81a\x107V[\x15a\x0F\xCCW`@Q`\x01\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90`\0\x80Q` a\x1B\x06\x839\x81Q\x91R\x90`\0\x90\xA3PV[`@Q`\0\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90`\0\x80Q` a\x1B\x06\x839\x81Q\x91R\x90\x83\x90\xA3PV[a\x0F\xFD\x82\x82a\x11\xFEV[`\0\x82\x81R`\x01` R`@\x90 a\x05\xEC\x90\x82a\x12\x82V[a\x10\x1F\x82\x82a\x12\x97V[`\0\x82\x81R`\x01` R`@\x90 a\x05\xEC\x90\x82a\x12\xFCV[`\x02T`@QcY\xAA'A`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R`\0\x92\x83\x92\x91\x16\x90c\xB3TN\x82\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x85W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xA9\x91\x90a\x194V[\x90P\x80`\0\x03a\x10\xBCWP`\0\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x90\x81R`\x03` R`@\x90 T\x81\x10a\x10\xE4WP`\x01\x92\x91PPV[P`\0\x92\x91PPV[`\x02T`@Qc6\x16\xB4\x11`\xE2\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x81\x16`\x04\x83\x01R\x83\x81\x16`$\x83\x01R`\0\x92\x16\x90c\xD8Z\xD0D\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11@W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11d\x91\x90a\x19\xBCV[\x90P\x80a\x05\xECW`@Qc\x07AIg`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06]V[`\0a\x07\xE1\x83\x83a\x13\x11V[`\0a\x04B\x82T\x90V[a\x11\xAF\x82\x82a\x0B\x1AV[a\x06pWa\x11\xBC\x81a\x13;V[a\x11\xC7\x83` a\x13MV[`@Q` \x01a\x11\xD8\x92\x91\x90a\x19\xFDV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90RbF\x1B\xCD`\xE5\x1B\x82Ra\x06]\x91`\x04\x01a\x1ArV[a\x12\x08\x82\x82a\x0B\x1AV[a\x06pW`\0\x82\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x90 \x80T`\xFF\x19\x16`\x01\x17\x90Ua\x12>3\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x83\x7F/\x87\x88\x11~~\xFF\x1D\x82\xE9&\xECyI\x01\xD1|x\x02JP'\t@0E@\xA73eo\r`@Q`@Q\x80\x91\x03\x90\xA4PPV[`\0a\x07\xE1\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x14\xE9V[a\x12\xA1\x82\x82a\x0B\x1AV[\x15a\x06pW`\0\x82\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x80\x85R\x92R\x80\x83 \x80T`\xFF\x19\x16\x90UQ3\x92\x85\x91\x7F\xF69\x1F\\2\xD9\xC6\x9D*G\xEAg\x0BD)t\xB595\xD1\xED\xC7\xFDd\xEB!\xE0G\xA89\x17\x1B\x91\x90\xA4PPV[`\0a\x07\xE1\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x158V[`\0\x82`\0\x01\x82\x81T\x81\x10a\x13(Wa\x13(a\x19vV[\x90`\0R` `\0 \x01T\x90P\x92\x91PPV[``a\x04B`\x01`\x01`\xA0\x1B\x03\x83\x16`\x14[```\0a\x13\\\x83`\x02a\x1A\xA5V[a\x13g\x90`\x02a\x1A\xBCV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\x7FWa\x13\x7Fa\x18\x17V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x13\xA9W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P`\x03`\xFC\x1B\x81`\0\x81Q\x81\x10a\x13\xC4Wa\x13\xC4a\x19vV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\x0F`\xFB\x1B\x81`\x01\x81Q\x81\x10a\x13\xF3Wa\x13\xF3a\x19vV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\0a\x14\x17\x84`\x02a\x1A\xA5V[a\x14\"\x90`\x01a\x1A\xBCV[\x90P[`\x01\x81\x11\x15a\x14\x9AWo\x18\x18\x99\x19\x9A\x1A\x9B\x1B\x9C\x1C\xB0\xB11\xB22\xB3`\x81\x1B\x85`\x0F\x16`\x10\x81\x10a\x14VWa\x14Va\x19vV[\x1A`\xF8\x1B\x82\x82\x81Q\x81\x10a\x14lWa\x14la\x19vV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\x04\x94\x90\x94\x1C\x93a\x14\x93\x81a\x19\xA5V[\x90Pa\x14%V[P\x83\x15a\x07\xE1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FStrings: hex length insufficient`D\x82\x01R`d\x01a\x06]V[`\0\x81\x81R`\x01\x83\x01` R`@\x81 Ta\x150WP\x81T`\x01\x81\x81\x01\x84U`\0\x84\x81R` \x80\x82 \x90\x93\x01\x84\x90U\x84T\x84\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x04BV[P`\0a\x04BV[`\0\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a\x16!W`\0a\x15\\`\x01\x83a\x19cV[\x85T\x90\x91P`\0\x90a\x15p\x90`\x01\x90a\x19cV[\x90P\x81\x81\x14a\x15\xD5W`\0\x86`\0\x01\x82\x81T\x81\x10a\x15\x90Wa\x15\x90a\x19vV[\x90`\0R` `\0 \x01T\x90P\x80\x87`\0\x01\x84\x81T\x81\x10a\x15\xB3Wa\x15\xB3a\x19vV[`\0\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80a\x15\xE6Wa\x15\xE6a\x1A\xCFV[`\x01\x90\x03\x81\x81\x90`\0R` `\0 \x01`\0\x90U\x90U\x85`\x01\x01`\0\x86\x81R` \x01\x90\x81R` \x01`\0 `\0\x90U`\x01\x93PPPPa\x04BV[`\0\x91PPa\x04BV[`\0` \x82\x84\x03\x12\x15a\x16=W`\0\x80\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x07\xE1W`\0\x80\xFD[`\0` \x82\x84\x03\x12\x15a\x16gW`\0\x80\xFD[P5\x91\x90PV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\x85W`\0\x80\xFD[\x91\x90PV[`\0` \x82\x84\x03\x12\x15a\x16\x9CW`\0\x80\xFD[a\x07\xE1\x82a\x16nV[`\0\x80\x83`\x1F\x84\x01\x12a\x16\xB7W`\0\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xCFW`\0\x80\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x16\xEAW`\0\x80\xFD[\x92P\x92\x90PV[`\0\x80` \x83\x85\x03\x12\x15a\x17\x04W`\0\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\x1BW`\0\x80\xFD[a\x17'\x85\x82\x86\x01a\x16\xA5V[\x90\x96\x90\x95P\x93PPPPV[`\0\x80`@\x83\x85\x03\x12\x15a\x17FW`\0\x80\xFD[\x825\x91Pa\x17V` \x84\x01a\x16nV[\x90P\x92P\x92\x90PV[`\0\x80`\0\x80`@\x85\x87\x03\x12\x15a\x17uW`\0\x80\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x17\x8DW`\0\x80\xFD[a\x17\x99\x88\x83\x89\x01a\x16\xA5V[\x90\x96P\x94P` \x87\x015\x91P\x80\x82\x11\x15a\x17\xB2W`\0\x80\xFD[Pa\x17\xBF\x87\x82\x88\x01a\x16\xA5V[\x95\x98\x94\x97P\x95PPPPV[`\0\x80`@\x83\x85\x03\x12\x15a\x17\xDEW`\0\x80\xFD[PP\x805\x92` \x90\x91\x015\x91PV[`\0\x80`@\x83\x85\x03\x12\x15a\x18\0W`\0\x80\xFD[a\x18\t\x83a\x16nV[\x91Pa\x17V` \x84\x01a\x16nV[cNH{q`\xE0\x1B`\0R`A`\x04R`$`\0\xFD[\x80\x15\x15\x81\x14a\x0F\x93W`\0\x80\xFD[\x805a\x16\x85\x81a\x18-V[`\0\x80`\0`@\x84\x86\x03\x12\x15a\x18[W`\0\x80\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18sW`\0\x80\xFD[a\x18\x7F\x87\x83\x88\x01a\x16\xA5V[\x90\x95P\x93P` \x91P\x85\x82\x015\x81\x81\x11\x15a\x18\x99W`\0\x80\xFD[\x86\x01`\x1F\x81\x01\x88\x13a\x18\xAAW`\0\x80\xFD[\x805\x82\x81\x11\x15a\x18\xBCWa\x18\xBCa\x18\x17V[\x80`\x05\x1B`@Q`\x1F\x19`?\x83\x01\x16\x81\x01\x81\x81\x10\x86\x82\x11\x17\x15a\x18\xE1Wa\x18\xE1a\x18\x17V[`@R\x91\x82R\x84\x82\x01\x93P\x82\x81\x01\x85\x01\x91\x8A\x83\x11\x15a\x18\xFFW`\0\x80\xFD[\x92\x85\x01\x92[\x82\x84\x10\x15a\x19$Wa\x19\x15\x84a\x18;V[\x85R\x93\x85\x01\x93\x92\x85\x01\x92a\x19\x04V[\x80\x96PPPPPPP\x92P\x92P\x92V[`\0` \x82\x84\x03\x12\x15a\x19FW`\0\x80\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[\x81\x81\x03\x81\x81\x11\x15a\x04BWa\x04Ba\x19MV[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[`\0`\x01\x82\x01a\x19\x9EWa\x19\x9Ea\x19MV[P`\x01\x01\x90V[`\0\x81a\x19\xB4Wa\x19\xB4a\x19MV[P`\0\x19\x01\x90V[`\0` \x82\x84\x03\x12\x15a\x19\xCEW`\0\x80\xFD[\x81Qa\x07\xE1\x81a\x18-V[`\0[\x83\x81\x10\x15a\x19\xF4W\x81\x81\x01Q\x83\x82\x01R` \x01a\x19\xDCV[PP`\0\x91\x01RV[\x7FAccessControl: account \0\0\0\0\0\0\0\0\0\x81R`\0\x83Qa\x1A5\x81`\x17\x85\x01` \x88\x01a\x19\xD9V[p\x01\x03K\x99\x03kK\x9B\x9BKs9\x03\x93{c)`}\x1B`\x17\x91\x84\x01\x91\x82\x01R\x83Qa\x1Af\x81`(\x84\x01` \x88\x01a\x19\xD9V[\x01`(\x01\x94\x93PPPPV[` \x81R`\0\x82Q\x80` \x84\x01Ra\x1A\x91\x81`@\x85\x01` \x87\x01a\x19\xD9V[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x04BWa\x04Ba\x19MV[\x80\x82\x01\x80\x82\x11\x15a\x04BWa\x04Ba\x19MV[cNH{q`\xE0\x1B`\0R`1`\x04R`$`\0\xFD\xFE$\x1E\xCF\x16\xD7\x9D\x0F\x8D\xBF\xB9,\xBC\x07\xFE\x17\x84\x04%\x97l\xF0f\x7F\x02/\xE9\x87|\xAA\x83\x1B\x08\xE2\x99O\x8Do`\n\xD4s\xDB\xA8,\n\x89\n\xB7\xAF\xFA\xCB\x86\r3e\xF4t\xBA\xA3\xDC\x04\xA2\xE5W\xA2dipfsX\"\x12 \xEF\xA4.A\xA8\x01\x8Ezx\xD1D\x0FA\\X\x0C\xEB\xAF\xEEu\xB4<\x89B\xFEPg\xDA\xC9\xDC\x19#dsolcC\0\x08\x13\x003",
826 );
827 #[derive(serde::Serialize, serde::Deserialize)]
828 #[derive(Default, Debug, PartialEq, Eq, Hash)]
829 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
834 #[derive(Clone)]
835 pub struct ArrayLengthNotMatch;
836 #[allow(
837 non_camel_case_types,
838 non_snake_case,
839 clippy::pub_underscore_fields,
840 clippy::style
841 )]
842 const _: () = {
843 use alloy::sol_types as alloy_sol_types;
844 #[doc(hidden)]
845 type UnderlyingSolTuple<'a> = ();
846 #[doc(hidden)]
847 type UnderlyingRustTuple<'a> = ();
848 #[cfg(test)]
849 #[allow(dead_code, unreachable_patterns)]
850 fn _type_assertion(
851 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
852 ) {
853 match _t {
854 alloy_sol_types::private::AssertTypeEq::<
855 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
856 >(_) => {}
857 }
858 }
859 #[automatically_derived]
860 #[doc(hidden)]
861 impl ::core::convert::From<ArrayLengthNotMatch> for UnderlyingRustTuple<'_> {
862 fn from(value: ArrayLengthNotMatch) -> Self {
863 ()
864 }
865 }
866 #[automatically_derived]
867 #[doc(hidden)]
868 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ArrayLengthNotMatch {
869 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
870 Self
871 }
872 }
873 #[automatically_derived]
874 impl alloy_sol_types::SolError for ArrayLengthNotMatch {
875 type Parameters<'a> = UnderlyingSolTuple<'a>;
876 type Token<'a> = <Self::Parameters<
877 'a,
878 > as alloy_sol_types::SolType>::Token<'a>;
879 const SIGNATURE: &'static str = "ArrayLengthNotMatch()";
880 const SELECTOR: [u8; 4] = [237u8, 136u8, 47u8, 113u8];
881 #[inline]
882 fn new<'a>(
883 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
884 ) -> Self {
885 tuple.into()
886 }
887 #[inline]
888 fn tokenize(&self) -> Self::Token<'_> {
889 ()
890 }
891 #[inline]
892 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
893 <Self::Parameters<
894 '_,
895 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
896 .map(Self::new)
897 }
898 }
899 };
900 #[derive(serde::Serialize, serde::Deserialize)]
901 #[derive(Default, Debug, PartialEq, Eq, Hash)]
902 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
907 #[derive(Clone)]
908 pub struct CannotOperateForNode {
909 #[allow(missing_docs)]
910 pub nodeAddress: alloy::sol_types::private::Address,
911 }
912 #[allow(
913 non_camel_case_types,
914 non_snake_case,
915 clippy::pub_underscore_fields,
916 clippy::style
917 )]
918 const _: () = {
919 use alloy::sol_types as alloy_sol_types;
920 #[doc(hidden)]
921 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
922 #[doc(hidden)]
923 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
924 #[cfg(test)]
925 #[allow(dead_code, unreachable_patterns)]
926 fn _type_assertion(
927 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
928 ) {
929 match _t {
930 alloy_sol_types::private::AssertTypeEq::<
931 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
932 >(_) => {}
933 }
934 }
935 #[automatically_derived]
936 #[doc(hidden)]
937 impl ::core::convert::From<CannotOperateForNode> for UnderlyingRustTuple<'_> {
938 fn from(value: CannotOperateForNode) -> Self {
939 (value.nodeAddress,)
940 }
941 }
942 #[automatically_derived]
943 #[doc(hidden)]
944 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CannotOperateForNode {
945 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
946 Self { nodeAddress: tuple.0 }
947 }
948 }
949 #[automatically_derived]
950 impl alloy_sol_types::SolError for CannotOperateForNode {
951 type Parameters<'a> = UnderlyingSolTuple<'a>;
952 type Token<'a> = <Self::Parameters<
953 'a,
954 > as alloy_sol_types::SolType>::Token<'a>;
955 const SIGNATURE: &'static str = "CannotOperateForNode(address)";
956 const SELECTOR: [u8; 4] = [7u8, 65u8, 73u8, 103u8];
957 #[inline]
958 fn new<'a>(
959 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
960 ) -> Self {
961 tuple.into()
962 }
963 #[inline]
964 fn tokenize(&self) -> Self::Token<'_> {
965 (
966 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
967 &self.nodeAddress,
968 ),
969 )
970 }
971 #[inline]
972 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
973 <Self::Parameters<
974 '_,
975 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
976 .map(Self::new)
977 }
978 }
979 };
980 #[derive(serde::Serialize, serde::Deserialize)]
981 #[derive(Default, Debug, PartialEq, Eq, Hash)]
982 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
987 #[derive(Clone)]
988 pub struct GloballyDisabledRegistry;
989 #[allow(
990 non_camel_case_types,
991 non_snake_case,
992 clippy::pub_underscore_fields,
993 clippy::style
994 )]
995 const _: () = {
996 use alloy::sol_types as alloy_sol_types;
997 #[doc(hidden)]
998 type UnderlyingSolTuple<'a> = ();
999 #[doc(hidden)]
1000 type UnderlyingRustTuple<'a> = ();
1001 #[cfg(test)]
1002 #[allow(dead_code, unreachable_patterns)]
1003 fn _type_assertion(
1004 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1005 ) {
1006 match _t {
1007 alloy_sol_types::private::AssertTypeEq::<
1008 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1009 >(_) => {}
1010 }
1011 }
1012 #[automatically_derived]
1013 #[doc(hidden)]
1014 impl ::core::convert::From<GloballyDisabledRegistry>
1015 for UnderlyingRustTuple<'_> {
1016 fn from(value: GloballyDisabledRegistry) -> Self {
1017 ()
1018 }
1019 }
1020 #[automatically_derived]
1021 #[doc(hidden)]
1022 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1023 for GloballyDisabledRegistry {
1024 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1025 Self
1026 }
1027 }
1028 #[automatically_derived]
1029 impl alloy_sol_types::SolError for GloballyDisabledRegistry {
1030 type Parameters<'a> = UnderlyingSolTuple<'a>;
1031 type Token<'a> = <Self::Parameters<
1032 'a,
1033 > as alloy_sol_types::SolType>::Token<'a>;
1034 const SIGNATURE: &'static str = "GloballyDisabledRegistry()";
1035 const SELECTOR: [u8; 4] = [196u8, 38u8, 56u8, 187u8];
1036 #[inline]
1037 fn new<'a>(
1038 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1039 ) -> Self {
1040 tuple.into()
1041 }
1042 #[inline]
1043 fn tokenize(&self) -> Self::Token<'_> {
1044 ()
1045 }
1046 #[inline]
1047 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1048 <Self::Parameters<
1049 '_,
1050 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1051 .map(Self::new)
1052 }
1053 }
1054 };
1055 #[derive(serde::Serialize, serde::Deserialize)]
1056 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1057 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1062 #[derive(Clone)]
1063 pub struct GloballyEnabledRegistry;
1064 #[allow(
1065 non_camel_case_types,
1066 non_snake_case,
1067 clippy::pub_underscore_fields,
1068 clippy::style
1069 )]
1070 const _: () = {
1071 use alloy::sol_types as alloy_sol_types;
1072 #[doc(hidden)]
1073 type UnderlyingSolTuple<'a> = ();
1074 #[doc(hidden)]
1075 type UnderlyingRustTuple<'a> = ();
1076 #[cfg(test)]
1077 #[allow(dead_code, unreachable_patterns)]
1078 fn _type_assertion(
1079 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1080 ) {
1081 match _t {
1082 alloy_sol_types::private::AssertTypeEq::<
1083 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1084 >(_) => {}
1085 }
1086 }
1087 #[automatically_derived]
1088 #[doc(hidden)]
1089 impl ::core::convert::From<GloballyEnabledRegistry> for UnderlyingRustTuple<'_> {
1090 fn from(value: GloballyEnabledRegistry) -> Self {
1091 ()
1092 }
1093 }
1094 #[automatically_derived]
1095 #[doc(hidden)]
1096 impl ::core::convert::From<UnderlyingRustTuple<'_>> for GloballyEnabledRegistry {
1097 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1098 Self
1099 }
1100 }
1101 #[automatically_derived]
1102 impl alloy_sol_types::SolError for GloballyEnabledRegistry {
1103 type Parameters<'a> = UnderlyingSolTuple<'a>;
1104 type Token<'a> = <Self::Parameters<
1105 'a,
1106 > as alloy_sol_types::SolType>::Token<'a>;
1107 const SIGNATURE: &'static str = "GloballyEnabledRegistry()";
1108 const SELECTOR: [u8; 4] = [237u8, 26u8, 12u8, 119u8];
1109 #[inline]
1110 fn new<'a>(
1111 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1112 ) -> Self {
1113 tuple.into()
1114 }
1115 #[inline]
1116 fn tokenize(&self) -> Self::Token<'_> {
1117 ()
1118 }
1119 #[inline]
1120 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1121 <Self::Parameters<
1122 '_,
1123 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1124 .map(Self::new)
1125 }
1126 }
1127 };
1128 #[derive(serde::Serialize, serde::Deserialize)]
1129 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1130 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1135 #[derive(Clone)]
1136 pub struct NodeAlreadyRegisterd {
1137 #[allow(missing_docs)]
1138 pub nodeAddress: alloy::sol_types::private::Address,
1139 }
1140 #[allow(
1141 non_camel_case_types,
1142 non_snake_case,
1143 clippy::pub_underscore_fields,
1144 clippy::style
1145 )]
1146 const _: () = {
1147 use alloy::sol_types as alloy_sol_types;
1148 #[doc(hidden)]
1149 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1150 #[doc(hidden)]
1151 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1152 #[cfg(test)]
1153 #[allow(dead_code, unreachable_patterns)]
1154 fn _type_assertion(
1155 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1156 ) {
1157 match _t {
1158 alloy_sol_types::private::AssertTypeEq::<
1159 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1160 >(_) => {}
1161 }
1162 }
1163 #[automatically_derived]
1164 #[doc(hidden)]
1165 impl ::core::convert::From<NodeAlreadyRegisterd> for UnderlyingRustTuple<'_> {
1166 fn from(value: NodeAlreadyRegisterd) -> Self {
1167 (value.nodeAddress,)
1168 }
1169 }
1170 #[automatically_derived]
1171 #[doc(hidden)]
1172 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NodeAlreadyRegisterd {
1173 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1174 Self { nodeAddress: tuple.0 }
1175 }
1176 }
1177 #[automatically_derived]
1178 impl alloy_sol_types::SolError for NodeAlreadyRegisterd {
1179 type Parameters<'a> = UnderlyingSolTuple<'a>;
1180 type Token<'a> = <Self::Parameters<
1181 'a,
1182 > as alloy_sol_types::SolType>::Token<'a>;
1183 const SIGNATURE: &'static str = "NodeAlreadyRegisterd(address)";
1184 const SELECTOR: [u8; 4] = [91u8, 83u8, 59u8, 161u8];
1185 #[inline]
1186 fn new<'a>(
1187 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1188 ) -> Self {
1189 tuple.into()
1190 }
1191 #[inline]
1192 fn tokenize(&self) -> Self::Token<'_> {
1193 (
1194 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1195 &self.nodeAddress,
1196 ),
1197 )
1198 }
1199 #[inline]
1200 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1201 <Self::Parameters<
1202 '_,
1203 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1204 .map(Self::new)
1205 }
1206 }
1207 };
1208 #[derive(serde::Serialize, serde::Deserialize)]
1209 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1210 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1215 #[derive(Clone)]
1216 pub struct NodeNotYetRegisterd {
1217 #[allow(missing_docs)]
1218 pub nodeAddress: alloy::sol_types::private::Address,
1219 }
1220 #[allow(
1221 non_camel_case_types,
1222 non_snake_case,
1223 clippy::pub_underscore_fields,
1224 clippy::style
1225 )]
1226 const _: () = {
1227 use alloy::sol_types as alloy_sol_types;
1228 #[doc(hidden)]
1229 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1230 #[doc(hidden)]
1231 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1232 #[cfg(test)]
1233 #[allow(dead_code, unreachable_patterns)]
1234 fn _type_assertion(
1235 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1236 ) {
1237 match _t {
1238 alloy_sol_types::private::AssertTypeEq::<
1239 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1240 >(_) => {}
1241 }
1242 }
1243 #[automatically_derived]
1244 #[doc(hidden)]
1245 impl ::core::convert::From<NodeNotYetRegisterd> for UnderlyingRustTuple<'_> {
1246 fn from(value: NodeNotYetRegisterd) -> Self {
1247 (value.nodeAddress,)
1248 }
1249 }
1250 #[automatically_derived]
1251 #[doc(hidden)]
1252 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NodeNotYetRegisterd {
1253 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1254 Self { nodeAddress: tuple.0 }
1255 }
1256 }
1257 #[automatically_derived]
1258 impl alloy_sol_types::SolError for NodeNotYetRegisterd {
1259 type Parameters<'a> = UnderlyingSolTuple<'a>;
1260 type Token<'a> = <Self::Parameters<
1261 'a,
1262 > as alloy_sol_types::SolType>::Token<'a>;
1263 const SIGNATURE: &'static str = "NodeNotYetRegisterd(address)";
1264 const SELECTOR: [u8; 4] = [177u8, 195u8, 200u8, 168u8];
1265 #[inline]
1266 fn new<'a>(
1267 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1268 ) -> Self {
1269 tuple.into()
1270 }
1271 #[inline]
1272 fn tokenize(&self) -> Self::Token<'_> {
1273 (
1274 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1275 &self.nodeAddress,
1276 ),
1277 )
1278 }
1279 #[inline]
1280 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1281 <Self::Parameters<
1282 '_,
1283 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1284 .map(Self::new)
1285 }
1286 }
1287 };
1288 #[derive(serde::Serialize, serde::Deserialize)]
1289 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1290 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1295 #[derive(Clone)]
1296 pub struct NodeRegisterdToOtherAccount {
1297 #[allow(missing_docs)]
1298 pub nodeAddress: alloy::sol_types::private::Address,
1299 }
1300 #[allow(
1301 non_camel_case_types,
1302 non_snake_case,
1303 clippy::pub_underscore_fields,
1304 clippy::style
1305 )]
1306 const _: () = {
1307 use alloy::sol_types as alloy_sol_types;
1308 #[doc(hidden)]
1309 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1310 #[doc(hidden)]
1311 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1312 #[cfg(test)]
1313 #[allow(dead_code, unreachable_patterns)]
1314 fn _type_assertion(
1315 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1316 ) {
1317 match _t {
1318 alloy_sol_types::private::AssertTypeEq::<
1319 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1320 >(_) => {}
1321 }
1322 }
1323 #[automatically_derived]
1324 #[doc(hidden)]
1325 impl ::core::convert::From<NodeRegisterdToOtherAccount>
1326 for UnderlyingRustTuple<'_> {
1327 fn from(value: NodeRegisterdToOtherAccount) -> Self {
1328 (value.nodeAddress,)
1329 }
1330 }
1331 #[automatically_derived]
1332 #[doc(hidden)]
1333 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1334 for NodeRegisterdToOtherAccount {
1335 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1336 Self { nodeAddress: tuple.0 }
1337 }
1338 }
1339 #[automatically_derived]
1340 impl alloy_sol_types::SolError for NodeRegisterdToOtherAccount {
1341 type Parameters<'a> = UnderlyingSolTuple<'a>;
1342 type Token<'a> = <Self::Parameters<
1343 'a,
1344 > as alloy_sol_types::SolType>::Token<'a>;
1345 const SIGNATURE: &'static str = "NodeRegisterdToOtherAccount(address)";
1346 const SELECTOR: [u8; 4] = [191u8, 79u8, 221u8, 115u8];
1347 #[inline]
1348 fn new<'a>(
1349 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1350 ) -> Self {
1351 tuple.into()
1352 }
1353 #[inline]
1354 fn tokenize(&self) -> Self::Token<'_> {
1355 (
1356 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1357 &self.nodeAddress,
1358 ),
1359 )
1360 }
1361 #[inline]
1362 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1363 <Self::Parameters<
1364 '_,
1365 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1366 .map(Self::new)
1367 }
1368 }
1369 };
1370 #[derive(serde::Serialize, serde::Deserialize)]
1371 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1372 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1377 #[derive(Clone)]
1378 pub struct NotEnoughAllowanceToRegisterNode;
1379 #[allow(
1380 non_camel_case_types,
1381 non_snake_case,
1382 clippy::pub_underscore_fields,
1383 clippy::style
1384 )]
1385 const _: () = {
1386 use alloy::sol_types as alloy_sol_types;
1387 #[doc(hidden)]
1388 type UnderlyingSolTuple<'a> = ();
1389 #[doc(hidden)]
1390 type UnderlyingRustTuple<'a> = ();
1391 #[cfg(test)]
1392 #[allow(dead_code, unreachable_patterns)]
1393 fn _type_assertion(
1394 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1395 ) {
1396 match _t {
1397 alloy_sol_types::private::AssertTypeEq::<
1398 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1399 >(_) => {}
1400 }
1401 }
1402 #[automatically_derived]
1403 #[doc(hidden)]
1404 impl ::core::convert::From<NotEnoughAllowanceToRegisterNode>
1405 for UnderlyingRustTuple<'_> {
1406 fn from(value: NotEnoughAllowanceToRegisterNode) -> Self {
1407 ()
1408 }
1409 }
1410 #[automatically_derived]
1411 #[doc(hidden)]
1412 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1413 for NotEnoughAllowanceToRegisterNode {
1414 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1415 Self
1416 }
1417 }
1418 #[automatically_derived]
1419 impl alloy_sol_types::SolError for NotEnoughAllowanceToRegisterNode {
1420 type Parameters<'a> = UnderlyingSolTuple<'a>;
1421 type Token<'a> = <Self::Parameters<
1422 'a,
1423 > as alloy_sol_types::SolType>::Token<'a>;
1424 const SIGNATURE: &'static str = "NotEnoughAllowanceToRegisterNode()";
1425 const SELECTOR: [u8; 4] = [15u8, 185u8, 189u8, 92u8];
1426 #[inline]
1427 fn new<'a>(
1428 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1429 ) -> Self {
1430 tuple.into()
1431 }
1432 #[inline]
1433 fn tokenize(&self) -> Self::Token<'_> {
1434 ()
1435 }
1436 #[inline]
1437 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1438 <Self::Parameters<
1439 '_,
1440 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1441 .map(Self::new)
1442 }
1443 }
1444 };
1445 #[derive(serde::Serialize, serde::Deserialize)]
1446 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1447 #[allow(
1452 non_camel_case_types,
1453 non_snake_case,
1454 clippy::pub_underscore_fields,
1455 clippy::style
1456 )]
1457 #[derive(Clone)]
1458 pub struct Deregistered {
1459 #[allow(missing_docs)]
1460 pub stakingAccount: alloy::sol_types::private::Address,
1461 #[allow(missing_docs)]
1462 pub nodeAddress: alloy::sol_types::private::Address,
1463 }
1464 #[allow(
1465 non_camel_case_types,
1466 non_snake_case,
1467 clippy::pub_underscore_fields,
1468 clippy::style
1469 )]
1470 const _: () = {
1471 use alloy::sol_types as alloy_sol_types;
1472 #[automatically_derived]
1473 impl alloy_sol_types::SolEvent for Deregistered {
1474 type DataTuple<'a> = ();
1475 type DataToken<'a> = <Self::DataTuple<
1476 'a,
1477 > as alloy_sol_types::SolType>::Token<'a>;
1478 type TopicList = (
1479 alloy_sol_types::sol_data::FixedBytes<32>,
1480 alloy::sol_types::sol_data::Address,
1481 alloy::sol_types::sol_data::Address,
1482 );
1483 const SIGNATURE: &'static str = "Deregistered(address,address)";
1484 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1485 21u8, 154u8, 138u8, 233u8, 72u8, 252u8, 198u8, 231u8, 248u8, 181u8, 73u8,
1486 92u8, 13u8, 115u8, 233u8, 21u8, 152u8, 68u8, 10u8, 248u8, 166u8, 40u8,
1487 23u8, 36u8, 108u8, 9u8, 237u8, 194u8, 194u8, 141u8, 186u8, 138u8,
1488 ]);
1489 const ANONYMOUS: bool = false;
1490 #[allow(unused_variables)]
1491 #[inline]
1492 fn new(
1493 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1494 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1495 ) -> Self {
1496 Self {
1497 stakingAccount: topics.1,
1498 nodeAddress: topics.2,
1499 }
1500 }
1501 #[inline]
1502 fn check_signature(
1503 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1504 ) -> alloy_sol_types::Result<()> {
1505 if topics.0 != Self::SIGNATURE_HASH {
1506 return Err(
1507 alloy_sol_types::Error::invalid_event_signature_hash(
1508 Self::SIGNATURE,
1509 topics.0,
1510 Self::SIGNATURE_HASH,
1511 ),
1512 );
1513 }
1514 Ok(())
1515 }
1516 #[inline]
1517 fn tokenize_body(&self) -> Self::DataToken<'_> {
1518 ()
1519 }
1520 #[inline]
1521 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1522 (
1523 Self::SIGNATURE_HASH.into(),
1524 self.stakingAccount.clone(),
1525 self.nodeAddress.clone(),
1526 )
1527 }
1528 #[inline]
1529 fn encode_topics_raw(
1530 &self,
1531 out: &mut [alloy_sol_types::abi::token::WordToken],
1532 ) -> alloy_sol_types::Result<()> {
1533 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1534 return Err(alloy_sol_types::Error::Overrun);
1535 }
1536 out[0usize] = alloy_sol_types::abi::token::WordToken(
1537 Self::SIGNATURE_HASH,
1538 );
1539 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1540 &self.stakingAccount,
1541 );
1542 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1543 &self.nodeAddress,
1544 );
1545 Ok(())
1546 }
1547 }
1548 #[automatically_derived]
1549 impl alloy_sol_types::private::IntoLogData for Deregistered {
1550 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1551 From::from(self)
1552 }
1553 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1554 From::from(&self)
1555 }
1556 }
1557 #[automatically_derived]
1558 impl From<&Deregistered> for alloy_sol_types::private::LogData {
1559 #[inline]
1560 fn from(this: &Deregistered) -> alloy_sol_types::private::LogData {
1561 alloy_sol_types::SolEvent::encode_log_data(this)
1562 }
1563 }
1564 };
1565 #[derive(serde::Serialize, serde::Deserialize)]
1566 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1567 #[allow(
1572 non_camel_case_types,
1573 non_snake_case,
1574 clippy::pub_underscore_fields,
1575 clippy::style
1576 )]
1577 #[derive(Clone)]
1578 pub struct DeregisteredByManager {
1579 #[allow(missing_docs)]
1580 pub stakingAccount: alloy::sol_types::private::Address,
1581 #[allow(missing_docs)]
1582 pub nodeAddress: alloy::sol_types::private::Address,
1583 }
1584 #[allow(
1585 non_camel_case_types,
1586 non_snake_case,
1587 clippy::pub_underscore_fields,
1588 clippy::style
1589 )]
1590 const _: () = {
1591 use alloy::sol_types as alloy_sol_types;
1592 #[automatically_derived]
1593 impl alloy_sol_types::SolEvent for DeregisteredByManager {
1594 type DataTuple<'a> = ();
1595 type DataToken<'a> = <Self::DataTuple<
1596 'a,
1597 > as alloy_sol_types::SolType>::Token<'a>;
1598 type TopicList = (
1599 alloy_sol_types::sol_data::FixedBytes<32>,
1600 alloy::sol_types::sol_data::Address,
1601 alloy::sol_types::sol_data::Address,
1602 );
1603 const SIGNATURE: &'static str = "DeregisteredByManager(address,address)";
1604 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1605 145u8, 118u8, 10u8, 16u8, 1u8, 245u8, 49u8, 236u8, 43u8, 238u8, 134u8,
1606 2u8, 190u8, 85u8, 173u8, 43u8, 17u8, 89u8, 70u8, 94u8, 223u8, 245u8,
1607 187u8, 205u8, 65u8, 210u8, 7u8, 3u8, 116u8, 42u8, 77u8, 66u8,
1608 ]);
1609 const ANONYMOUS: bool = false;
1610 #[allow(unused_variables)]
1611 #[inline]
1612 fn new(
1613 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1614 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1615 ) -> Self {
1616 Self {
1617 stakingAccount: topics.1,
1618 nodeAddress: topics.2,
1619 }
1620 }
1621 #[inline]
1622 fn check_signature(
1623 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1624 ) -> alloy_sol_types::Result<()> {
1625 if topics.0 != Self::SIGNATURE_HASH {
1626 return Err(
1627 alloy_sol_types::Error::invalid_event_signature_hash(
1628 Self::SIGNATURE,
1629 topics.0,
1630 Self::SIGNATURE_HASH,
1631 ),
1632 );
1633 }
1634 Ok(())
1635 }
1636 #[inline]
1637 fn tokenize_body(&self) -> Self::DataToken<'_> {
1638 ()
1639 }
1640 #[inline]
1641 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1642 (
1643 Self::SIGNATURE_HASH.into(),
1644 self.stakingAccount.clone(),
1645 self.nodeAddress.clone(),
1646 )
1647 }
1648 #[inline]
1649 fn encode_topics_raw(
1650 &self,
1651 out: &mut [alloy_sol_types::abi::token::WordToken],
1652 ) -> alloy_sol_types::Result<()> {
1653 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1654 return Err(alloy_sol_types::Error::Overrun);
1655 }
1656 out[0usize] = alloy_sol_types::abi::token::WordToken(
1657 Self::SIGNATURE_HASH,
1658 );
1659 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1660 &self.stakingAccount,
1661 );
1662 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1663 &self.nodeAddress,
1664 );
1665 Ok(())
1666 }
1667 }
1668 #[automatically_derived]
1669 impl alloy_sol_types::private::IntoLogData for DeregisteredByManager {
1670 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1671 From::from(self)
1672 }
1673 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1674 From::from(&self)
1675 }
1676 }
1677 #[automatically_derived]
1678 impl From<&DeregisteredByManager> for alloy_sol_types::private::LogData {
1679 #[inline]
1680 fn from(this: &DeregisteredByManager) -> alloy_sol_types::private::LogData {
1681 alloy_sol_types::SolEvent::encode_log_data(this)
1682 }
1683 }
1684 };
1685 #[derive(serde::Serialize, serde::Deserialize)]
1686 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1687 #[allow(
1692 non_camel_case_types,
1693 non_snake_case,
1694 clippy::pub_underscore_fields,
1695 clippy::style
1696 )]
1697 #[derive(Clone)]
1698 pub struct EligibilityUpdated {
1699 #[allow(missing_docs)]
1700 pub stakingAccount: alloy::sol_types::private::Address,
1701 #[allow(missing_docs)]
1702 pub eligibility: bool,
1703 }
1704 #[allow(
1705 non_camel_case_types,
1706 non_snake_case,
1707 clippy::pub_underscore_fields,
1708 clippy::style
1709 )]
1710 const _: () = {
1711 use alloy::sol_types as alloy_sol_types;
1712 #[automatically_derived]
1713 impl alloy_sol_types::SolEvent for EligibilityUpdated {
1714 type DataTuple<'a> = ();
1715 type DataToken<'a> = <Self::DataTuple<
1716 'a,
1717 > as alloy_sol_types::SolType>::Token<'a>;
1718 type TopicList = (
1719 alloy_sol_types::sol_data::FixedBytes<32>,
1720 alloy::sol_types::sol_data::Address,
1721 alloy::sol_types::sol_data::Bool,
1722 );
1723 const SIGNATURE: &'static str = "EligibilityUpdated(address,bool)";
1724 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1725 226u8, 153u8, 79u8, 141u8, 111u8, 96u8, 10u8, 212u8, 115u8, 219u8, 168u8,
1726 44u8, 10u8, 137u8, 10u8, 183u8, 175u8, 250u8, 203u8, 134u8, 13u8, 51u8,
1727 101u8, 244u8, 116u8, 186u8, 163u8, 220u8, 4u8, 162u8, 229u8, 87u8,
1728 ]);
1729 const ANONYMOUS: bool = false;
1730 #[allow(unused_variables)]
1731 #[inline]
1732 fn new(
1733 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1734 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1735 ) -> Self {
1736 Self {
1737 stakingAccount: topics.1,
1738 eligibility: topics.2,
1739 }
1740 }
1741 #[inline]
1742 fn check_signature(
1743 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1744 ) -> alloy_sol_types::Result<()> {
1745 if topics.0 != Self::SIGNATURE_HASH {
1746 return Err(
1747 alloy_sol_types::Error::invalid_event_signature_hash(
1748 Self::SIGNATURE,
1749 topics.0,
1750 Self::SIGNATURE_HASH,
1751 ),
1752 );
1753 }
1754 Ok(())
1755 }
1756 #[inline]
1757 fn tokenize_body(&self) -> Self::DataToken<'_> {
1758 ()
1759 }
1760 #[inline]
1761 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1762 (
1763 Self::SIGNATURE_HASH.into(),
1764 self.stakingAccount.clone(),
1765 self.eligibility.clone(),
1766 )
1767 }
1768 #[inline]
1769 fn encode_topics_raw(
1770 &self,
1771 out: &mut [alloy_sol_types::abi::token::WordToken],
1772 ) -> alloy_sol_types::Result<()> {
1773 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1774 return Err(alloy_sol_types::Error::Overrun);
1775 }
1776 out[0usize] = alloy_sol_types::abi::token::WordToken(
1777 Self::SIGNATURE_HASH,
1778 );
1779 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1780 &self.stakingAccount,
1781 );
1782 out[2usize] = <alloy::sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic(
1783 &self.eligibility,
1784 );
1785 Ok(())
1786 }
1787 }
1788 #[automatically_derived]
1789 impl alloy_sol_types::private::IntoLogData for EligibilityUpdated {
1790 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1791 From::from(self)
1792 }
1793 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1794 From::from(&self)
1795 }
1796 }
1797 #[automatically_derived]
1798 impl From<&EligibilityUpdated> for alloy_sol_types::private::LogData {
1799 #[inline]
1800 fn from(this: &EligibilityUpdated) -> alloy_sol_types::private::LogData {
1801 alloy_sol_types::SolEvent::encode_log_data(this)
1802 }
1803 }
1804 };
1805 #[derive(serde::Serialize, serde::Deserialize)]
1806 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1807 #[allow(
1812 non_camel_case_types,
1813 non_snake_case,
1814 clippy::pub_underscore_fields,
1815 clippy::style
1816 )]
1817 #[derive(Clone)]
1818 pub struct NetworkRegistryStatusUpdated {
1819 #[allow(missing_docs)]
1820 pub isEnabled: bool,
1821 }
1822 #[allow(
1823 non_camel_case_types,
1824 non_snake_case,
1825 clippy::pub_underscore_fields,
1826 clippy::style
1827 )]
1828 const _: () = {
1829 use alloy::sol_types as alloy_sol_types;
1830 #[automatically_derived]
1831 impl alloy_sol_types::SolEvent for NetworkRegistryStatusUpdated {
1832 type DataTuple<'a> = ();
1833 type DataToken<'a> = <Self::DataTuple<
1834 'a,
1835 > as alloy_sol_types::SolType>::Token<'a>;
1836 type TopicList = (
1837 alloy_sol_types::sol_data::FixedBytes<32>,
1838 alloy::sol_types::sol_data::Bool,
1839 );
1840 const SIGNATURE: &'static str = "NetworkRegistryStatusUpdated(bool)";
1841 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1842 139u8, 200u8, 95u8, 37u8, 227u8, 233u8, 51u8, 151u8, 143u8, 9u8, 148u8,
1843 8u8, 179u8, 187u8, 62u8, 183u8, 99u8, 11u8, 118u8, 247u8, 69u8, 95u8,
1844 46u8, 32u8, 91u8, 203u8, 192u8, 167u8, 128u8, 225u8, 126u8, 114u8,
1845 ]);
1846 const ANONYMOUS: bool = false;
1847 #[allow(unused_variables)]
1848 #[inline]
1849 fn new(
1850 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1851 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1852 ) -> Self {
1853 Self { isEnabled: topics.1 }
1854 }
1855 #[inline]
1856 fn check_signature(
1857 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1858 ) -> alloy_sol_types::Result<()> {
1859 if topics.0 != Self::SIGNATURE_HASH {
1860 return Err(
1861 alloy_sol_types::Error::invalid_event_signature_hash(
1862 Self::SIGNATURE,
1863 topics.0,
1864 Self::SIGNATURE_HASH,
1865 ),
1866 );
1867 }
1868 Ok(())
1869 }
1870 #[inline]
1871 fn tokenize_body(&self) -> Self::DataToken<'_> {
1872 ()
1873 }
1874 #[inline]
1875 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1876 (Self::SIGNATURE_HASH.into(), self.isEnabled.clone())
1877 }
1878 #[inline]
1879 fn encode_topics_raw(
1880 &self,
1881 out: &mut [alloy_sol_types::abi::token::WordToken],
1882 ) -> alloy_sol_types::Result<()> {
1883 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1884 return Err(alloy_sol_types::Error::Overrun);
1885 }
1886 out[0usize] = alloy_sol_types::abi::token::WordToken(
1887 Self::SIGNATURE_HASH,
1888 );
1889 out[1usize] = <alloy::sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic(
1890 &self.isEnabled,
1891 );
1892 Ok(())
1893 }
1894 }
1895 #[automatically_derived]
1896 impl alloy_sol_types::private::IntoLogData for NetworkRegistryStatusUpdated {
1897 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1898 From::from(self)
1899 }
1900 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1901 From::from(&self)
1902 }
1903 }
1904 #[automatically_derived]
1905 impl From<&NetworkRegistryStatusUpdated> for alloy_sol_types::private::LogData {
1906 #[inline]
1907 fn from(
1908 this: &NetworkRegistryStatusUpdated,
1909 ) -> alloy_sol_types::private::LogData {
1910 alloy_sol_types::SolEvent::encode_log_data(this)
1911 }
1912 }
1913 };
1914 #[derive(serde::Serialize, serde::Deserialize)]
1915 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1916 #[allow(
1921 non_camel_case_types,
1922 non_snake_case,
1923 clippy::pub_underscore_fields,
1924 clippy::style
1925 )]
1926 #[derive(Clone)]
1927 pub struct Registered {
1928 #[allow(missing_docs)]
1929 pub stakingAccount: alloy::sol_types::private::Address,
1930 #[allow(missing_docs)]
1931 pub nodeAddress: alloy::sol_types::private::Address,
1932 }
1933 #[allow(
1934 non_camel_case_types,
1935 non_snake_case,
1936 clippy::pub_underscore_fields,
1937 clippy::style
1938 )]
1939 const _: () = {
1940 use alloy::sol_types as alloy_sol_types;
1941 #[automatically_derived]
1942 impl alloy_sol_types::SolEvent for Registered {
1943 type DataTuple<'a> = ();
1944 type DataToken<'a> = <Self::DataTuple<
1945 'a,
1946 > as alloy_sol_types::SolType>::Token<'a>;
1947 type TopicList = (
1948 alloy_sol_types::sol_data::FixedBytes<32>,
1949 alloy::sol_types::sol_data::Address,
1950 alloy::sol_types::sol_data::Address,
1951 );
1952 const SIGNATURE: &'static str = "Registered(address,address)";
1953 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1954 10u8, 49u8, 238u8, 157u8, 70u8, 168u8, 40u8, 136u8, 75u8, 129u8, 0u8,
1955 60u8, 132u8, 152u8, 21u8, 110u8, 166u8, 170u8, 21u8, 185u8, 181u8, 75u8,
1956 221u8, 14u8, 240u8, 181u8, 51u8, 217u8, 235u8, 165u8, 126u8, 85u8,
1957 ]);
1958 const ANONYMOUS: bool = false;
1959 #[allow(unused_variables)]
1960 #[inline]
1961 fn new(
1962 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1963 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1964 ) -> Self {
1965 Self {
1966 stakingAccount: topics.1,
1967 nodeAddress: topics.2,
1968 }
1969 }
1970 #[inline]
1971 fn check_signature(
1972 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1973 ) -> alloy_sol_types::Result<()> {
1974 if topics.0 != Self::SIGNATURE_HASH {
1975 return Err(
1976 alloy_sol_types::Error::invalid_event_signature_hash(
1977 Self::SIGNATURE,
1978 topics.0,
1979 Self::SIGNATURE_HASH,
1980 ),
1981 );
1982 }
1983 Ok(())
1984 }
1985 #[inline]
1986 fn tokenize_body(&self) -> Self::DataToken<'_> {
1987 ()
1988 }
1989 #[inline]
1990 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1991 (
1992 Self::SIGNATURE_HASH.into(),
1993 self.stakingAccount.clone(),
1994 self.nodeAddress.clone(),
1995 )
1996 }
1997 #[inline]
1998 fn encode_topics_raw(
1999 &self,
2000 out: &mut [alloy_sol_types::abi::token::WordToken],
2001 ) -> alloy_sol_types::Result<()> {
2002 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2003 return Err(alloy_sol_types::Error::Overrun);
2004 }
2005 out[0usize] = alloy_sol_types::abi::token::WordToken(
2006 Self::SIGNATURE_HASH,
2007 );
2008 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2009 &self.stakingAccount,
2010 );
2011 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2012 &self.nodeAddress,
2013 );
2014 Ok(())
2015 }
2016 }
2017 #[automatically_derived]
2018 impl alloy_sol_types::private::IntoLogData for Registered {
2019 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2020 From::from(self)
2021 }
2022 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2023 From::from(&self)
2024 }
2025 }
2026 #[automatically_derived]
2027 impl From<&Registered> for alloy_sol_types::private::LogData {
2028 #[inline]
2029 fn from(this: &Registered) -> alloy_sol_types::private::LogData {
2030 alloy_sol_types::SolEvent::encode_log_data(this)
2031 }
2032 }
2033 };
2034 #[derive(serde::Serialize, serde::Deserialize)]
2035 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2036 #[allow(
2041 non_camel_case_types,
2042 non_snake_case,
2043 clippy::pub_underscore_fields,
2044 clippy::style
2045 )]
2046 #[derive(Clone)]
2047 pub struct RegisteredByManager {
2048 #[allow(missing_docs)]
2049 pub stakingAccount: alloy::sol_types::private::Address,
2050 #[allow(missing_docs)]
2051 pub nodeAddress: alloy::sol_types::private::Address,
2052 }
2053 #[allow(
2054 non_camel_case_types,
2055 non_snake_case,
2056 clippy::pub_underscore_fields,
2057 clippy::style
2058 )]
2059 const _: () = {
2060 use alloy::sol_types as alloy_sol_types;
2061 #[automatically_derived]
2062 impl alloy_sol_types::SolEvent for RegisteredByManager {
2063 type DataTuple<'a> = ();
2064 type DataToken<'a> = <Self::DataTuple<
2065 'a,
2066 > as alloy_sol_types::SolType>::Token<'a>;
2067 type TopicList = (
2068 alloy_sol_types::sol_data::FixedBytes<32>,
2069 alloy::sol_types::sol_data::Address,
2070 alloy::sol_types::sol_data::Address,
2071 );
2072 const SIGNATURE: &'static str = "RegisteredByManager(address,address)";
2073 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2074 4u8, 225u8, 234u8, 164u8, 218u8, 24u8, 247u8, 231u8, 66u8, 164u8, 237u8,
2075 187u8, 233u8, 237u8, 227u8, 108u8, 223u8, 117u8, 247u8, 147u8, 187u8,
2076 3u8, 171u8, 33u8, 88u8, 192u8, 135u8, 127u8, 28u8, 175u8, 43u8, 147u8,
2077 ]);
2078 const ANONYMOUS: bool = false;
2079 #[allow(unused_variables)]
2080 #[inline]
2081 fn new(
2082 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2083 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2084 ) -> Self {
2085 Self {
2086 stakingAccount: topics.1,
2087 nodeAddress: topics.2,
2088 }
2089 }
2090 #[inline]
2091 fn check_signature(
2092 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2093 ) -> alloy_sol_types::Result<()> {
2094 if topics.0 != Self::SIGNATURE_HASH {
2095 return Err(
2096 alloy_sol_types::Error::invalid_event_signature_hash(
2097 Self::SIGNATURE,
2098 topics.0,
2099 Self::SIGNATURE_HASH,
2100 ),
2101 );
2102 }
2103 Ok(())
2104 }
2105 #[inline]
2106 fn tokenize_body(&self) -> Self::DataToken<'_> {
2107 ()
2108 }
2109 #[inline]
2110 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2111 (
2112 Self::SIGNATURE_HASH.into(),
2113 self.stakingAccount.clone(),
2114 self.nodeAddress.clone(),
2115 )
2116 }
2117 #[inline]
2118 fn encode_topics_raw(
2119 &self,
2120 out: &mut [alloy_sol_types::abi::token::WordToken],
2121 ) -> alloy_sol_types::Result<()> {
2122 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2123 return Err(alloy_sol_types::Error::Overrun);
2124 }
2125 out[0usize] = alloy_sol_types::abi::token::WordToken(
2126 Self::SIGNATURE_HASH,
2127 );
2128 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2129 &self.stakingAccount,
2130 );
2131 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2132 &self.nodeAddress,
2133 );
2134 Ok(())
2135 }
2136 }
2137 #[automatically_derived]
2138 impl alloy_sol_types::private::IntoLogData for RegisteredByManager {
2139 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2140 From::from(self)
2141 }
2142 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2143 From::from(&self)
2144 }
2145 }
2146 #[automatically_derived]
2147 impl From<&RegisteredByManager> for alloy_sol_types::private::LogData {
2148 #[inline]
2149 fn from(this: &RegisteredByManager) -> alloy_sol_types::private::LogData {
2150 alloy_sol_types::SolEvent::encode_log_data(this)
2151 }
2152 }
2153 };
2154 #[derive(serde::Serialize, serde::Deserialize)]
2155 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2156 #[allow(
2161 non_camel_case_types,
2162 non_snake_case,
2163 clippy::pub_underscore_fields,
2164 clippy::style
2165 )]
2166 #[derive(Clone)]
2167 pub struct RequirementUpdated {
2168 #[allow(missing_docs)]
2169 pub requirementImplementation: alloy::sol_types::private::Address,
2170 }
2171 #[allow(
2172 non_camel_case_types,
2173 non_snake_case,
2174 clippy::pub_underscore_fields,
2175 clippy::style
2176 )]
2177 const _: () = {
2178 use alloy::sol_types as alloy_sol_types;
2179 #[automatically_derived]
2180 impl alloy_sol_types::SolEvent for RequirementUpdated {
2181 type DataTuple<'a> = ();
2182 type DataToken<'a> = <Self::DataTuple<
2183 'a,
2184 > as alloy_sol_types::SolType>::Token<'a>;
2185 type TopicList = (
2186 alloy_sol_types::sol_data::FixedBytes<32>,
2187 alloy::sol_types::sol_data::Address,
2188 );
2189 const SIGNATURE: &'static str = "RequirementUpdated(address)";
2190 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2191 138u8, 196u8, 178u8, 235u8, 119u8, 73u8, 247u8, 92u8, 91u8, 153u8, 184u8,
2192 152u8, 229u8, 71u8, 253u8, 97u8, 93u8, 215u8, 164u8, 36u8, 230u8, 131u8,
2193 86u8, 234u8, 25u8, 107u8, 125u8, 174u8, 116u8, 45u8, 108u8, 50u8,
2194 ]);
2195 const ANONYMOUS: bool = false;
2196 #[allow(unused_variables)]
2197 #[inline]
2198 fn new(
2199 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2200 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2201 ) -> Self {
2202 Self {
2203 requirementImplementation: topics.1,
2204 }
2205 }
2206 #[inline]
2207 fn check_signature(
2208 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2209 ) -> alloy_sol_types::Result<()> {
2210 if topics.0 != Self::SIGNATURE_HASH {
2211 return Err(
2212 alloy_sol_types::Error::invalid_event_signature_hash(
2213 Self::SIGNATURE,
2214 topics.0,
2215 Self::SIGNATURE_HASH,
2216 ),
2217 );
2218 }
2219 Ok(())
2220 }
2221 #[inline]
2222 fn tokenize_body(&self) -> Self::DataToken<'_> {
2223 ()
2224 }
2225 #[inline]
2226 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2227 (Self::SIGNATURE_HASH.into(), self.requirementImplementation.clone())
2228 }
2229 #[inline]
2230 fn encode_topics_raw(
2231 &self,
2232 out: &mut [alloy_sol_types::abi::token::WordToken],
2233 ) -> alloy_sol_types::Result<()> {
2234 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2235 return Err(alloy_sol_types::Error::Overrun);
2236 }
2237 out[0usize] = alloy_sol_types::abi::token::WordToken(
2238 Self::SIGNATURE_HASH,
2239 );
2240 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2241 &self.requirementImplementation,
2242 );
2243 Ok(())
2244 }
2245 }
2246 #[automatically_derived]
2247 impl alloy_sol_types::private::IntoLogData for RequirementUpdated {
2248 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2249 From::from(self)
2250 }
2251 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2252 From::from(&self)
2253 }
2254 }
2255 #[automatically_derived]
2256 impl From<&RequirementUpdated> for alloy_sol_types::private::LogData {
2257 #[inline]
2258 fn from(this: &RequirementUpdated) -> alloy_sol_types::private::LogData {
2259 alloy_sol_types::SolEvent::encode_log_data(this)
2260 }
2261 }
2262 };
2263 #[derive(serde::Serialize, serde::Deserialize)]
2264 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2265 #[allow(
2270 non_camel_case_types,
2271 non_snake_case,
2272 clippy::pub_underscore_fields,
2273 clippy::style
2274 )]
2275 #[derive(Clone)]
2276 pub struct RoleAdminChanged {
2277 #[allow(missing_docs)]
2278 pub role: alloy::sol_types::private::FixedBytes<32>,
2279 #[allow(missing_docs)]
2280 pub previousAdminRole: alloy::sol_types::private::FixedBytes<32>,
2281 #[allow(missing_docs)]
2282 pub newAdminRole: alloy::sol_types::private::FixedBytes<32>,
2283 }
2284 #[allow(
2285 non_camel_case_types,
2286 non_snake_case,
2287 clippy::pub_underscore_fields,
2288 clippy::style
2289 )]
2290 const _: () = {
2291 use alloy::sol_types as alloy_sol_types;
2292 #[automatically_derived]
2293 impl alloy_sol_types::SolEvent for RoleAdminChanged {
2294 type DataTuple<'a> = ();
2295 type DataToken<'a> = <Self::DataTuple<
2296 'a,
2297 > as alloy_sol_types::SolType>::Token<'a>;
2298 type TopicList = (
2299 alloy_sol_types::sol_data::FixedBytes<32>,
2300 alloy::sol_types::sol_data::FixedBytes<32>,
2301 alloy::sol_types::sol_data::FixedBytes<32>,
2302 alloy::sol_types::sol_data::FixedBytes<32>,
2303 );
2304 const SIGNATURE: &'static str = "RoleAdminChanged(bytes32,bytes32,bytes32)";
2305 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2306 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
2307 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
2308 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
2309 ]);
2310 const ANONYMOUS: bool = false;
2311 #[allow(unused_variables)]
2312 #[inline]
2313 fn new(
2314 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2315 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2316 ) -> Self {
2317 Self {
2318 role: topics.1,
2319 previousAdminRole: topics.2,
2320 newAdminRole: topics.3,
2321 }
2322 }
2323 #[inline]
2324 fn check_signature(
2325 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2326 ) -> alloy_sol_types::Result<()> {
2327 if topics.0 != Self::SIGNATURE_HASH {
2328 return Err(
2329 alloy_sol_types::Error::invalid_event_signature_hash(
2330 Self::SIGNATURE,
2331 topics.0,
2332 Self::SIGNATURE_HASH,
2333 ),
2334 );
2335 }
2336 Ok(())
2337 }
2338 #[inline]
2339 fn tokenize_body(&self) -> Self::DataToken<'_> {
2340 ()
2341 }
2342 #[inline]
2343 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2344 (
2345 Self::SIGNATURE_HASH.into(),
2346 self.role.clone(),
2347 self.previousAdminRole.clone(),
2348 self.newAdminRole.clone(),
2349 )
2350 }
2351 #[inline]
2352 fn encode_topics_raw(
2353 &self,
2354 out: &mut [alloy_sol_types::abi::token::WordToken],
2355 ) -> alloy_sol_types::Result<()> {
2356 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2357 return Err(alloy_sol_types::Error::Overrun);
2358 }
2359 out[0usize] = alloy_sol_types::abi::token::WordToken(
2360 Self::SIGNATURE_HASH,
2361 );
2362 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2363 32,
2364 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
2365 out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
2366 32,
2367 > as alloy_sol_types::EventTopic>::encode_topic(&self.previousAdminRole);
2368 out[3usize] = <alloy::sol_types::sol_data::FixedBytes<
2369 32,
2370 > as alloy_sol_types::EventTopic>::encode_topic(&self.newAdminRole);
2371 Ok(())
2372 }
2373 }
2374 #[automatically_derived]
2375 impl alloy_sol_types::private::IntoLogData for RoleAdminChanged {
2376 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2377 From::from(self)
2378 }
2379 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2380 From::from(&self)
2381 }
2382 }
2383 #[automatically_derived]
2384 impl From<&RoleAdminChanged> for alloy_sol_types::private::LogData {
2385 #[inline]
2386 fn from(this: &RoleAdminChanged) -> alloy_sol_types::private::LogData {
2387 alloy_sol_types::SolEvent::encode_log_data(this)
2388 }
2389 }
2390 };
2391 #[derive(serde::Serialize, serde::Deserialize)]
2392 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2393 #[allow(
2398 non_camel_case_types,
2399 non_snake_case,
2400 clippy::pub_underscore_fields,
2401 clippy::style
2402 )]
2403 #[derive(Clone)]
2404 pub struct RoleGranted {
2405 #[allow(missing_docs)]
2406 pub role: alloy::sol_types::private::FixedBytes<32>,
2407 #[allow(missing_docs)]
2408 pub account: alloy::sol_types::private::Address,
2409 #[allow(missing_docs)]
2410 pub sender: alloy::sol_types::private::Address,
2411 }
2412 #[allow(
2413 non_camel_case_types,
2414 non_snake_case,
2415 clippy::pub_underscore_fields,
2416 clippy::style
2417 )]
2418 const _: () = {
2419 use alloy::sol_types as alloy_sol_types;
2420 #[automatically_derived]
2421 impl alloy_sol_types::SolEvent for RoleGranted {
2422 type DataTuple<'a> = ();
2423 type DataToken<'a> = <Self::DataTuple<
2424 'a,
2425 > as alloy_sol_types::SolType>::Token<'a>;
2426 type TopicList = (
2427 alloy_sol_types::sol_data::FixedBytes<32>,
2428 alloy::sol_types::sol_data::FixedBytes<32>,
2429 alloy::sol_types::sol_data::Address,
2430 alloy::sol_types::sol_data::Address,
2431 );
2432 const SIGNATURE: &'static str = "RoleGranted(bytes32,address,address)";
2433 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2434 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
2435 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
2436 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
2437 ]);
2438 const ANONYMOUS: bool = false;
2439 #[allow(unused_variables)]
2440 #[inline]
2441 fn new(
2442 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2443 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2444 ) -> Self {
2445 Self {
2446 role: topics.1,
2447 account: topics.2,
2448 sender: topics.3,
2449 }
2450 }
2451 #[inline]
2452 fn check_signature(
2453 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2454 ) -> alloy_sol_types::Result<()> {
2455 if topics.0 != Self::SIGNATURE_HASH {
2456 return Err(
2457 alloy_sol_types::Error::invalid_event_signature_hash(
2458 Self::SIGNATURE,
2459 topics.0,
2460 Self::SIGNATURE_HASH,
2461 ),
2462 );
2463 }
2464 Ok(())
2465 }
2466 #[inline]
2467 fn tokenize_body(&self) -> Self::DataToken<'_> {
2468 ()
2469 }
2470 #[inline]
2471 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2472 (
2473 Self::SIGNATURE_HASH.into(),
2474 self.role.clone(),
2475 self.account.clone(),
2476 self.sender.clone(),
2477 )
2478 }
2479 #[inline]
2480 fn encode_topics_raw(
2481 &self,
2482 out: &mut [alloy_sol_types::abi::token::WordToken],
2483 ) -> alloy_sol_types::Result<()> {
2484 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2485 return Err(alloy_sol_types::Error::Overrun);
2486 }
2487 out[0usize] = alloy_sol_types::abi::token::WordToken(
2488 Self::SIGNATURE_HASH,
2489 );
2490 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2491 32,
2492 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
2493 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2494 &self.account,
2495 );
2496 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2497 &self.sender,
2498 );
2499 Ok(())
2500 }
2501 }
2502 #[automatically_derived]
2503 impl alloy_sol_types::private::IntoLogData for RoleGranted {
2504 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2505 From::from(self)
2506 }
2507 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2508 From::from(&self)
2509 }
2510 }
2511 #[automatically_derived]
2512 impl From<&RoleGranted> for alloy_sol_types::private::LogData {
2513 #[inline]
2514 fn from(this: &RoleGranted) -> alloy_sol_types::private::LogData {
2515 alloy_sol_types::SolEvent::encode_log_data(this)
2516 }
2517 }
2518 };
2519 #[derive(serde::Serialize, serde::Deserialize)]
2520 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2521 #[allow(
2526 non_camel_case_types,
2527 non_snake_case,
2528 clippy::pub_underscore_fields,
2529 clippy::style
2530 )]
2531 #[derive(Clone)]
2532 pub struct RoleRevoked {
2533 #[allow(missing_docs)]
2534 pub role: alloy::sol_types::private::FixedBytes<32>,
2535 #[allow(missing_docs)]
2536 pub account: alloy::sol_types::private::Address,
2537 #[allow(missing_docs)]
2538 pub sender: alloy::sol_types::private::Address,
2539 }
2540 #[allow(
2541 non_camel_case_types,
2542 non_snake_case,
2543 clippy::pub_underscore_fields,
2544 clippy::style
2545 )]
2546 const _: () = {
2547 use alloy::sol_types as alloy_sol_types;
2548 #[automatically_derived]
2549 impl alloy_sol_types::SolEvent for RoleRevoked {
2550 type DataTuple<'a> = ();
2551 type DataToken<'a> = <Self::DataTuple<
2552 'a,
2553 > as alloy_sol_types::SolType>::Token<'a>;
2554 type TopicList = (
2555 alloy_sol_types::sol_data::FixedBytes<32>,
2556 alloy::sol_types::sol_data::FixedBytes<32>,
2557 alloy::sol_types::sol_data::Address,
2558 alloy::sol_types::sol_data::Address,
2559 );
2560 const SIGNATURE: &'static str = "RoleRevoked(bytes32,address,address)";
2561 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2562 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
2563 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
2564 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
2565 ]);
2566 const ANONYMOUS: bool = false;
2567 #[allow(unused_variables)]
2568 #[inline]
2569 fn new(
2570 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2571 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2572 ) -> Self {
2573 Self {
2574 role: topics.1,
2575 account: topics.2,
2576 sender: topics.3,
2577 }
2578 }
2579 #[inline]
2580 fn check_signature(
2581 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2582 ) -> alloy_sol_types::Result<()> {
2583 if topics.0 != Self::SIGNATURE_HASH {
2584 return Err(
2585 alloy_sol_types::Error::invalid_event_signature_hash(
2586 Self::SIGNATURE,
2587 topics.0,
2588 Self::SIGNATURE_HASH,
2589 ),
2590 );
2591 }
2592 Ok(())
2593 }
2594 #[inline]
2595 fn tokenize_body(&self) -> Self::DataToken<'_> {
2596 ()
2597 }
2598 #[inline]
2599 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2600 (
2601 Self::SIGNATURE_HASH.into(),
2602 self.role.clone(),
2603 self.account.clone(),
2604 self.sender.clone(),
2605 )
2606 }
2607 #[inline]
2608 fn encode_topics_raw(
2609 &self,
2610 out: &mut [alloy_sol_types::abi::token::WordToken],
2611 ) -> alloy_sol_types::Result<()> {
2612 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2613 return Err(alloy_sol_types::Error::Overrun);
2614 }
2615 out[0usize] = alloy_sol_types::abi::token::WordToken(
2616 Self::SIGNATURE_HASH,
2617 );
2618 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2619 32,
2620 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
2621 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2622 &self.account,
2623 );
2624 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2625 &self.sender,
2626 );
2627 Ok(())
2628 }
2629 }
2630 #[automatically_derived]
2631 impl alloy_sol_types::private::IntoLogData for RoleRevoked {
2632 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2633 From::from(self)
2634 }
2635 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2636 From::from(&self)
2637 }
2638 }
2639 #[automatically_derived]
2640 impl From<&RoleRevoked> for alloy_sol_types::private::LogData {
2641 #[inline]
2642 fn from(this: &RoleRevoked) -> alloy_sol_types::private::LogData {
2643 alloy_sol_types::SolEvent::encode_log_data(this)
2644 }
2645 }
2646 };
2647 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2652 #[derive(Clone)]
2653 pub struct constructorCall {
2654 #[allow(missing_docs)]
2655 pub _requirementImplementation: alloy::sol_types::private::Address,
2656 #[allow(missing_docs)]
2657 pub _newOwner: alloy::sol_types::private::Address,
2658 #[allow(missing_docs)]
2659 pub _manager: alloy::sol_types::private::Address,
2660 }
2661 const _: () = {
2662 use alloy::sol_types as alloy_sol_types;
2663 {
2664 #[doc(hidden)]
2665 type UnderlyingSolTuple<'a> = (
2666 alloy::sol_types::sol_data::Address,
2667 alloy::sol_types::sol_data::Address,
2668 alloy::sol_types::sol_data::Address,
2669 );
2670 #[doc(hidden)]
2671 type UnderlyingRustTuple<'a> = (
2672 alloy::sol_types::private::Address,
2673 alloy::sol_types::private::Address,
2674 alloy::sol_types::private::Address,
2675 );
2676 #[cfg(test)]
2677 #[allow(dead_code, unreachable_patterns)]
2678 fn _type_assertion(
2679 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2680 ) {
2681 match _t {
2682 alloy_sol_types::private::AssertTypeEq::<
2683 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2684 >(_) => {}
2685 }
2686 }
2687 #[automatically_derived]
2688 #[doc(hidden)]
2689 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
2690 fn from(value: constructorCall) -> Self {
2691 (value._requirementImplementation, value._newOwner, value._manager)
2692 }
2693 }
2694 #[automatically_derived]
2695 #[doc(hidden)]
2696 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
2697 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2698 Self {
2699 _requirementImplementation: tuple.0,
2700 _newOwner: tuple.1,
2701 _manager: tuple.2,
2702 }
2703 }
2704 }
2705 }
2706 #[automatically_derived]
2707 impl alloy_sol_types::SolConstructor for constructorCall {
2708 type Parameters<'a> = (
2709 alloy::sol_types::sol_data::Address,
2710 alloy::sol_types::sol_data::Address,
2711 alloy::sol_types::sol_data::Address,
2712 );
2713 type Token<'a> = <Self::Parameters<
2714 'a,
2715 > as alloy_sol_types::SolType>::Token<'a>;
2716 #[inline]
2717 fn new<'a>(
2718 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2719 ) -> Self {
2720 tuple.into()
2721 }
2722 #[inline]
2723 fn tokenize(&self) -> Self::Token<'_> {
2724 (
2725 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2726 &self._requirementImplementation,
2727 ),
2728 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2729 &self._newOwner,
2730 ),
2731 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2732 &self._manager,
2733 ),
2734 )
2735 }
2736 }
2737 };
2738 #[derive(serde::Serialize, serde::Deserialize)]
2739 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2740 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2745 #[derive(Clone)]
2746 pub struct DEFAULT_ADMIN_ROLECall;
2747 #[derive(serde::Serialize, serde::Deserialize)]
2748 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2749 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2751 #[derive(Clone)]
2752 pub struct DEFAULT_ADMIN_ROLEReturn {
2753 #[allow(missing_docs)]
2754 pub _0: alloy::sol_types::private::FixedBytes<32>,
2755 }
2756 #[allow(
2757 non_camel_case_types,
2758 non_snake_case,
2759 clippy::pub_underscore_fields,
2760 clippy::style
2761 )]
2762 const _: () = {
2763 use alloy::sol_types as alloy_sol_types;
2764 {
2765 #[doc(hidden)]
2766 type UnderlyingSolTuple<'a> = ();
2767 #[doc(hidden)]
2768 type UnderlyingRustTuple<'a> = ();
2769 #[cfg(test)]
2770 #[allow(dead_code, unreachable_patterns)]
2771 fn _type_assertion(
2772 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2773 ) {
2774 match _t {
2775 alloy_sol_types::private::AssertTypeEq::<
2776 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2777 >(_) => {}
2778 }
2779 }
2780 #[automatically_derived]
2781 #[doc(hidden)]
2782 impl ::core::convert::From<DEFAULT_ADMIN_ROLECall>
2783 for UnderlyingRustTuple<'_> {
2784 fn from(value: DEFAULT_ADMIN_ROLECall) -> Self {
2785 ()
2786 }
2787 }
2788 #[automatically_derived]
2789 #[doc(hidden)]
2790 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2791 for DEFAULT_ADMIN_ROLECall {
2792 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2793 Self
2794 }
2795 }
2796 }
2797 {
2798 #[doc(hidden)]
2799 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2800 #[doc(hidden)]
2801 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
2802 #[cfg(test)]
2803 #[allow(dead_code, unreachable_patterns)]
2804 fn _type_assertion(
2805 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2806 ) {
2807 match _t {
2808 alloy_sol_types::private::AssertTypeEq::<
2809 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2810 >(_) => {}
2811 }
2812 }
2813 #[automatically_derived]
2814 #[doc(hidden)]
2815 impl ::core::convert::From<DEFAULT_ADMIN_ROLEReturn>
2816 for UnderlyingRustTuple<'_> {
2817 fn from(value: DEFAULT_ADMIN_ROLEReturn) -> Self {
2818 (value._0,)
2819 }
2820 }
2821 #[automatically_derived]
2822 #[doc(hidden)]
2823 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2824 for DEFAULT_ADMIN_ROLEReturn {
2825 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2826 Self { _0: tuple.0 }
2827 }
2828 }
2829 }
2830 #[automatically_derived]
2831 impl alloy_sol_types::SolCall for DEFAULT_ADMIN_ROLECall {
2832 type Parameters<'a> = ();
2833 type Token<'a> = <Self::Parameters<
2834 'a,
2835 > as alloy_sol_types::SolType>::Token<'a>;
2836 type Return = alloy::sol_types::private::FixedBytes<32>;
2837 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2838 type ReturnToken<'a> = <Self::ReturnTuple<
2839 'a,
2840 > as alloy_sol_types::SolType>::Token<'a>;
2841 const SIGNATURE: &'static str = "DEFAULT_ADMIN_ROLE()";
2842 const SELECTOR: [u8; 4] = [162u8, 23u8, 253u8, 223u8];
2843 #[inline]
2844 fn new<'a>(
2845 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2846 ) -> Self {
2847 tuple.into()
2848 }
2849 #[inline]
2850 fn tokenize(&self) -> Self::Token<'_> {
2851 ()
2852 }
2853 #[inline]
2854 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2855 (
2856 <alloy::sol_types::sol_data::FixedBytes<
2857 32,
2858 > as alloy_sol_types::SolType>::tokenize(ret),
2859 )
2860 }
2861 #[inline]
2862 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2863 <Self::ReturnTuple<
2864 '_,
2865 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2866 .map(|r| {
2867 let r: DEFAULT_ADMIN_ROLEReturn = r.into();
2868 r._0
2869 })
2870 }
2871 #[inline]
2872 fn abi_decode_returns_validate(
2873 data: &[u8],
2874 ) -> alloy_sol_types::Result<Self::Return> {
2875 <Self::ReturnTuple<
2876 '_,
2877 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2878 .map(|r| {
2879 let r: DEFAULT_ADMIN_ROLEReturn = r.into();
2880 r._0
2881 })
2882 }
2883 }
2884 };
2885 #[derive(serde::Serialize, serde::Deserialize)]
2886 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2887 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2892 #[derive(Clone)]
2893 pub struct MANAGER_ROLECall;
2894 #[derive(serde::Serialize, serde::Deserialize)]
2895 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2896 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2898 #[derive(Clone)]
2899 pub struct MANAGER_ROLEReturn {
2900 #[allow(missing_docs)]
2901 pub _0: alloy::sol_types::private::FixedBytes<32>,
2902 }
2903 #[allow(
2904 non_camel_case_types,
2905 non_snake_case,
2906 clippy::pub_underscore_fields,
2907 clippy::style
2908 )]
2909 const _: () = {
2910 use alloy::sol_types as alloy_sol_types;
2911 {
2912 #[doc(hidden)]
2913 type UnderlyingSolTuple<'a> = ();
2914 #[doc(hidden)]
2915 type UnderlyingRustTuple<'a> = ();
2916 #[cfg(test)]
2917 #[allow(dead_code, unreachable_patterns)]
2918 fn _type_assertion(
2919 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2920 ) {
2921 match _t {
2922 alloy_sol_types::private::AssertTypeEq::<
2923 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2924 >(_) => {}
2925 }
2926 }
2927 #[automatically_derived]
2928 #[doc(hidden)]
2929 impl ::core::convert::From<MANAGER_ROLECall> for UnderlyingRustTuple<'_> {
2930 fn from(value: MANAGER_ROLECall) -> Self {
2931 ()
2932 }
2933 }
2934 #[automatically_derived]
2935 #[doc(hidden)]
2936 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MANAGER_ROLECall {
2937 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2938 Self
2939 }
2940 }
2941 }
2942 {
2943 #[doc(hidden)]
2944 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2945 #[doc(hidden)]
2946 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
2947 #[cfg(test)]
2948 #[allow(dead_code, unreachable_patterns)]
2949 fn _type_assertion(
2950 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2951 ) {
2952 match _t {
2953 alloy_sol_types::private::AssertTypeEq::<
2954 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2955 >(_) => {}
2956 }
2957 }
2958 #[automatically_derived]
2959 #[doc(hidden)]
2960 impl ::core::convert::From<MANAGER_ROLEReturn> for UnderlyingRustTuple<'_> {
2961 fn from(value: MANAGER_ROLEReturn) -> Self {
2962 (value._0,)
2963 }
2964 }
2965 #[automatically_derived]
2966 #[doc(hidden)]
2967 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MANAGER_ROLEReturn {
2968 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2969 Self { _0: tuple.0 }
2970 }
2971 }
2972 }
2973 #[automatically_derived]
2974 impl alloy_sol_types::SolCall for MANAGER_ROLECall {
2975 type Parameters<'a> = ();
2976 type Token<'a> = <Self::Parameters<
2977 'a,
2978 > as alloy_sol_types::SolType>::Token<'a>;
2979 type Return = alloy::sol_types::private::FixedBytes<32>;
2980 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2981 type ReturnToken<'a> = <Self::ReturnTuple<
2982 'a,
2983 > as alloy_sol_types::SolType>::Token<'a>;
2984 const SIGNATURE: &'static str = "MANAGER_ROLE()";
2985 const SELECTOR: [u8; 4] = [236u8, 135u8, 98u8, 28u8];
2986 #[inline]
2987 fn new<'a>(
2988 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2989 ) -> Self {
2990 tuple.into()
2991 }
2992 #[inline]
2993 fn tokenize(&self) -> Self::Token<'_> {
2994 ()
2995 }
2996 #[inline]
2997 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2998 (
2999 <alloy::sol_types::sol_data::FixedBytes<
3000 32,
3001 > as alloy_sol_types::SolType>::tokenize(ret),
3002 )
3003 }
3004 #[inline]
3005 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3006 <Self::ReturnTuple<
3007 '_,
3008 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3009 .map(|r| {
3010 let r: MANAGER_ROLEReturn = r.into();
3011 r._0
3012 })
3013 }
3014 #[inline]
3015 fn abi_decode_returns_validate(
3016 data: &[u8],
3017 ) -> alloy_sol_types::Result<Self::Return> {
3018 <Self::ReturnTuple<
3019 '_,
3020 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3021 .map(|r| {
3022 let r: MANAGER_ROLEReturn = r.into();
3023 r._0
3024 })
3025 }
3026 }
3027 };
3028 #[derive(serde::Serialize, serde::Deserialize)]
3029 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3030 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3035 #[derive(Clone)]
3036 pub struct countRegisterdNodesPerAccountCall(pub alloy::sol_types::private::Address);
3037 #[derive(serde::Serialize, serde::Deserialize)]
3038 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3039 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3041 #[derive(Clone)]
3042 pub struct countRegisterdNodesPerAccountReturn {
3043 #[allow(missing_docs)]
3044 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3045 }
3046 #[allow(
3047 non_camel_case_types,
3048 non_snake_case,
3049 clippy::pub_underscore_fields,
3050 clippy::style
3051 )]
3052 const _: () = {
3053 use alloy::sol_types as alloy_sol_types;
3054 {
3055 #[doc(hidden)]
3056 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3057 #[doc(hidden)]
3058 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3059 #[cfg(test)]
3060 #[allow(dead_code, unreachable_patterns)]
3061 fn _type_assertion(
3062 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3063 ) {
3064 match _t {
3065 alloy_sol_types::private::AssertTypeEq::<
3066 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3067 >(_) => {}
3068 }
3069 }
3070 #[automatically_derived]
3071 #[doc(hidden)]
3072 impl ::core::convert::From<countRegisterdNodesPerAccountCall>
3073 for UnderlyingRustTuple<'_> {
3074 fn from(value: countRegisterdNodesPerAccountCall) -> Self {
3075 (value.0,)
3076 }
3077 }
3078 #[automatically_derived]
3079 #[doc(hidden)]
3080 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3081 for countRegisterdNodesPerAccountCall {
3082 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3083 Self(tuple.0)
3084 }
3085 }
3086 }
3087 {
3088 #[doc(hidden)]
3089 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3090 #[doc(hidden)]
3091 type UnderlyingRustTuple<'a> = (
3092 alloy::sol_types::private::primitives::aliases::U256,
3093 );
3094 #[cfg(test)]
3095 #[allow(dead_code, unreachable_patterns)]
3096 fn _type_assertion(
3097 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3098 ) {
3099 match _t {
3100 alloy_sol_types::private::AssertTypeEq::<
3101 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3102 >(_) => {}
3103 }
3104 }
3105 #[automatically_derived]
3106 #[doc(hidden)]
3107 impl ::core::convert::From<countRegisterdNodesPerAccountReturn>
3108 for UnderlyingRustTuple<'_> {
3109 fn from(value: countRegisterdNodesPerAccountReturn) -> Self {
3110 (value._0,)
3111 }
3112 }
3113 #[automatically_derived]
3114 #[doc(hidden)]
3115 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3116 for countRegisterdNodesPerAccountReturn {
3117 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3118 Self { _0: tuple.0 }
3119 }
3120 }
3121 }
3122 #[automatically_derived]
3123 impl alloy_sol_types::SolCall for countRegisterdNodesPerAccountCall {
3124 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3125 type Token<'a> = <Self::Parameters<
3126 'a,
3127 > as alloy_sol_types::SolType>::Token<'a>;
3128 type Return = alloy::sol_types::private::primitives::aliases::U256;
3129 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3130 type ReturnToken<'a> = <Self::ReturnTuple<
3131 'a,
3132 > as alloy_sol_types::SolType>::Token<'a>;
3133 const SIGNATURE: &'static str = "countRegisterdNodesPerAccount(address)";
3134 const SELECTOR: [u8; 4] = [63u8, 165u8, 132u8, 87u8];
3135 #[inline]
3136 fn new<'a>(
3137 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3138 ) -> Self {
3139 tuple.into()
3140 }
3141 #[inline]
3142 fn tokenize(&self) -> Self::Token<'_> {
3143 (
3144 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3145 &self.0,
3146 ),
3147 )
3148 }
3149 #[inline]
3150 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3151 (
3152 <alloy::sol_types::sol_data::Uint<
3153 256,
3154 > as alloy_sol_types::SolType>::tokenize(ret),
3155 )
3156 }
3157 #[inline]
3158 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3159 <Self::ReturnTuple<
3160 '_,
3161 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3162 .map(|r| {
3163 let r: countRegisterdNodesPerAccountReturn = r.into();
3164 r._0
3165 })
3166 }
3167 #[inline]
3168 fn abi_decode_returns_validate(
3169 data: &[u8],
3170 ) -> alloy_sol_types::Result<Self::Return> {
3171 <Self::ReturnTuple<
3172 '_,
3173 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3174 .map(|r| {
3175 let r: countRegisterdNodesPerAccountReturn = r.into();
3176 r._0
3177 })
3178 }
3179 }
3180 };
3181 #[derive(serde::Serialize, serde::Deserialize)]
3182 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3183 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3188 #[derive(Clone)]
3189 pub struct disableRegistryCall;
3190 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3192 #[derive(Clone)]
3193 pub struct disableRegistryReturn {}
3194 #[allow(
3195 non_camel_case_types,
3196 non_snake_case,
3197 clippy::pub_underscore_fields,
3198 clippy::style
3199 )]
3200 const _: () = {
3201 use alloy::sol_types as alloy_sol_types;
3202 {
3203 #[doc(hidden)]
3204 type UnderlyingSolTuple<'a> = ();
3205 #[doc(hidden)]
3206 type UnderlyingRustTuple<'a> = ();
3207 #[cfg(test)]
3208 #[allow(dead_code, unreachable_patterns)]
3209 fn _type_assertion(
3210 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3211 ) {
3212 match _t {
3213 alloy_sol_types::private::AssertTypeEq::<
3214 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3215 >(_) => {}
3216 }
3217 }
3218 #[automatically_derived]
3219 #[doc(hidden)]
3220 impl ::core::convert::From<disableRegistryCall> for UnderlyingRustTuple<'_> {
3221 fn from(value: disableRegistryCall) -> Self {
3222 ()
3223 }
3224 }
3225 #[automatically_derived]
3226 #[doc(hidden)]
3227 impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableRegistryCall {
3228 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3229 Self
3230 }
3231 }
3232 }
3233 {
3234 #[doc(hidden)]
3235 type UnderlyingSolTuple<'a> = ();
3236 #[doc(hidden)]
3237 type UnderlyingRustTuple<'a> = ();
3238 #[cfg(test)]
3239 #[allow(dead_code, unreachable_patterns)]
3240 fn _type_assertion(
3241 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3242 ) {
3243 match _t {
3244 alloy_sol_types::private::AssertTypeEq::<
3245 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3246 >(_) => {}
3247 }
3248 }
3249 #[automatically_derived]
3250 #[doc(hidden)]
3251 impl ::core::convert::From<disableRegistryReturn>
3252 for UnderlyingRustTuple<'_> {
3253 fn from(value: disableRegistryReturn) -> Self {
3254 ()
3255 }
3256 }
3257 #[automatically_derived]
3258 #[doc(hidden)]
3259 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3260 for disableRegistryReturn {
3261 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3262 Self {}
3263 }
3264 }
3265 }
3266 impl disableRegistryReturn {
3267 fn _tokenize(
3268 &self,
3269 ) -> <disableRegistryCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3270 ()
3271 }
3272 }
3273 #[automatically_derived]
3274 impl alloy_sol_types::SolCall for disableRegistryCall {
3275 type Parameters<'a> = ();
3276 type Token<'a> = <Self::Parameters<
3277 'a,
3278 > as alloy_sol_types::SolType>::Token<'a>;
3279 type Return = disableRegistryReturn;
3280 type ReturnTuple<'a> = ();
3281 type ReturnToken<'a> = <Self::ReturnTuple<
3282 'a,
3283 > as alloy_sol_types::SolType>::Token<'a>;
3284 const SIGNATURE: &'static str = "disableRegistry()";
3285 const SELECTOR: [u8; 4] = [203u8, 235u8, 175u8, 224u8];
3286 #[inline]
3287 fn new<'a>(
3288 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3289 ) -> Self {
3290 tuple.into()
3291 }
3292 #[inline]
3293 fn tokenize(&self) -> Self::Token<'_> {
3294 ()
3295 }
3296 #[inline]
3297 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3298 disableRegistryReturn::_tokenize(ret)
3299 }
3300 #[inline]
3301 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3302 <Self::ReturnTuple<
3303 '_,
3304 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3305 .map(Into::into)
3306 }
3307 #[inline]
3308 fn abi_decode_returns_validate(
3309 data: &[u8],
3310 ) -> alloy_sol_types::Result<Self::Return> {
3311 <Self::ReturnTuple<
3312 '_,
3313 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3314 .map(Into::into)
3315 }
3316 }
3317 };
3318 #[derive(serde::Serialize, serde::Deserialize)]
3319 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3320 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3325 #[derive(Clone)]
3326 pub struct enableRegistryCall;
3327 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3329 #[derive(Clone)]
3330 pub struct enableRegistryReturn {}
3331 #[allow(
3332 non_camel_case_types,
3333 non_snake_case,
3334 clippy::pub_underscore_fields,
3335 clippy::style
3336 )]
3337 const _: () = {
3338 use alloy::sol_types as alloy_sol_types;
3339 {
3340 #[doc(hidden)]
3341 type UnderlyingSolTuple<'a> = ();
3342 #[doc(hidden)]
3343 type UnderlyingRustTuple<'a> = ();
3344 #[cfg(test)]
3345 #[allow(dead_code, unreachable_patterns)]
3346 fn _type_assertion(
3347 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3348 ) {
3349 match _t {
3350 alloy_sol_types::private::AssertTypeEq::<
3351 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3352 >(_) => {}
3353 }
3354 }
3355 #[automatically_derived]
3356 #[doc(hidden)]
3357 impl ::core::convert::From<enableRegistryCall> for UnderlyingRustTuple<'_> {
3358 fn from(value: enableRegistryCall) -> Self {
3359 ()
3360 }
3361 }
3362 #[automatically_derived]
3363 #[doc(hidden)]
3364 impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableRegistryCall {
3365 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3366 Self
3367 }
3368 }
3369 }
3370 {
3371 #[doc(hidden)]
3372 type UnderlyingSolTuple<'a> = ();
3373 #[doc(hidden)]
3374 type UnderlyingRustTuple<'a> = ();
3375 #[cfg(test)]
3376 #[allow(dead_code, unreachable_patterns)]
3377 fn _type_assertion(
3378 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3379 ) {
3380 match _t {
3381 alloy_sol_types::private::AssertTypeEq::<
3382 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3383 >(_) => {}
3384 }
3385 }
3386 #[automatically_derived]
3387 #[doc(hidden)]
3388 impl ::core::convert::From<enableRegistryReturn>
3389 for UnderlyingRustTuple<'_> {
3390 fn from(value: enableRegistryReturn) -> Self {
3391 ()
3392 }
3393 }
3394 #[automatically_derived]
3395 #[doc(hidden)]
3396 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3397 for enableRegistryReturn {
3398 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3399 Self {}
3400 }
3401 }
3402 }
3403 impl enableRegistryReturn {
3404 fn _tokenize(
3405 &self,
3406 ) -> <enableRegistryCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3407 ()
3408 }
3409 }
3410 #[automatically_derived]
3411 impl alloy_sol_types::SolCall for enableRegistryCall {
3412 type Parameters<'a> = ();
3413 type Token<'a> = <Self::Parameters<
3414 'a,
3415 > as alloy_sol_types::SolType>::Token<'a>;
3416 type Return = enableRegistryReturn;
3417 type ReturnTuple<'a> = ();
3418 type ReturnToken<'a> = <Self::ReturnTuple<
3419 'a,
3420 > as alloy_sol_types::SolType>::Token<'a>;
3421 const SIGNATURE: &'static str = "enableRegistry()";
3422 const SELECTOR: [u8; 4] = [207u8, 179u8, 115u8, 95u8];
3423 #[inline]
3424 fn new<'a>(
3425 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3426 ) -> Self {
3427 tuple.into()
3428 }
3429 #[inline]
3430 fn tokenize(&self) -> Self::Token<'_> {
3431 ()
3432 }
3433 #[inline]
3434 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3435 enableRegistryReturn::_tokenize(ret)
3436 }
3437 #[inline]
3438 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3439 <Self::ReturnTuple<
3440 '_,
3441 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3442 .map(Into::into)
3443 }
3444 #[inline]
3445 fn abi_decode_returns_validate(
3446 data: &[u8],
3447 ) -> alloy_sol_types::Result<Self::Return> {
3448 <Self::ReturnTuple<
3449 '_,
3450 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3451 .map(Into::into)
3452 }
3453 }
3454 };
3455 #[derive(serde::Serialize, serde::Deserialize)]
3456 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3457 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3462 #[derive(Clone)]
3463 pub struct enabledCall;
3464 #[derive(serde::Serialize, serde::Deserialize)]
3465 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3466 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3468 #[derive(Clone)]
3469 pub struct enabledReturn {
3470 #[allow(missing_docs)]
3471 pub _0: bool,
3472 }
3473 #[allow(
3474 non_camel_case_types,
3475 non_snake_case,
3476 clippy::pub_underscore_fields,
3477 clippy::style
3478 )]
3479 const _: () = {
3480 use alloy::sol_types as alloy_sol_types;
3481 {
3482 #[doc(hidden)]
3483 type UnderlyingSolTuple<'a> = ();
3484 #[doc(hidden)]
3485 type UnderlyingRustTuple<'a> = ();
3486 #[cfg(test)]
3487 #[allow(dead_code, unreachable_patterns)]
3488 fn _type_assertion(
3489 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3490 ) {
3491 match _t {
3492 alloy_sol_types::private::AssertTypeEq::<
3493 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3494 >(_) => {}
3495 }
3496 }
3497 #[automatically_derived]
3498 #[doc(hidden)]
3499 impl ::core::convert::From<enabledCall> for UnderlyingRustTuple<'_> {
3500 fn from(value: enabledCall) -> Self {
3501 ()
3502 }
3503 }
3504 #[automatically_derived]
3505 #[doc(hidden)]
3506 impl ::core::convert::From<UnderlyingRustTuple<'_>> for enabledCall {
3507 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3508 Self
3509 }
3510 }
3511 }
3512 {
3513 #[doc(hidden)]
3514 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3515 #[doc(hidden)]
3516 type UnderlyingRustTuple<'a> = (bool,);
3517 #[cfg(test)]
3518 #[allow(dead_code, unreachable_patterns)]
3519 fn _type_assertion(
3520 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3521 ) {
3522 match _t {
3523 alloy_sol_types::private::AssertTypeEq::<
3524 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3525 >(_) => {}
3526 }
3527 }
3528 #[automatically_derived]
3529 #[doc(hidden)]
3530 impl ::core::convert::From<enabledReturn> for UnderlyingRustTuple<'_> {
3531 fn from(value: enabledReturn) -> Self {
3532 (value._0,)
3533 }
3534 }
3535 #[automatically_derived]
3536 #[doc(hidden)]
3537 impl ::core::convert::From<UnderlyingRustTuple<'_>> for enabledReturn {
3538 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3539 Self { _0: tuple.0 }
3540 }
3541 }
3542 }
3543 #[automatically_derived]
3544 impl alloy_sol_types::SolCall for enabledCall {
3545 type Parameters<'a> = ();
3546 type Token<'a> = <Self::Parameters<
3547 'a,
3548 > as alloy_sol_types::SolType>::Token<'a>;
3549 type Return = bool;
3550 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3551 type ReturnToken<'a> = <Self::ReturnTuple<
3552 'a,
3553 > as alloy_sol_types::SolType>::Token<'a>;
3554 const SIGNATURE: &'static str = "enabled()";
3555 const SELECTOR: [u8; 4] = [35u8, 141u8, 175u8, 224u8];
3556 #[inline]
3557 fn new<'a>(
3558 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3559 ) -> Self {
3560 tuple.into()
3561 }
3562 #[inline]
3563 fn tokenize(&self) -> Self::Token<'_> {
3564 ()
3565 }
3566 #[inline]
3567 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3568 (
3569 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
3570 ret,
3571 ),
3572 )
3573 }
3574 #[inline]
3575 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3576 <Self::ReturnTuple<
3577 '_,
3578 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3579 .map(|r| {
3580 let r: enabledReturn = r.into();
3581 r._0
3582 })
3583 }
3584 #[inline]
3585 fn abi_decode_returns_validate(
3586 data: &[u8],
3587 ) -> alloy_sol_types::Result<Self::Return> {
3588 <Self::ReturnTuple<
3589 '_,
3590 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3591 .map(|r| {
3592 let r: enabledReturn = r.into();
3593 r._0
3594 })
3595 }
3596 }
3597 };
3598 #[derive(serde::Serialize, serde::Deserialize)]
3599 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3600 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3605 #[derive(Clone)]
3606 pub struct getRoleAdminCall {
3607 #[allow(missing_docs)]
3608 pub role: alloy::sol_types::private::FixedBytes<32>,
3609 }
3610 #[derive(serde::Serialize, serde::Deserialize)]
3611 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3612 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3614 #[derive(Clone)]
3615 pub struct getRoleAdminReturn {
3616 #[allow(missing_docs)]
3617 pub _0: alloy::sol_types::private::FixedBytes<32>,
3618 }
3619 #[allow(
3620 non_camel_case_types,
3621 non_snake_case,
3622 clippy::pub_underscore_fields,
3623 clippy::style
3624 )]
3625 const _: () = {
3626 use alloy::sol_types as alloy_sol_types;
3627 {
3628 #[doc(hidden)]
3629 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3630 #[doc(hidden)]
3631 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3632 #[cfg(test)]
3633 #[allow(dead_code, unreachable_patterns)]
3634 fn _type_assertion(
3635 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3636 ) {
3637 match _t {
3638 alloy_sol_types::private::AssertTypeEq::<
3639 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3640 >(_) => {}
3641 }
3642 }
3643 #[automatically_derived]
3644 #[doc(hidden)]
3645 impl ::core::convert::From<getRoleAdminCall> for UnderlyingRustTuple<'_> {
3646 fn from(value: getRoleAdminCall) -> Self {
3647 (value.role,)
3648 }
3649 }
3650 #[automatically_derived]
3651 #[doc(hidden)]
3652 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminCall {
3653 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3654 Self { role: tuple.0 }
3655 }
3656 }
3657 }
3658 {
3659 #[doc(hidden)]
3660 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3661 #[doc(hidden)]
3662 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3663 #[cfg(test)]
3664 #[allow(dead_code, unreachable_patterns)]
3665 fn _type_assertion(
3666 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3667 ) {
3668 match _t {
3669 alloy_sol_types::private::AssertTypeEq::<
3670 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3671 >(_) => {}
3672 }
3673 }
3674 #[automatically_derived]
3675 #[doc(hidden)]
3676 impl ::core::convert::From<getRoleAdminReturn> for UnderlyingRustTuple<'_> {
3677 fn from(value: getRoleAdminReturn) -> Self {
3678 (value._0,)
3679 }
3680 }
3681 #[automatically_derived]
3682 #[doc(hidden)]
3683 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminReturn {
3684 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3685 Self { _0: tuple.0 }
3686 }
3687 }
3688 }
3689 #[automatically_derived]
3690 impl alloy_sol_types::SolCall for getRoleAdminCall {
3691 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3692 type Token<'a> = <Self::Parameters<
3693 'a,
3694 > as alloy_sol_types::SolType>::Token<'a>;
3695 type Return = alloy::sol_types::private::FixedBytes<32>;
3696 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3697 type ReturnToken<'a> = <Self::ReturnTuple<
3698 'a,
3699 > as alloy_sol_types::SolType>::Token<'a>;
3700 const SIGNATURE: &'static str = "getRoleAdmin(bytes32)";
3701 const SELECTOR: [u8; 4] = [36u8, 138u8, 156u8, 163u8];
3702 #[inline]
3703 fn new<'a>(
3704 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3705 ) -> Self {
3706 tuple.into()
3707 }
3708 #[inline]
3709 fn tokenize(&self) -> Self::Token<'_> {
3710 (
3711 <alloy::sol_types::sol_data::FixedBytes<
3712 32,
3713 > as alloy_sol_types::SolType>::tokenize(&self.role),
3714 )
3715 }
3716 #[inline]
3717 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3718 (
3719 <alloy::sol_types::sol_data::FixedBytes<
3720 32,
3721 > as alloy_sol_types::SolType>::tokenize(ret),
3722 )
3723 }
3724 #[inline]
3725 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3726 <Self::ReturnTuple<
3727 '_,
3728 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3729 .map(|r| {
3730 let r: getRoleAdminReturn = r.into();
3731 r._0
3732 })
3733 }
3734 #[inline]
3735 fn abi_decode_returns_validate(
3736 data: &[u8],
3737 ) -> alloy_sol_types::Result<Self::Return> {
3738 <Self::ReturnTuple<
3739 '_,
3740 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3741 .map(|r| {
3742 let r: getRoleAdminReturn = r.into();
3743 r._0
3744 })
3745 }
3746 }
3747 };
3748 #[derive(serde::Serialize, serde::Deserialize)]
3749 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3750 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3755 #[derive(Clone)]
3756 pub struct getRoleMemberCall {
3757 #[allow(missing_docs)]
3758 pub role: alloy::sol_types::private::FixedBytes<32>,
3759 #[allow(missing_docs)]
3760 pub index: alloy::sol_types::private::primitives::aliases::U256,
3761 }
3762 #[derive(serde::Serialize, serde::Deserialize)]
3763 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3764 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3766 #[derive(Clone)]
3767 pub struct getRoleMemberReturn {
3768 #[allow(missing_docs)]
3769 pub _0: alloy::sol_types::private::Address,
3770 }
3771 #[allow(
3772 non_camel_case_types,
3773 non_snake_case,
3774 clippy::pub_underscore_fields,
3775 clippy::style
3776 )]
3777 const _: () = {
3778 use alloy::sol_types as alloy_sol_types;
3779 {
3780 #[doc(hidden)]
3781 type UnderlyingSolTuple<'a> = (
3782 alloy::sol_types::sol_data::FixedBytes<32>,
3783 alloy::sol_types::sol_data::Uint<256>,
3784 );
3785 #[doc(hidden)]
3786 type UnderlyingRustTuple<'a> = (
3787 alloy::sol_types::private::FixedBytes<32>,
3788 alloy::sol_types::private::primitives::aliases::U256,
3789 );
3790 #[cfg(test)]
3791 #[allow(dead_code, unreachable_patterns)]
3792 fn _type_assertion(
3793 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3794 ) {
3795 match _t {
3796 alloy_sol_types::private::AssertTypeEq::<
3797 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3798 >(_) => {}
3799 }
3800 }
3801 #[automatically_derived]
3802 #[doc(hidden)]
3803 impl ::core::convert::From<getRoleMemberCall> for UnderlyingRustTuple<'_> {
3804 fn from(value: getRoleMemberCall) -> Self {
3805 (value.role, value.index)
3806 }
3807 }
3808 #[automatically_derived]
3809 #[doc(hidden)]
3810 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberCall {
3811 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3812 Self {
3813 role: tuple.0,
3814 index: tuple.1,
3815 }
3816 }
3817 }
3818 }
3819 {
3820 #[doc(hidden)]
3821 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3822 #[doc(hidden)]
3823 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3824 #[cfg(test)]
3825 #[allow(dead_code, unreachable_patterns)]
3826 fn _type_assertion(
3827 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3828 ) {
3829 match _t {
3830 alloy_sol_types::private::AssertTypeEq::<
3831 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3832 >(_) => {}
3833 }
3834 }
3835 #[automatically_derived]
3836 #[doc(hidden)]
3837 impl ::core::convert::From<getRoleMemberReturn> for UnderlyingRustTuple<'_> {
3838 fn from(value: getRoleMemberReturn) -> Self {
3839 (value._0,)
3840 }
3841 }
3842 #[automatically_derived]
3843 #[doc(hidden)]
3844 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberReturn {
3845 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3846 Self { _0: tuple.0 }
3847 }
3848 }
3849 }
3850 #[automatically_derived]
3851 impl alloy_sol_types::SolCall for getRoleMemberCall {
3852 type Parameters<'a> = (
3853 alloy::sol_types::sol_data::FixedBytes<32>,
3854 alloy::sol_types::sol_data::Uint<256>,
3855 );
3856 type Token<'a> = <Self::Parameters<
3857 'a,
3858 > as alloy_sol_types::SolType>::Token<'a>;
3859 type Return = alloy::sol_types::private::Address;
3860 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3861 type ReturnToken<'a> = <Self::ReturnTuple<
3862 'a,
3863 > as alloy_sol_types::SolType>::Token<'a>;
3864 const SIGNATURE: &'static str = "getRoleMember(bytes32,uint256)";
3865 const SELECTOR: [u8; 4] = [144u8, 16u8, 208u8, 124u8];
3866 #[inline]
3867 fn new<'a>(
3868 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3869 ) -> Self {
3870 tuple.into()
3871 }
3872 #[inline]
3873 fn tokenize(&self) -> Self::Token<'_> {
3874 (
3875 <alloy::sol_types::sol_data::FixedBytes<
3876 32,
3877 > as alloy_sol_types::SolType>::tokenize(&self.role),
3878 <alloy::sol_types::sol_data::Uint<
3879 256,
3880 > as alloy_sol_types::SolType>::tokenize(&self.index),
3881 )
3882 }
3883 #[inline]
3884 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3885 (
3886 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3887 ret,
3888 ),
3889 )
3890 }
3891 #[inline]
3892 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3893 <Self::ReturnTuple<
3894 '_,
3895 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3896 .map(|r| {
3897 let r: getRoleMemberReturn = r.into();
3898 r._0
3899 })
3900 }
3901 #[inline]
3902 fn abi_decode_returns_validate(
3903 data: &[u8],
3904 ) -> alloy_sol_types::Result<Self::Return> {
3905 <Self::ReturnTuple<
3906 '_,
3907 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3908 .map(|r| {
3909 let r: getRoleMemberReturn = r.into();
3910 r._0
3911 })
3912 }
3913 }
3914 };
3915 #[derive(serde::Serialize, serde::Deserialize)]
3916 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3917 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3922 #[derive(Clone)]
3923 pub struct getRoleMemberCountCall {
3924 #[allow(missing_docs)]
3925 pub role: alloy::sol_types::private::FixedBytes<32>,
3926 }
3927 #[derive(serde::Serialize, serde::Deserialize)]
3928 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3929 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3931 #[derive(Clone)]
3932 pub struct getRoleMemberCountReturn {
3933 #[allow(missing_docs)]
3934 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3935 }
3936 #[allow(
3937 non_camel_case_types,
3938 non_snake_case,
3939 clippy::pub_underscore_fields,
3940 clippy::style
3941 )]
3942 const _: () = {
3943 use alloy::sol_types as alloy_sol_types;
3944 {
3945 #[doc(hidden)]
3946 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3947 #[doc(hidden)]
3948 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3949 #[cfg(test)]
3950 #[allow(dead_code, unreachable_patterns)]
3951 fn _type_assertion(
3952 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3953 ) {
3954 match _t {
3955 alloy_sol_types::private::AssertTypeEq::<
3956 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3957 >(_) => {}
3958 }
3959 }
3960 #[automatically_derived]
3961 #[doc(hidden)]
3962 impl ::core::convert::From<getRoleMemberCountCall>
3963 for UnderlyingRustTuple<'_> {
3964 fn from(value: getRoleMemberCountCall) -> Self {
3965 (value.role,)
3966 }
3967 }
3968 #[automatically_derived]
3969 #[doc(hidden)]
3970 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3971 for getRoleMemberCountCall {
3972 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3973 Self { role: tuple.0 }
3974 }
3975 }
3976 }
3977 {
3978 #[doc(hidden)]
3979 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3980 #[doc(hidden)]
3981 type UnderlyingRustTuple<'a> = (
3982 alloy::sol_types::private::primitives::aliases::U256,
3983 );
3984 #[cfg(test)]
3985 #[allow(dead_code, unreachable_patterns)]
3986 fn _type_assertion(
3987 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3988 ) {
3989 match _t {
3990 alloy_sol_types::private::AssertTypeEq::<
3991 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3992 >(_) => {}
3993 }
3994 }
3995 #[automatically_derived]
3996 #[doc(hidden)]
3997 impl ::core::convert::From<getRoleMemberCountReturn>
3998 for UnderlyingRustTuple<'_> {
3999 fn from(value: getRoleMemberCountReturn) -> Self {
4000 (value._0,)
4001 }
4002 }
4003 #[automatically_derived]
4004 #[doc(hidden)]
4005 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4006 for getRoleMemberCountReturn {
4007 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4008 Self { _0: tuple.0 }
4009 }
4010 }
4011 }
4012 #[automatically_derived]
4013 impl alloy_sol_types::SolCall for getRoleMemberCountCall {
4014 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4015 type Token<'a> = <Self::Parameters<
4016 'a,
4017 > as alloy_sol_types::SolType>::Token<'a>;
4018 type Return = alloy::sol_types::private::primitives::aliases::U256;
4019 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4020 type ReturnToken<'a> = <Self::ReturnTuple<
4021 'a,
4022 > as alloy_sol_types::SolType>::Token<'a>;
4023 const SIGNATURE: &'static str = "getRoleMemberCount(bytes32)";
4024 const SELECTOR: [u8; 4] = [202u8, 21u8, 200u8, 115u8];
4025 #[inline]
4026 fn new<'a>(
4027 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4028 ) -> Self {
4029 tuple.into()
4030 }
4031 #[inline]
4032 fn tokenize(&self) -> Self::Token<'_> {
4033 (
4034 <alloy::sol_types::sol_data::FixedBytes<
4035 32,
4036 > as alloy_sol_types::SolType>::tokenize(&self.role),
4037 )
4038 }
4039 #[inline]
4040 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4041 (
4042 <alloy::sol_types::sol_data::Uint<
4043 256,
4044 > as alloy_sol_types::SolType>::tokenize(ret),
4045 )
4046 }
4047 #[inline]
4048 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4049 <Self::ReturnTuple<
4050 '_,
4051 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4052 .map(|r| {
4053 let r: getRoleMemberCountReturn = r.into();
4054 r._0
4055 })
4056 }
4057 #[inline]
4058 fn abi_decode_returns_validate(
4059 data: &[u8],
4060 ) -> alloy_sol_types::Result<Self::Return> {
4061 <Self::ReturnTuple<
4062 '_,
4063 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4064 .map(|r| {
4065 let r: getRoleMemberCountReturn = r.into();
4066 r._0
4067 })
4068 }
4069 }
4070 };
4071 #[derive(serde::Serialize, serde::Deserialize)]
4072 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4073 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4078 #[derive(Clone)]
4079 pub struct grantRoleCall {
4080 #[allow(missing_docs)]
4081 pub role: alloy::sol_types::private::FixedBytes<32>,
4082 #[allow(missing_docs)]
4083 pub account: alloy::sol_types::private::Address,
4084 }
4085 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4087 #[derive(Clone)]
4088 pub struct grantRoleReturn {}
4089 #[allow(
4090 non_camel_case_types,
4091 non_snake_case,
4092 clippy::pub_underscore_fields,
4093 clippy::style
4094 )]
4095 const _: () = {
4096 use alloy::sol_types as alloy_sol_types;
4097 {
4098 #[doc(hidden)]
4099 type UnderlyingSolTuple<'a> = (
4100 alloy::sol_types::sol_data::FixedBytes<32>,
4101 alloy::sol_types::sol_data::Address,
4102 );
4103 #[doc(hidden)]
4104 type UnderlyingRustTuple<'a> = (
4105 alloy::sol_types::private::FixedBytes<32>,
4106 alloy::sol_types::private::Address,
4107 );
4108 #[cfg(test)]
4109 #[allow(dead_code, unreachable_patterns)]
4110 fn _type_assertion(
4111 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4112 ) {
4113 match _t {
4114 alloy_sol_types::private::AssertTypeEq::<
4115 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4116 >(_) => {}
4117 }
4118 }
4119 #[automatically_derived]
4120 #[doc(hidden)]
4121 impl ::core::convert::From<grantRoleCall> for UnderlyingRustTuple<'_> {
4122 fn from(value: grantRoleCall) -> Self {
4123 (value.role, value.account)
4124 }
4125 }
4126 #[automatically_derived]
4127 #[doc(hidden)]
4128 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
4129 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4130 Self {
4131 role: tuple.0,
4132 account: tuple.1,
4133 }
4134 }
4135 }
4136 }
4137 {
4138 #[doc(hidden)]
4139 type UnderlyingSolTuple<'a> = ();
4140 #[doc(hidden)]
4141 type UnderlyingRustTuple<'a> = ();
4142 #[cfg(test)]
4143 #[allow(dead_code, unreachable_patterns)]
4144 fn _type_assertion(
4145 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4146 ) {
4147 match _t {
4148 alloy_sol_types::private::AssertTypeEq::<
4149 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4150 >(_) => {}
4151 }
4152 }
4153 #[automatically_derived]
4154 #[doc(hidden)]
4155 impl ::core::convert::From<grantRoleReturn> for UnderlyingRustTuple<'_> {
4156 fn from(value: grantRoleReturn) -> Self {
4157 ()
4158 }
4159 }
4160 #[automatically_derived]
4161 #[doc(hidden)]
4162 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
4163 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4164 Self {}
4165 }
4166 }
4167 }
4168 impl grantRoleReturn {
4169 fn _tokenize(
4170 &self,
4171 ) -> <grantRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4172 ()
4173 }
4174 }
4175 #[automatically_derived]
4176 impl alloy_sol_types::SolCall for grantRoleCall {
4177 type Parameters<'a> = (
4178 alloy::sol_types::sol_data::FixedBytes<32>,
4179 alloy::sol_types::sol_data::Address,
4180 );
4181 type Token<'a> = <Self::Parameters<
4182 'a,
4183 > as alloy_sol_types::SolType>::Token<'a>;
4184 type Return = grantRoleReturn;
4185 type ReturnTuple<'a> = ();
4186 type ReturnToken<'a> = <Self::ReturnTuple<
4187 'a,
4188 > as alloy_sol_types::SolType>::Token<'a>;
4189 const SIGNATURE: &'static str = "grantRole(bytes32,address)";
4190 const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
4191 #[inline]
4192 fn new<'a>(
4193 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4194 ) -> Self {
4195 tuple.into()
4196 }
4197 #[inline]
4198 fn tokenize(&self) -> Self::Token<'_> {
4199 (
4200 <alloy::sol_types::sol_data::FixedBytes<
4201 32,
4202 > as alloy_sol_types::SolType>::tokenize(&self.role),
4203 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4204 &self.account,
4205 ),
4206 )
4207 }
4208 #[inline]
4209 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4210 grantRoleReturn::_tokenize(ret)
4211 }
4212 #[inline]
4213 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4214 <Self::ReturnTuple<
4215 '_,
4216 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4217 .map(Into::into)
4218 }
4219 #[inline]
4220 fn abi_decode_returns_validate(
4221 data: &[u8],
4222 ) -> alloy_sol_types::Result<Self::Return> {
4223 <Self::ReturnTuple<
4224 '_,
4225 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4226 .map(Into::into)
4227 }
4228 }
4229 };
4230 #[derive(serde::Serialize, serde::Deserialize)]
4231 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4232 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4237 #[derive(Clone)]
4238 pub struct hasRoleCall {
4239 #[allow(missing_docs)]
4240 pub role: alloy::sol_types::private::FixedBytes<32>,
4241 #[allow(missing_docs)]
4242 pub account: alloy::sol_types::private::Address,
4243 }
4244 #[derive(serde::Serialize, serde::Deserialize)]
4245 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4246 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4248 #[derive(Clone)]
4249 pub struct hasRoleReturn {
4250 #[allow(missing_docs)]
4251 pub _0: bool,
4252 }
4253 #[allow(
4254 non_camel_case_types,
4255 non_snake_case,
4256 clippy::pub_underscore_fields,
4257 clippy::style
4258 )]
4259 const _: () = {
4260 use alloy::sol_types as alloy_sol_types;
4261 {
4262 #[doc(hidden)]
4263 type UnderlyingSolTuple<'a> = (
4264 alloy::sol_types::sol_data::FixedBytes<32>,
4265 alloy::sol_types::sol_data::Address,
4266 );
4267 #[doc(hidden)]
4268 type UnderlyingRustTuple<'a> = (
4269 alloy::sol_types::private::FixedBytes<32>,
4270 alloy::sol_types::private::Address,
4271 );
4272 #[cfg(test)]
4273 #[allow(dead_code, unreachable_patterns)]
4274 fn _type_assertion(
4275 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4276 ) {
4277 match _t {
4278 alloy_sol_types::private::AssertTypeEq::<
4279 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4280 >(_) => {}
4281 }
4282 }
4283 #[automatically_derived]
4284 #[doc(hidden)]
4285 impl ::core::convert::From<hasRoleCall> for UnderlyingRustTuple<'_> {
4286 fn from(value: hasRoleCall) -> Self {
4287 (value.role, value.account)
4288 }
4289 }
4290 #[automatically_derived]
4291 #[doc(hidden)]
4292 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleCall {
4293 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4294 Self {
4295 role: tuple.0,
4296 account: tuple.1,
4297 }
4298 }
4299 }
4300 }
4301 {
4302 #[doc(hidden)]
4303 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4304 #[doc(hidden)]
4305 type UnderlyingRustTuple<'a> = (bool,);
4306 #[cfg(test)]
4307 #[allow(dead_code, unreachable_patterns)]
4308 fn _type_assertion(
4309 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4310 ) {
4311 match _t {
4312 alloy_sol_types::private::AssertTypeEq::<
4313 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4314 >(_) => {}
4315 }
4316 }
4317 #[automatically_derived]
4318 #[doc(hidden)]
4319 impl ::core::convert::From<hasRoleReturn> for UnderlyingRustTuple<'_> {
4320 fn from(value: hasRoleReturn) -> Self {
4321 (value._0,)
4322 }
4323 }
4324 #[automatically_derived]
4325 #[doc(hidden)]
4326 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleReturn {
4327 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4328 Self { _0: tuple.0 }
4329 }
4330 }
4331 }
4332 #[automatically_derived]
4333 impl alloy_sol_types::SolCall for hasRoleCall {
4334 type Parameters<'a> = (
4335 alloy::sol_types::sol_data::FixedBytes<32>,
4336 alloy::sol_types::sol_data::Address,
4337 );
4338 type Token<'a> = <Self::Parameters<
4339 'a,
4340 > as alloy_sol_types::SolType>::Token<'a>;
4341 type Return = bool;
4342 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4343 type ReturnToken<'a> = <Self::ReturnTuple<
4344 'a,
4345 > as alloy_sol_types::SolType>::Token<'a>;
4346 const SIGNATURE: &'static str = "hasRole(bytes32,address)";
4347 const SELECTOR: [u8; 4] = [145u8, 209u8, 72u8, 84u8];
4348 #[inline]
4349 fn new<'a>(
4350 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4351 ) -> Self {
4352 tuple.into()
4353 }
4354 #[inline]
4355 fn tokenize(&self) -> Self::Token<'_> {
4356 (
4357 <alloy::sol_types::sol_data::FixedBytes<
4358 32,
4359 > as alloy_sol_types::SolType>::tokenize(&self.role),
4360 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4361 &self.account,
4362 ),
4363 )
4364 }
4365 #[inline]
4366 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4367 (
4368 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
4369 ret,
4370 ),
4371 )
4372 }
4373 #[inline]
4374 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4375 <Self::ReturnTuple<
4376 '_,
4377 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4378 .map(|r| {
4379 let r: hasRoleReturn = r.into();
4380 r._0
4381 })
4382 }
4383 #[inline]
4384 fn abi_decode_returns_validate(
4385 data: &[u8],
4386 ) -> alloy_sol_types::Result<Self::Return> {
4387 <Self::ReturnTuple<
4388 '_,
4389 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4390 .map(|r| {
4391 let r: hasRoleReturn = r.into();
4392 r._0
4393 })
4394 }
4395 }
4396 };
4397 #[derive(serde::Serialize, serde::Deserialize)]
4398 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4399 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4404 #[derive(Clone)]
4405 pub struct isAccountEligibleCall {
4406 #[allow(missing_docs)]
4407 pub stakingAccount: alloy::sol_types::private::Address,
4408 }
4409 #[derive(serde::Serialize, serde::Deserialize)]
4410 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4411 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4413 #[derive(Clone)]
4414 pub struct isAccountEligibleReturn {
4415 #[allow(missing_docs)]
4416 pub _0: bool,
4417 }
4418 #[allow(
4419 non_camel_case_types,
4420 non_snake_case,
4421 clippy::pub_underscore_fields,
4422 clippy::style
4423 )]
4424 const _: () = {
4425 use alloy::sol_types as alloy_sol_types;
4426 {
4427 #[doc(hidden)]
4428 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4429 #[doc(hidden)]
4430 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4431 #[cfg(test)]
4432 #[allow(dead_code, unreachable_patterns)]
4433 fn _type_assertion(
4434 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4435 ) {
4436 match _t {
4437 alloy_sol_types::private::AssertTypeEq::<
4438 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4439 >(_) => {}
4440 }
4441 }
4442 #[automatically_derived]
4443 #[doc(hidden)]
4444 impl ::core::convert::From<isAccountEligibleCall>
4445 for UnderlyingRustTuple<'_> {
4446 fn from(value: isAccountEligibleCall) -> Self {
4447 (value.stakingAccount,)
4448 }
4449 }
4450 #[automatically_derived]
4451 #[doc(hidden)]
4452 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4453 for isAccountEligibleCall {
4454 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4455 Self { stakingAccount: tuple.0 }
4456 }
4457 }
4458 }
4459 {
4460 #[doc(hidden)]
4461 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4462 #[doc(hidden)]
4463 type UnderlyingRustTuple<'a> = (bool,);
4464 #[cfg(test)]
4465 #[allow(dead_code, unreachable_patterns)]
4466 fn _type_assertion(
4467 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4468 ) {
4469 match _t {
4470 alloy_sol_types::private::AssertTypeEq::<
4471 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4472 >(_) => {}
4473 }
4474 }
4475 #[automatically_derived]
4476 #[doc(hidden)]
4477 impl ::core::convert::From<isAccountEligibleReturn>
4478 for UnderlyingRustTuple<'_> {
4479 fn from(value: isAccountEligibleReturn) -> Self {
4480 (value._0,)
4481 }
4482 }
4483 #[automatically_derived]
4484 #[doc(hidden)]
4485 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4486 for isAccountEligibleReturn {
4487 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4488 Self { _0: tuple.0 }
4489 }
4490 }
4491 }
4492 #[automatically_derived]
4493 impl alloy_sol_types::SolCall for isAccountEligibleCall {
4494 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4495 type Token<'a> = <Self::Parameters<
4496 'a,
4497 > as alloy_sol_types::SolType>::Token<'a>;
4498 type Return = bool;
4499 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4500 type ReturnToken<'a> = <Self::ReturnTuple<
4501 'a,
4502 > as alloy_sol_types::SolType>::Token<'a>;
4503 const SIGNATURE: &'static str = "isAccountEligible(address)";
4504 const SELECTOR: [u8; 4] = [111u8, 251u8, 249u8, 136u8];
4505 #[inline]
4506 fn new<'a>(
4507 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4508 ) -> Self {
4509 tuple.into()
4510 }
4511 #[inline]
4512 fn tokenize(&self) -> Self::Token<'_> {
4513 (
4514 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4515 &self.stakingAccount,
4516 ),
4517 )
4518 }
4519 #[inline]
4520 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4521 (
4522 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
4523 ret,
4524 ),
4525 )
4526 }
4527 #[inline]
4528 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4529 <Self::ReturnTuple<
4530 '_,
4531 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4532 .map(|r| {
4533 let r: isAccountEligibleReturn = r.into();
4534 r._0
4535 })
4536 }
4537 #[inline]
4538 fn abi_decode_returns_validate(
4539 data: &[u8],
4540 ) -> alloy_sol_types::Result<Self::Return> {
4541 <Self::ReturnTuple<
4542 '_,
4543 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4544 .map(|r| {
4545 let r: isAccountEligibleReturn = r.into();
4546 r._0
4547 })
4548 }
4549 }
4550 };
4551 #[derive(serde::Serialize, serde::Deserialize)]
4552 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4553 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4558 #[derive(Clone)]
4559 pub struct isNodeRegisteredAndEligibleCall {
4560 #[allow(missing_docs)]
4561 pub nodeAddress: alloy::sol_types::private::Address,
4562 }
4563 #[derive(serde::Serialize, serde::Deserialize)]
4564 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4565 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4567 #[derive(Clone)]
4568 pub struct isNodeRegisteredAndEligibleReturn {
4569 #[allow(missing_docs)]
4570 pub _0: bool,
4571 }
4572 #[allow(
4573 non_camel_case_types,
4574 non_snake_case,
4575 clippy::pub_underscore_fields,
4576 clippy::style
4577 )]
4578 const _: () = {
4579 use alloy::sol_types as alloy_sol_types;
4580 {
4581 #[doc(hidden)]
4582 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4583 #[doc(hidden)]
4584 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4585 #[cfg(test)]
4586 #[allow(dead_code, unreachable_patterns)]
4587 fn _type_assertion(
4588 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4589 ) {
4590 match _t {
4591 alloy_sol_types::private::AssertTypeEq::<
4592 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4593 >(_) => {}
4594 }
4595 }
4596 #[automatically_derived]
4597 #[doc(hidden)]
4598 impl ::core::convert::From<isNodeRegisteredAndEligibleCall>
4599 for UnderlyingRustTuple<'_> {
4600 fn from(value: isNodeRegisteredAndEligibleCall) -> Self {
4601 (value.nodeAddress,)
4602 }
4603 }
4604 #[automatically_derived]
4605 #[doc(hidden)]
4606 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4607 for isNodeRegisteredAndEligibleCall {
4608 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4609 Self { nodeAddress: tuple.0 }
4610 }
4611 }
4612 }
4613 {
4614 #[doc(hidden)]
4615 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4616 #[doc(hidden)]
4617 type UnderlyingRustTuple<'a> = (bool,);
4618 #[cfg(test)]
4619 #[allow(dead_code, unreachable_patterns)]
4620 fn _type_assertion(
4621 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4622 ) {
4623 match _t {
4624 alloy_sol_types::private::AssertTypeEq::<
4625 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4626 >(_) => {}
4627 }
4628 }
4629 #[automatically_derived]
4630 #[doc(hidden)]
4631 impl ::core::convert::From<isNodeRegisteredAndEligibleReturn>
4632 for UnderlyingRustTuple<'_> {
4633 fn from(value: isNodeRegisteredAndEligibleReturn) -> Self {
4634 (value._0,)
4635 }
4636 }
4637 #[automatically_derived]
4638 #[doc(hidden)]
4639 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4640 for isNodeRegisteredAndEligibleReturn {
4641 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4642 Self { _0: tuple.0 }
4643 }
4644 }
4645 }
4646 #[automatically_derived]
4647 impl alloy_sol_types::SolCall for isNodeRegisteredAndEligibleCall {
4648 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4649 type Token<'a> = <Self::Parameters<
4650 'a,
4651 > as alloy_sol_types::SolType>::Token<'a>;
4652 type Return = bool;
4653 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4654 type ReturnToken<'a> = <Self::ReturnTuple<
4655 'a,
4656 > as alloy_sol_types::SolType>::Token<'a>;
4657 const SIGNATURE: &'static str = "isNodeRegisteredAndEligible(address)";
4658 const SELECTOR: [u8; 4] = [78u8, 177u8, 128u8, 92u8];
4659 #[inline]
4660 fn new<'a>(
4661 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4662 ) -> Self {
4663 tuple.into()
4664 }
4665 #[inline]
4666 fn tokenize(&self) -> Self::Token<'_> {
4667 (
4668 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4669 &self.nodeAddress,
4670 ),
4671 )
4672 }
4673 #[inline]
4674 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4675 (
4676 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
4677 ret,
4678 ),
4679 )
4680 }
4681 #[inline]
4682 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4683 <Self::ReturnTuple<
4684 '_,
4685 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4686 .map(|r| {
4687 let r: isNodeRegisteredAndEligibleReturn = r.into();
4688 r._0
4689 })
4690 }
4691 #[inline]
4692 fn abi_decode_returns_validate(
4693 data: &[u8],
4694 ) -> alloy_sol_types::Result<Self::Return> {
4695 <Self::ReturnTuple<
4696 '_,
4697 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4698 .map(|r| {
4699 let r: isNodeRegisteredAndEligibleReturn = r.into();
4700 r._0
4701 })
4702 }
4703 }
4704 };
4705 #[derive(serde::Serialize, serde::Deserialize)]
4706 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4707 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4712 #[derive(Clone)]
4713 pub struct isNodeRegisteredByAccountCall {
4714 #[allow(missing_docs)]
4715 pub nodeAddress: alloy::sol_types::private::Address,
4716 #[allow(missing_docs)]
4717 pub account: alloy::sol_types::private::Address,
4718 }
4719 #[derive(serde::Serialize, serde::Deserialize)]
4720 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4721 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4723 #[derive(Clone)]
4724 pub struct isNodeRegisteredByAccountReturn {
4725 #[allow(missing_docs)]
4726 pub _0: bool,
4727 }
4728 #[allow(
4729 non_camel_case_types,
4730 non_snake_case,
4731 clippy::pub_underscore_fields,
4732 clippy::style
4733 )]
4734 const _: () = {
4735 use alloy::sol_types as alloy_sol_types;
4736 {
4737 #[doc(hidden)]
4738 type UnderlyingSolTuple<'a> = (
4739 alloy::sol_types::sol_data::Address,
4740 alloy::sol_types::sol_data::Address,
4741 );
4742 #[doc(hidden)]
4743 type UnderlyingRustTuple<'a> = (
4744 alloy::sol_types::private::Address,
4745 alloy::sol_types::private::Address,
4746 );
4747 #[cfg(test)]
4748 #[allow(dead_code, unreachable_patterns)]
4749 fn _type_assertion(
4750 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4751 ) {
4752 match _t {
4753 alloy_sol_types::private::AssertTypeEq::<
4754 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4755 >(_) => {}
4756 }
4757 }
4758 #[automatically_derived]
4759 #[doc(hidden)]
4760 impl ::core::convert::From<isNodeRegisteredByAccountCall>
4761 for UnderlyingRustTuple<'_> {
4762 fn from(value: isNodeRegisteredByAccountCall) -> Self {
4763 (value.nodeAddress, value.account)
4764 }
4765 }
4766 #[automatically_derived]
4767 #[doc(hidden)]
4768 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4769 for isNodeRegisteredByAccountCall {
4770 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4771 Self {
4772 nodeAddress: tuple.0,
4773 account: tuple.1,
4774 }
4775 }
4776 }
4777 }
4778 {
4779 #[doc(hidden)]
4780 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4781 #[doc(hidden)]
4782 type UnderlyingRustTuple<'a> = (bool,);
4783 #[cfg(test)]
4784 #[allow(dead_code, unreachable_patterns)]
4785 fn _type_assertion(
4786 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4787 ) {
4788 match _t {
4789 alloy_sol_types::private::AssertTypeEq::<
4790 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4791 >(_) => {}
4792 }
4793 }
4794 #[automatically_derived]
4795 #[doc(hidden)]
4796 impl ::core::convert::From<isNodeRegisteredByAccountReturn>
4797 for UnderlyingRustTuple<'_> {
4798 fn from(value: isNodeRegisteredByAccountReturn) -> Self {
4799 (value._0,)
4800 }
4801 }
4802 #[automatically_derived]
4803 #[doc(hidden)]
4804 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4805 for isNodeRegisteredByAccountReturn {
4806 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4807 Self { _0: tuple.0 }
4808 }
4809 }
4810 }
4811 #[automatically_derived]
4812 impl alloy_sol_types::SolCall for isNodeRegisteredByAccountCall {
4813 type Parameters<'a> = (
4814 alloy::sol_types::sol_data::Address,
4815 alloy::sol_types::sol_data::Address,
4816 );
4817 type Token<'a> = <Self::Parameters<
4818 'a,
4819 > as alloy_sol_types::SolType>::Token<'a>;
4820 type Return = bool;
4821 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4822 type ReturnToken<'a> = <Self::ReturnTuple<
4823 'a,
4824 > as alloy_sol_types::SolType>::Token<'a>;
4825 const SIGNATURE: &'static str = "isNodeRegisteredByAccount(address,address)";
4826 const SELECTOR: [u8; 4] = [165u8, 96u8, 93u8, 165u8];
4827 #[inline]
4828 fn new<'a>(
4829 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4830 ) -> Self {
4831 tuple.into()
4832 }
4833 #[inline]
4834 fn tokenize(&self) -> Self::Token<'_> {
4835 (
4836 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4837 &self.nodeAddress,
4838 ),
4839 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4840 &self.account,
4841 ),
4842 )
4843 }
4844 #[inline]
4845 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4846 (
4847 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
4848 ret,
4849 ),
4850 )
4851 }
4852 #[inline]
4853 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4854 <Self::ReturnTuple<
4855 '_,
4856 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4857 .map(|r| {
4858 let r: isNodeRegisteredByAccountReturn = r.into();
4859 r._0
4860 })
4861 }
4862 #[inline]
4863 fn abi_decode_returns_validate(
4864 data: &[u8],
4865 ) -> alloy_sol_types::Result<Self::Return> {
4866 <Self::ReturnTuple<
4867 '_,
4868 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4869 .map(|r| {
4870 let r: isNodeRegisteredByAccountReturn = r.into();
4871 r._0
4872 })
4873 }
4874 }
4875 };
4876 #[derive(serde::Serialize, serde::Deserialize)]
4877 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4878 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4883 #[derive(Clone)]
4884 pub struct managerDeregisterCall {
4885 #[allow(missing_docs)]
4886 pub nodeAddresses: alloy::sol_types::private::Vec<
4887 alloy::sol_types::private::Address,
4888 >,
4889 }
4890 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4892 #[derive(Clone)]
4893 pub struct managerDeregisterReturn {}
4894 #[allow(
4895 non_camel_case_types,
4896 non_snake_case,
4897 clippy::pub_underscore_fields,
4898 clippy::style
4899 )]
4900 const _: () = {
4901 use alloy::sol_types as alloy_sol_types;
4902 {
4903 #[doc(hidden)]
4904 type UnderlyingSolTuple<'a> = (
4905 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
4906 );
4907 #[doc(hidden)]
4908 type UnderlyingRustTuple<'a> = (
4909 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
4910 );
4911 #[cfg(test)]
4912 #[allow(dead_code, unreachable_patterns)]
4913 fn _type_assertion(
4914 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4915 ) {
4916 match _t {
4917 alloy_sol_types::private::AssertTypeEq::<
4918 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4919 >(_) => {}
4920 }
4921 }
4922 #[automatically_derived]
4923 #[doc(hidden)]
4924 impl ::core::convert::From<managerDeregisterCall>
4925 for UnderlyingRustTuple<'_> {
4926 fn from(value: managerDeregisterCall) -> Self {
4927 (value.nodeAddresses,)
4928 }
4929 }
4930 #[automatically_derived]
4931 #[doc(hidden)]
4932 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4933 for managerDeregisterCall {
4934 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4935 Self { nodeAddresses: tuple.0 }
4936 }
4937 }
4938 }
4939 {
4940 #[doc(hidden)]
4941 type UnderlyingSolTuple<'a> = ();
4942 #[doc(hidden)]
4943 type UnderlyingRustTuple<'a> = ();
4944 #[cfg(test)]
4945 #[allow(dead_code, unreachable_patterns)]
4946 fn _type_assertion(
4947 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4948 ) {
4949 match _t {
4950 alloy_sol_types::private::AssertTypeEq::<
4951 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4952 >(_) => {}
4953 }
4954 }
4955 #[automatically_derived]
4956 #[doc(hidden)]
4957 impl ::core::convert::From<managerDeregisterReturn>
4958 for UnderlyingRustTuple<'_> {
4959 fn from(value: managerDeregisterReturn) -> Self {
4960 ()
4961 }
4962 }
4963 #[automatically_derived]
4964 #[doc(hidden)]
4965 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4966 for managerDeregisterReturn {
4967 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4968 Self {}
4969 }
4970 }
4971 }
4972 impl managerDeregisterReturn {
4973 fn _tokenize(
4974 &self,
4975 ) -> <managerDeregisterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4976 ()
4977 }
4978 }
4979 #[automatically_derived]
4980 impl alloy_sol_types::SolCall for managerDeregisterCall {
4981 type Parameters<'a> = (
4982 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
4983 );
4984 type Token<'a> = <Self::Parameters<
4985 'a,
4986 > as alloy_sol_types::SolType>::Token<'a>;
4987 type Return = managerDeregisterReturn;
4988 type ReturnTuple<'a> = ();
4989 type ReturnToken<'a> = <Self::ReturnTuple<
4990 'a,
4991 > as alloy_sol_types::SolType>::Token<'a>;
4992 const SIGNATURE: &'static str = "managerDeregister(address[])";
4993 const SELECTOR: [u8; 4] = [65u8, 182u8, 73u8, 101u8];
4994 #[inline]
4995 fn new<'a>(
4996 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4997 ) -> Self {
4998 tuple.into()
4999 }
5000 #[inline]
5001 fn tokenize(&self) -> Self::Token<'_> {
5002 (
5003 <alloy::sol_types::sol_data::Array<
5004 alloy::sol_types::sol_data::Address,
5005 > as alloy_sol_types::SolType>::tokenize(&self.nodeAddresses),
5006 )
5007 }
5008 #[inline]
5009 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5010 managerDeregisterReturn::_tokenize(ret)
5011 }
5012 #[inline]
5013 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5014 <Self::ReturnTuple<
5015 '_,
5016 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5017 .map(Into::into)
5018 }
5019 #[inline]
5020 fn abi_decode_returns_validate(
5021 data: &[u8],
5022 ) -> alloy_sol_types::Result<Self::Return> {
5023 <Self::ReturnTuple<
5024 '_,
5025 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5026 .map(Into::into)
5027 }
5028 }
5029 };
5030 #[derive(serde::Serialize, serde::Deserialize)]
5031 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5032 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5037 #[derive(Clone)]
5038 pub struct managerForceSyncCall {
5039 #[allow(missing_docs)]
5040 pub stakingAccounts: alloy::sol_types::private::Vec<
5041 alloy::sol_types::private::Address,
5042 >,
5043 #[allow(missing_docs)]
5044 pub eligibilities: alloy::sol_types::private::Vec<bool>,
5045 }
5046 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5048 #[derive(Clone)]
5049 pub struct managerForceSyncReturn {}
5050 #[allow(
5051 non_camel_case_types,
5052 non_snake_case,
5053 clippy::pub_underscore_fields,
5054 clippy::style
5055 )]
5056 const _: () = {
5057 use alloy::sol_types as alloy_sol_types;
5058 {
5059 #[doc(hidden)]
5060 type UnderlyingSolTuple<'a> = (
5061 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5062 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bool>,
5063 );
5064 #[doc(hidden)]
5065 type UnderlyingRustTuple<'a> = (
5066 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
5067 alloy::sol_types::private::Vec<bool>,
5068 );
5069 #[cfg(test)]
5070 #[allow(dead_code, unreachable_patterns)]
5071 fn _type_assertion(
5072 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5073 ) {
5074 match _t {
5075 alloy_sol_types::private::AssertTypeEq::<
5076 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5077 >(_) => {}
5078 }
5079 }
5080 #[automatically_derived]
5081 #[doc(hidden)]
5082 impl ::core::convert::From<managerForceSyncCall>
5083 for UnderlyingRustTuple<'_> {
5084 fn from(value: managerForceSyncCall) -> Self {
5085 (value.stakingAccounts, value.eligibilities)
5086 }
5087 }
5088 #[automatically_derived]
5089 #[doc(hidden)]
5090 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5091 for managerForceSyncCall {
5092 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5093 Self {
5094 stakingAccounts: tuple.0,
5095 eligibilities: tuple.1,
5096 }
5097 }
5098 }
5099 }
5100 {
5101 #[doc(hidden)]
5102 type UnderlyingSolTuple<'a> = ();
5103 #[doc(hidden)]
5104 type UnderlyingRustTuple<'a> = ();
5105 #[cfg(test)]
5106 #[allow(dead_code, unreachable_patterns)]
5107 fn _type_assertion(
5108 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5109 ) {
5110 match _t {
5111 alloy_sol_types::private::AssertTypeEq::<
5112 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5113 >(_) => {}
5114 }
5115 }
5116 #[automatically_derived]
5117 #[doc(hidden)]
5118 impl ::core::convert::From<managerForceSyncReturn>
5119 for UnderlyingRustTuple<'_> {
5120 fn from(value: managerForceSyncReturn) -> Self {
5121 ()
5122 }
5123 }
5124 #[automatically_derived]
5125 #[doc(hidden)]
5126 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5127 for managerForceSyncReturn {
5128 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5129 Self {}
5130 }
5131 }
5132 }
5133 impl managerForceSyncReturn {
5134 fn _tokenize(
5135 &self,
5136 ) -> <managerForceSyncCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
5137 ()
5138 }
5139 }
5140 #[automatically_derived]
5141 impl alloy_sol_types::SolCall for managerForceSyncCall {
5142 type Parameters<'a> = (
5143 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5144 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bool>,
5145 );
5146 type Token<'a> = <Self::Parameters<
5147 'a,
5148 > as alloy_sol_types::SolType>::Token<'a>;
5149 type Return = managerForceSyncReturn;
5150 type ReturnTuple<'a> = ();
5151 type ReturnToken<'a> = <Self::ReturnTuple<
5152 'a,
5153 > as alloy_sol_types::SolType>::Token<'a>;
5154 const SIGNATURE: &'static str = "managerForceSync(address[],bool[])";
5155 const SELECTOR: [u8; 4] = [202u8, 245u8, 245u8, 1u8];
5156 #[inline]
5157 fn new<'a>(
5158 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5159 ) -> Self {
5160 tuple.into()
5161 }
5162 #[inline]
5163 fn tokenize(&self) -> Self::Token<'_> {
5164 (
5165 <alloy::sol_types::sol_data::Array<
5166 alloy::sol_types::sol_data::Address,
5167 > as alloy_sol_types::SolType>::tokenize(&self.stakingAccounts),
5168 <alloy::sol_types::sol_data::Array<
5169 alloy::sol_types::sol_data::Bool,
5170 > as alloy_sol_types::SolType>::tokenize(&self.eligibilities),
5171 )
5172 }
5173 #[inline]
5174 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5175 managerForceSyncReturn::_tokenize(ret)
5176 }
5177 #[inline]
5178 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5179 <Self::ReturnTuple<
5180 '_,
5181 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5182 .map(Into::into)
5183 }
5184 #[inline]
5185 fn abi_decode_returns_validate(
5186 data: &[u8],
5187 ) -> alloy_sol_types::Result<Self::Return> {
5188 <Self::ReturnTuple<
5189 '_,
5190 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5191 .map(Into::into)
5192 }
5193 }
5194 };
5195 #[derive(serde::Serialize, serde::Deserialize)]
5196 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5197 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5202 #[derive(Clone)]
5203 pub struct managerRegisterCall {
5204 #[allow(missing_docs)]
5205 pub stakingAccounts: alloy::sol_types::private::Vec<
5206 alloy::sol_types::private::Address,
5207 >,
5208 #[allow(missing_docs)]
5209 pub nodeAddresses: alloy::sol_types::private::Vec<
5210 alloy::sol_types::private::Address,
5211 >,
5212 }
5213 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5215 #[derive(Clone)]
5216 pub struct managerRegisterReturn {}
5217 #[allow(
5218 non_camel_case_types,
5219 non_snake_case,
5220 clippy::pub_underscore_fields,
5221 clippy::style
5222 )]
5223 const _: () = {
5224 use alloy::sol_types as alloy_sol_types;
5225 {
5226 #[doc(hidden)]
5227 type UnderlyingSolTuple<'a> = (
5228 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5229 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5230 );
5231 #[doc(hidden)]
5232 type UnderlyingRustTuple<'a> = (
5233 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
5234 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
5235 );
5236 #[cfg(test)]
5237 #[allow(dead_code, unreachable_patterns)]
5238 fn _type_assertion(
5239 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5240 ) {
5241 match _t {
5242 alloy_sol_types::private::AssertTypeEq::<
5243 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5244 >(_) => {}
5245 }
5246 }
5247 #[automatically_derived]
5248 #[doc(hidden)]
5249 impl ::core::convert::From<managerRegisterCall> for UnderlyingRustTuple<'_> {
5250 fn from(value: managerRegisterCall) -> Self {
5251 (value.stakingAccounts, value.nodeAddresses)
5252 }
5253 }
5254 #[automatically_derived]
5255 #[doc(hidden)]
5256 impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerRegisterCall {
5257 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5258 Self {
5259 stakingAccounts: tuple.0,
5260 nodeAddresses: tuple.1,
5261 }
5262 }
5263 }
5264 }
5265 {
5266 #[doc(hidden)]
5267 type UnderlyingSolTuple<'a> = ();
5268 #[doc(hidden)]
5269 type UnderlyingRustTuple<'a> = ();
5270 #[cfg(test)]
5271 #[allow(dead_code, unreachable_patterns)]
5272 fn _type_assertion(
5273 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5274 ) {
5275 match _t {
5276 alloy_sol_types::private::AssertTypeEq::<
5277 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5278 >(_) => {}
5279 }
5280 }
5281 #[automatically_derived]
5282 #[doc(hidden)]
5283 impl ::core::convert::From<managerRegisterReturn>
5284 for UnderlyingRustTuple<'_> {
5285 fn from(value: managerRegisterReturn) -> Self {
5286 ()
5287 }
5288 }
5289 #[automatically_derived]
5290 #[doc(hidden)]
5291 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5292 for managerRegisterReturn {
5293 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5294 Self {}
5295 }
5296 }
5297 }
5298 impl managerRegisterReturn {
5299 fn _tokenize(
5300 &self,
5301 ) -> <managerRegisterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
5302 ()
5303 }
5304 }
5305 #[automatically_derived]
5306 impl alloy_sol_types::SolCall for managerRegisterCall {
5307 type Parameters<'a> = (
5308 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5309 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5310 );
5311 type Token<'a> = <Self::Parameters<
5312 'a,
5313 > as alloy_sol_types::SolType>::Token<'a>;
5314 type Return = managerRegisterReturn;
5315 type ReturnTuple<'a> = ();
5316 type ReturnToken<'a> = <Self::ReturnTuple<
5317 'a,
5318 > as alloy_sol_types::SolType>::Token<'a>;
5319 const SIGNATURE: &'static str = "managerRegister(address[],address[])";
5320 const SELECTOR: [u8; 4] = [141u8, 117u8, 59u8, 45u8];
5321 #[inline]
5322 fn new<'a>(
5323 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5324 ) -> Self {
5325 tuple.into()
5326 }
5327 #[inline]
5328 fn tokenize(&self) -> Self::Token<'_> {
5329 (
5330 <alloy::sol_types::sol_data::Array<
5331 alloy::sol_types::sol_data::Address,
5332 > as alloy_sol_types::SolType>::tokenize(&self.stakingAccounts),
5333 <alloy::sol_types::sol_data::Array<
5334 alloy::sol_types::sol_data::Address,
5335 > as alloy_sol_types::SolType>::tokenize(&self.nodeAddresses),
5336 )
5337 }
5338 #[inline]
5339 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5340 managerRegisterReturn::_tokenize(ret)
5341 }
5342 #[inline]
5343 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5344 <Self::ReturnTuple<
5345 '_,
5346 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5347 .map(Into::into)
5348 }
5349 #[inline]
5350 fn abi_decode_returns_validate(
5351 data: &[u8],
5352 ) -> alloy_sol_types::Result<Self::Return> {
5353 <Self::ReturnTuple<
5354 '_,
5355 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5356 .map(Into::into)
5357 }
5358 }
5359 };
5360 #[derive(serde::Serialize, serde::Deserialize)]
5361 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5362 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5367 #[derive(Clone)]
5368 pub struct managerSyncCall {
5369 #[allow(missing_docs)]
5370 pub stakingAccounts: alloy::sol_types::private::Vec<
5371 alloy::sol_types::private::Address,
5372 >,
5373 }
5374 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5376 #[derive(Clone)]
5377 pub struct managerSyncReturn {}
5378 #[allow(
5379 non_camel_case_types,
5380 non_snake_case,
5381 clippy::pub_underscore_fields,
5382 clippy::style
5383 )]
5384 const _: () = {
5385 use alloy::sol_types as alloy_sol_types;
5386 {
5387 #[doc(hidden)]
5388 type UnderlyingSolTuple<'a> = (
5389 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5390 );
5391 #[doc(hidden)]
5392 type UnderlyingRustTuple<'a> = (
5393 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
5394 );
5395 #[cfg(test)]
5396 #[allow(dead_code, unreachable_patterns)]
5397 fn _type_assertion(
5398 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5399 ) {
5400 match _t {
5401 alloy_sol_types::private::AssertTypeEq::<
5402 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5403 >(_) => {}
5404 }
5405 }
5406 #[automatically_derived]
5407 #[doc(hidden)]
5408 impl ::core::convert::From<managerSyncCall> for UnderlyingRustTuple<'_> {
5409 fn from(value: managerSyncCall) -> Self {
5410 (value.stakingAccounts,)
5411 }
5412 }
5413 #[automatically_derived]
5414 #[doc(hidden)]
5415 impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerSyncCall {
5416 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5417 Self { stakingAccounts: tuple.0 }
5418 }
5419 }
5420 }
5421 {
5422 #[doc(hidden)]
5423 type UnderlyingSolTuple<'a> = ();
5424 #[doc(hidden)]
5425 type UnderlyingRustTuple<'a> = ();
5426 #[cfg(test)]
5427 #[allow(dead_code, unreachable_patterns)]
5428 fn _type_assertion(
5429 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5430 ) {
5431 match _t {
5432 alloy_sol_types::private::AssertTypeEq::<
5433 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5434 >(_) => {}
5435 }
5436 }
5437 #[automatically_derived]
5438 #[doc(hidden)]
5439 impl ::core::convert::From<managerSyncReturn> for UnderlyingRustTuple<'_> {
5440 fn from(value: managerSyncReturn) -> Self {
5441 ()
5442 }
5443 }
5444 #[automatically_derived]
5445 #[doc(hidden)]
5446 impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerSyncReturn {
5447 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5448 Self {}
5449 }
5450 }
5451 }
5452 impl managerSyncReturn {
5453 fn _tokenize(
5454 &self,
5455 ) -> <managerSyncCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
5456 ()
5457 }
5458 }
5459 #[automatically_derived]
5460 impl alloy_sol_types::SolCall for managerSyncCall {
5461 type Parameters<'a> = (
5462 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5463 );
5464 type Token<'a> = <Self::Parameters<
5465 'a,
5466 > as alloy_sol_types::SolType>::Token<'a>;
5467 type Return = managerSyncReturn;
5468 type ReturnTuple<'a> = ();
5469 type ReturnToken<'a> = <Self::ReturnTuple<
5470 'a,
5471 > as alloy_sol_types::SolType>::Token<'a>;
5472 const SIGNATURE: &'static str = "managerSync(address[])";
5473 const SELECTOR: [u8; 4] = [44u8, 51u8, 202u8, 251u8];
5474 #[inline]
5475 fn new<'a>(
5476 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5477 ) -> Self {
5478 tuple.into()
5479 }
5480 #[inline]
5481 fn tokenize(&self) -> Self::Token<'_> {
5482 (
5483 <alloy::sol_types::sol_data::Array<
5484 alloy::sol_types::sol_data::Address,
5485 > as alloy_sol_types::SolType>::tokenize(&self.stakingAccounts),
5486 )
5487 }
5488 #[inline]
5489 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5490 managerSyncReturn::_tokenize(ret)
5491 }
5492 #[inline]
5493 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5494 <Self::ReturnTuple<
5495 '_,
5496 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5497 .map(Into::into)
5498 }
5499 #[inline]
5500 fn abi_decode_returns_validate(
5501 data: &[u8],
5502 ) -> alloy_sol_types::Result<Self::Return> {
5503 <Self::ReturnTuple<
5504 '_,
5505 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5506 .map(Into::into)
5507 }
5508 }
5509 };
5510 #[derive(serde::Serialize, serde::Deserialize)]
5511 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5512 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5517 #[derive(Clone)]
5518 pub struct maxAdditionalRegistrationsCall {
5519 #[allow(missing_docs)]
5520 pub stakingAccount: alloy::sol_types::private::Address,
5521 }
5522 #[derive(serde::Serialize, serde::Deserialize)]
5523 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5524 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5526 #[derive(Clone)]
5527 pub struct maxAdditionalRegistrationsReturn {
5528 #[allow(missing_docs)]
5529 pub _0: alloy::sol_types::private::primitives::aliases::U256,
5530 }
5531 #[allow(
5532 non_camel_case_types,
5533 non_snake_case,
5534 clippy::pub_underscore_fields,
5535 clippy::style
5536 )]
5537 const _: () = {
5538 use alloy::sol_types as alloy_sol_types;
5539 {
5540 #[doc(hidden)]
5541 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5542 #[doc(hidden)]
5543 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5544 #[cfg(test)]
5545 #[allow(dead_code, unreachable_patterns)]
5546 fn _type_assertion(
5547 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5548 ) {
5549 match _t {
5550 alloy_sol_types::private::AssertTypeEq::<
5551 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5552 >(_) => {}
5553 }
5554 }
5555 #[automatically_derived]
5556 #[doc(hidden)]
5557 impl ::core::convert::From<maxAdditionalRegistrationsCall>
5558 for UnderlyingRustTuple<'_> {
5559 fn from(value: maxAdditionalRegistrationsCall) -> Self {
5560 (value.stakingAccount,)
5561 }
5562 }
5563 #[automatically_derived]
5564 #[doc(hidden)]
5565 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5566 for maxAdditionalRegistrationsCall {
5567 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5568 Self { stakingAccount: tuple.0 }
5569 }
5570 }
5571 }
5572 {
5573 #[doc(hidden)]
5574 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5575 #[doc(hidden)]
5576 type UnderlyingRustTuple<'a> = (
5577 alloy::sol_types::private::primitives::aliases::U256,
5578 );
5579 #[cfg(test)]
5580 #[allow(dead_code, unreachable_patterns)]
5581 fn _type_assertion(
5582 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5583 ) {
5584 match _t {
5585 alloy_sol_types::private::AssertTypeEq::<
5586 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5587 >(_) => {}
5588 }
5589 }
5590 #[automatically_derived]
5591 #[doc(hidden)]
5592 impl ::core::convert::From<maxAdditionalRegistrationsReturn>
5593 for UnderlyingRustTuple<'_> {
5594 fn from(value: maxAdditionalRegistrationsReturn) -> Self {
5595 (value._0,)
5596 }
5597 }
5598 #[automatically_derived]
5599 #[doc(hidden)]
5600 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5601 for maxAdditionalRegistrationsReturn {
5602 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5603 Self { _0: tuple.0 }
5604 }
5605 }
5606 }
5607 #[automatically_derived]
5608 impl alloy_sol_types::SolCall for maxAdditionalRegistrationsCall {
5609 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
5610 type Token<'a> = <Self::Parameters<
5611 'a,
5612 > as alloy_sol_types::SolType>::Token<'a>;
5613 type Return = alloy::sol_types::private::primitives::aliases::U256;
5614 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5615 type ReturnToken<'a> = <Self::ReturnTuple<
5616 'a,
5617 > as alloy_sol_types::SolType>::Token<'a>;
5618 const SIGNATURE: &'static str = "maxAdditionalRegistrations(address)";
5619 const SELECTOR: [u8; 4] = [42u8, 45u8, 238u8, 226u8];
5620 #[inline]
5621 fn new<'a>(
5622 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5623 ) -> Self {
5624 tuple.into()
5625 }
5626 #[inline]
5627 fn tokenize(&self) -> Self::Token<'_> {
5628 (
5629 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5630 &self.stakingAccount,
5631 ),
5632 )
5633 }
5634 #[inline]
5635 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5636 (
5637 <alloy::sol_types::sol_data::Uint<
5638 256,
5639 > as alloy_sol_types::SolType>::tokenize(ret),
5640 )
5641 }
5642 #[inline]
5643 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5644 <Self::ReturnTuple<
5645 '_,
5646 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5647 .map(|r| {
5648 let r: maxAdditionalRegistrationsReturn = r.into();
5649 r._0
5650 })
5651 }
5652 #[inline]
5653 fn abi_decode_returns_validate(
5654 data: &[u8],
5655 ) -> alloy_sol_types::Result<Self::Return> {
5656 <Self::ReturnTuple<
5657 '_,
5658 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5659 .map(|r| {
5660 let r: maxAdditionalRegistrationsReturn = r.into();
5661 r._0
5662 })
5663 }
5664 }
5665 };
5666 #[derive(serde::Serialize, serde::Deserialize)]
5667 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5668 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5673 #[derive(Clone)]
5674 pub struct nodeRegisterdToAccountCall(pub alloy::sol_types::private::Address);
5675 #[derive(serde::Serialize, serde::Deserialize)]
5676 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5677 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5679 #[derive(Clone)]
5680 pub struct nodeRegisterdToAccountReturn {
5681 #[allow(missing_docs)]
5682 pub _0: alloy::sol_types::private::Address,
5683 }
5684 #[allow(
5685 non_camel_case_types,
5686 non_snake_case,
5687 clippy::pub_underscore_fields,
5688 clippy::style
5689 )]
5690 const _: () = {
5691 use alloy::sol_types as alloy_sol_types;
5692 {
5693 #[doc(hidden)]
5694 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5695 #[doc(hidden)]
5696 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5697 #[cfg(test)]
5698 #[allow(dead_code, unreachable_patterns)]
5699 fn _type_assertion(
5700 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5701 ) {
5702 match _t {
5703 alloy_sol_types::private::AssertTypeEq::<
5704 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5705 >(_) => {}
5706 }
5707 }
5708 #[automatically_derived]
5709 #[doc(hidden)]
5710 impl ::core::convert::From<nodeRegisterdToAccountCall>
5711 for UnderlyingRustTuple<'_> {
5712 fn from(value: nodeRegisterdToAccountCall) -> Self {
5713 (value.0,)
5714 }
5715 }
5716 #[automatically_derived]
5717 #[doc(hidden)]
5718 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5719 for nodeRegisterdToAccountCall {
5720 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5721 Self(tuple.0)
5722 }
5723 }
5724 }
5725 {
5726 #[doc(hidden)]
5727 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5728 #[doc(hidden)]
5729 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5730 #[cfg(test)]
5731 #[allow(dead_code, unreachable_patterns)]
5732 fn _type_assertion(
5733 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5734 ) {
5735 match _t {
5736 alloy_sol_types::private::AssertTypeEq::<
5737 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5738 >(_) => {}
5739 }
5740 }
5741 #[automatically_derived]
5742 #[doc(hidden)]
5743 impl ::core::convert::From<nodeRegisterdToAccountReturn>
5744 for UnderlyingRustTuple<'_> {
5745 fn from(value: nodeRegisterdToAccountReturn) -> Self {
5746 (value._0,)
5747 }
5748 }
5749 #[automatically_derived]
5750 #[doc(hidden)]
5751 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5752 for nodeRegisterdToAccountReturn {
5753 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5754 Self { _0: tuple.0 }
5755 }
5756 }
5757 }
5758 #[automatically_derived]
5759 impl alloy_sol_types::SolCall for nodeRegisterdToAccountCall {
5760 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
5761 type Token<'a> = <Self::Parameters<
5762 'a,
5763 > as alloy_sol_types::SolType>::Token<'a>;
5764 type Return = alloy::sol_types::private::Address;
5765 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
5766 type ReturnToken<'a> = <Self::ReturnTuple<
5767 'a,
5768 > as alloy_sol_types::SolType>::Token<'a>;
5769 const SIGNATURE: &'static str = "nodeRegisterdToAccount(address)";
5770 const SELECTOR: [u8; 4] = [199u8, 236u8, 171u8, 143u8];
5771 #[inline]
5772 fn new<'a>(
5773 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5774 ) -> Self {
5775 tuple.into()
5776 }
5777 #[inline]
5778 fn tokenize(&self) -> Self::Token<'_> {
5779 (
5780 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5781 &self.0,
5782 ),
5783 )
5784 }
5785 #[inline]
5786 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5787 (
5788 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5789 ret,
5790 ),
5791 )
5792 }
5793 #[inline]
5794 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5795 <Self::ReturnTuple<
5796 '_,
5797 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5798 .map(|r| {
5799 let r: nodeRegisterdToAccountReturn = r.into();
5800 r._0
5801 })
5802 }
5803 #[inline]
5804 fn abi_decode_returns_validate(
5805 data: &[u8],
5806 ) -> alloy_sol_types::Result<Self::Return> {
5807 <Self::ReturnTuple<
5808 '_,
5809 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5810 .map(|r| {
5811 let r: nodeRegisterdToAccountReturn = r.into();
5812 r._0
5813 })
5814 }
5815 }
5816 };
5817 #[derive(serde::Serialize, serde::Deserialize)]
5818 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5819 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5824 #[derive(Clone)]
5825 pub struct renounceRoleCall {
5826 #[allow(missing_docs)]
5827 pub role: alloy::sol_types::private::FixedBytes<32>,
5828 #[allow(missing_docs)]
5829 pub account: alloy::sol_types::private::Address,
5830 }
5831 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5833 #[derive(Clone)]
5834 pub struct renounceRoleReturn {}
5835 #[allow(
5836 non_camel_case_types,
5837 non_snake_case,
5838 clippy::pub_underscore_fields,
5839 clippy::style
5840 )]
5841 const _: () = {
5842 use alloy::sol_types as alloy_sol_types;
5843 {
5844 #[doc(hidden)]
5845 type UnderlyingSolTuple<'a> = (
5846 alloy::sol_types::sol_data::FixedBytes<32>,
5847 alloy::sol_types::sol_data::Address,
5848 );
5849 #[doc(hidden)]
5850 type UnderlyingRustTuple<'a> = (
5851 alloy::sol_types::private::FixedBytes<32>,
5852 alloy::sol_types::private::Address,
5853 );
5854 #[cfg(test)]
5855 #[allow(dead_code, unreachable_patterns)]
5856 fn _type_assertion(
5857 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5858 ) {
5859 match _t {
5860 alloy_sol_types::private::AssertTypeEq::<
5861 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5862 >(_) => {}
5863 }
5864 }
5865 #[automatically_derived]
5866 #[doc(hidden)]
5867 impl ::core::convert::From<renounceRoleCall> for UnderlyingRustTuple<'_> {
5868 fn from(value: renounceRoleCall) -> Self {
5869 (value.role, value.account)
5870 }
5871 }
5872 #[automatically_derived]
5873 #[doc(hidden)]
5874 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleCall {
5875 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5876 Self {
5877 role: tuple.0,
5878 account: tuple.1,
5879 }
5880 }
5881 }
5882 }
5883 {
5884 #[doc(hidden)]
5885 type UnderlyingSolTuple<'a> = ();
5886 #[doc(hidden)]
5887 type UnderlyingRustTuple<'a> = ();
5888 #[cfg(test)]
5889 #[allow(dead_code, unreachable_patterns)]
5890 fn _type_assertion(
5891 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5892 ) {
5893 match _t {
5894 alloy_sol_types::private::AssertTypeEq::<
5895 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5896 >(_) => {}
5897 }
5898 }
5899 #[automatically_derived]
5900 #[doc(hidden)]
5901 impl ::core::convert::From<renounceRoleReturn> for UnderlyingRustTuple<'_> {
5902 fn from(value: renounceRoleReturn) -> Self {
5903 ()
5904 }
5905 }
5906 #[automatically_derived]
5907 #[doc(hidden)]
5908 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleReturn {
5909 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5910 Self {}
5911 }
5912 }
5913 }
5914 impl renounceRoleReturn {
5915 fn _tokenize(
5916 &self,
5917 ) -> <renounceRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
5918 ()
5919 }
5920 }
5921 #[automatically_derived]
5922 impl alloy_sol_types::SolCall for renounceRoleCall {
5923 type Parameters<'a> = (
5924 alloy::sol_types::sol_data::FixedBytes<32>,
5925 alloy::sol_types::sol_data::Address,
5926 );
5927 type Token<'a> = <Self::Parameters<
5928 'a,
5929 > as alloy_sol_types::SolType>::Token<'a>;
5930 type Return = renounceRoleReturn;
5931 type ReturnTuple<'a> = ();
5932 type ReturnToken<'a> = <Self::ReturnTuple<
5933 'a,
5934 > as alloy_sol_types::SolType>::Token<'a>;
5935 const SIGNATURE: &'static str = "renounceRole(bytes32,address)";
5936 const SELECTOR: [u8; 4] = [54u8, 86u8, 138u8, 190u8];
5937 #[inline]
5938 fn new<'a>(
5939 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5940 ) -> Self {
5941 tuple.into()
5942 }
5943 #[inline]
5944 fn tokenize(&self) -> Self::Token<'_> {
5945 (
5946 <alloy::sol_types::sol_data::FixedBytes<
5947 32,
5948 > as alloy_sol_types::SolType>::tokenize(&self.role),
5949 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5950 &self.account,
5951 ),
5952 )
5953 }
5954 #[inline]
5955 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5956 renounceRoleReturn::_tokenize(ret)
5957 }
5958 #[inline]
5959 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5960 <Self::ReturnTuple<
5961 '_,
5962 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5963 .map(Into::into)
5964 }
5965 #[inline]
5966 fn abi_decode_returns_validate(
5967 data: &[u8],
5968 ) -> alloy_sol_types::Result<Self::Return> {
5969 <Self::ReturnTuple<
5970 '_,
5971 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5972 .map(Into::into)
5973 }
5974 }
5975 };
5976 #[derive(serde::Serialize, serde::Deserialize)]
5977 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5978 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5983 #[derive(Clone)]
5984 pub struct requirementImplementationCall;
5985 #[derive(serde::Serialize, serde::Deserialize)]
5986 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5987 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5989 #[derive(Clone)]
5990 pub struct requirementImplementationReturn {
5991 #[allow(missing_docs)]
5992 pub _0: alloy::sol_types::private::Address,
5993 }
5994 #[allow(
5995 non_camel_case_types,
5996 non_snake_case,
5997 clippy::pub_underscore_fields,
5998 clippy::style
5999 )]
6000 const _: () = {
6001 use alloy::sol_types as alloy_sol_types;
6002 {
6003 #[doc(hidden)]
6004 type UnderlyingSolTuple<'a> = ();
6005 #[doc(hidden)]
6006 type UnderlyingRustTuple<'a> = ();
6007 #[cfg(test)]
6008 #[allow(dead_code, unreachable_patterns)]
6009 fn _type_assertion(
6010 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6011 ) {
6012 match _t {
6013 alloy_sol_types::private::AssertTypeEq::<
6014 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6015 >(_) => {}
6016 }
6017 }
6018 #[automatically_derived]
6019 #[doc(hidden)]
6020 impl ::core::convert::From<requirementImplementationCall>
6021 for UnderlyingRustTuple<'_> {
6022 fn from(value: requirementImplementationCall) -> Self {
6023 ()
6024 }
6025 }
6026 #[automatically_derived]
6027 #[doc(hidden)]
6028 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6029 for requirementImplementationCall {
6030 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6031 Self
6032 }
6033 }
6034 }
6035 {
6036 #[doc(hidden)]
6037 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6038 #[doc(hidden)]
6039 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6040 #[cfg(test)]
6041 #[allow(dead_code, unreachable_patterns)]
6042 fn _type_assertion(
6043 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6044 ) {
6045 match _t {
6046 alloy_sol_types::private::AssertTypeEq::<
6047 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6048 >(_) => {}
6049 }
6050 }
6051 #[automatically_derived]
6052 #[doc(hidden)]
6053 impl ::core::convert::From<requirementImplementationReturn>
6054 for UnderlyingRustTuple<'_> {
6055 fn from(value: requirementImplementationReturn) -> Self {
6056 (value._0,)
6057 }
6058 }
6059 #[automatically_derived]
6060 #[doc(hidden)]
6061 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6062 for requirementImplementationReturn {
6063 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6064 Self { _0: tuple.0 }
6065 }
6066 }
6067 }
6068 #[automatically_derived]
6069 impl alloy_sol_types::SolCall for requirementImplementationCall {
6070 type Parameters<'a> = ();
6071 type Token<'a> = <Self::Parameters<
6072 'a,
6073 > as alloy_sol_types::SolType>::Token<'a>;
6074 type Return = alloy::sol_types::private::Address;
6075 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
6076 type ReturnToken<'a> = <Self::ReturnTuple<
6077 'a,
6078 > as alloy_sol_types::SolType>::Token<'a>;
6079 const SIGNATURE: &'static str = "requirementImplementation()";
6080 const SELECTOR: [u8; 4] = [227u8, 210u8, 160u8, 113u8];
6081 #[inline]
6082 fn new<'a>(
6083 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6084 ) -> Self {
6085 tuple.into()
6086 }
6087 #[inline]
6088 fn tokenize(&self) -> Self::Token<'_> {
6089 ()
6090 }
6091 #[inline]
6092 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6093 (
6094 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6095 ret,
6096 ),
6097 )
6098 }
6099 #[inline]
6100 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6101 <Self::ReturnTuple<
6102 '_,
6103 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6104 .map(|r| {
6105 let r: requirementImplementationReturn = r.into();
6106 r._0
6107 })
6108 }
6109 #[inline]
6110 fn abi_decode_returns_validate(
6111 data: &[u8],
6112 ) -> alloy_sol_types::Result<Self::Return> {
6113 <Self::ReturnTuple<
6114 '_,
6115 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6116 .map(|r| {
6117 let r: requirementImplementationReturn = r.into();
6118 r._0
6119 })
6120 }
6121 }
6122 };
6123 #[derive(serde::Serialize, serde::Deserialize)]
6124 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6125 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6130 #[derive(Clone)]
6131 pub struct revokeRoleCall {
6132 #[allow(missing_docs)]
6133 pub role: alloy::sol_types::private::FixedBytes<32>,
6134 #[allow(missing_docs)]
6135 pub account: alloy::sol_types::private::Address,
6136 }
6137 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6139 #[derive(Clone)]
6140 pub struct revokeRoleReturn {}
6141 #[allow(
6142 non_camel_case_types,
6143 non_snake_case,
6144 clippy::pub_underscore_fields,
6145 clippy::style
6146 )]
6147 const _: () = {
6148 use alloy::sol_types as alloy_sol_types;
6149 {
6150 #[doc(hidden)]
6151 type UnderlyingSolTuple<'a> = (
6152 alloy::sol_types::sol_data::FixedBytes<32>,
6153 alloy::sol_types::sol_data::Address,
6154 );
6155 #[doc(hidden)]
6156 type UnderlyingRustTuple<'a> = (
6157 alloy::sol_types::private::FixedBytes<32>,
6158 alloy::sol_types::private::Address,
6159 );
6160 #[cfg(test)]
6161 #[allow(dead_code, unreachable_patterns)]
6162 fn _type_assertion(
6163 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6164 ) {
6165 match _t {
6166 alloy_sol_types::private::AssertTypeEq::<
6167 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6168 >(_) => {}
6169 }
6170 }
6171 #[automatically_derived]
6172 #[doc(hidden)]
6173 impl ::core::convert::From<revokeRoleCall> for UnderlyingRustTuple<'_> {
6174 fn from(value: revokeRoleCall) -> Self {
6175 (value.role, value.account)
6176 }
6177 }
6178 #[automatically_derived]
6179 #[doc(hidden)]
6180 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleCall {
6181 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6182 Self {
6183 role: tuple.0,
6184 account: tuple.1,
6185 }
6186 }
6187 }
6188 }
6189 {
6190 #[doc(hidden)]
6191 type UnderlyingSolTuple<'a> = ();
6192 #[doc(hidden)]
6193 type UnderlyingRustTuple<'a> = ();
6194 #[cfg(test)]
6195 #[allow(dead_code, unreachable_patterns)]
6196 fn _type_assertion(
6197 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6198 ) {
6199 match _t {
6200 alloy_sol_types::private::AssertTypeEq::<
6201 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6202 >(_) => {}
6203 }
6204 }
6205 #[automatically_derived]
6206 #[doc(hidden)]
6207 impl ::core::convert::From<revokeRoleReturn> for UnderlyingRustTuple<'_> {
6208 fn from(value: revokeRoleReturn) -> Self {
6209 ()
6210 }
6211 }
6212 #[automatically_derived]
6213 #[doc(hidden)]
6214 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleReturn {
6215 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6216 Self {}
6217 }
6218 }
6219 }
6220 impl revokeRoleReturn {
6221 fn _tokenize(
6222 &self,
6223 ) -> <revokeRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6224 ()
6225 }
6226 }
6227 #[automatically_derived]
6228 impl alloy_sol_types::SolCall for revokeRoleCall {
6229 type Parameters<'a> = (
6230 alloy::sol_types::sol_data::FixedBytes<32>,
6231 alloy::sol_types::sol_data::Address,
6232 );
6233 type Token<'a> = <Self::Parameters<
6234 'a,
6235 > as alloy_sol_types::SolType>::Token<'a>;
6236 type Return = revokeRoleReturn;
6237 type ReturnTuple<'a> = ();
6238 type ReturnToken<'a> = <Self::ReturnTuple<
6239 'a,
6240 > as alloy_sol_types::SolType>::Token<'a>;
6241 const SIGNATURE: &'static str = "revokeRole(bytes32,address)";
6242 const SELECTOR: [u8; 4] = [213u8, 71u8, 116u8, 31u8];
6243 #[inline]
6244 fn new<'a>(
6245 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6246 ) -> Self {
6247 tuple.into()
6248 }
6249 #[inline]
6250 fn tokenize(&self) -> Self::Token<'_> {
6251 (
6252 <alloy::sol_types::sol_data::FixedBytes<
6253 32,
6254 > as alloy_sol_types::SolType>::tokenize(&self.role),
6255 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6256 &self.account,
6257 ),
6258 )
6259 }
6260 #[inline]
6261 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6262 revokeRoleReturn::_tokenize(ret)
6263 }
6264 #[inline]
6265 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6266 <Self::ReturnTuple<
6267 '_,
6268 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6269 .map(Into::into)
6270 }
6271 #[inline]
6272 fn abi_decode_returns_validate(
6273 data: &[u8],
6274 ) -> alloy_sol_types::Result<Self::Return> {
6275 <Self::ReturnTuple<
6276 '_,
6277 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6278 .map(Into::into)
6279 }
6280 }
6281 };
6282 #[derive(serde::Serialize, serde::Deserialize)]
6283 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6284 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6289 #[derive(Clone)]
6290 pub struct selfDeregisterCall {
6291 #[allow(missing_docs)]
6292 pub nodeAddresses: alloy::sol_types::private::Vec<
6293 alloy::sol_types::private::Address,
6294 >,
6295 }
6296 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6298 #[derive(Clone)]
6299 pub struct selfDeregisterReturn {}
6300 #[allow(
6301 non_camel_case_types,
6302 non_snake_case,
6303 clippy::pub_underscore_fields,
6304 clippy::style
6305 )]
6306 const _: () = {
6307 use alloy::sol_types as alloy_sol_types;
6308 {
6309 #[doc(hidden)]
6310 type UnderlyingSolTuple<'a> = (
6311 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6312 );
6313 #[doc(hidden)]
6314 type UnderlyingRustTuple<'a> = (
6315 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
6316 );
6317 #[cfg(test)]
6318 #[allow(dead_code, unreachable_patterns)]
6319 fn _type_assertion(
6320 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6321 ) {
6322 match _t {
6323 alloy_sol_types::private::AssertTypeEq::<
6324 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6325 >(_) => {}
6326 }
6327 }
6328 #[automatically_derived]
6329 #[doc(hidden)]
6330 impl ::core::convert::From<selfDeregisterCall> for UnderlyingRustTuple<'_> {
6331 fn from(value: selfDeregisterCall) -> Self {
6332 (value.nodeAddresses,)
6333 }
6334 }
6335 #[automatically_derived]
6336 #[doc(hidden)]
6337 impl ::core::convert::From<UnderlyingRustTuple<'_>> for selfDeregisterCall {
6338 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6339 Self { nodeAddresses: tuple.0 }
6340 }
6341 }
6342 }
6343 {
6344 #[doc(hidden)]
6345 type UnderlyingSolTuple<'a> = ();
6346 #[doc(hidden)]
6347 type UnderlyingRustTuple<'a> = ();
6348 #[cfg(test)]
6349 #[allow(dead_code, unreachable_patterns)]
6350 fn _type_assertion(
6351 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6352 ) {
6353 match _t {
6354 alloy_sol_types::private::AssertTypeEq::<
6355 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6356 >(_) => {}
6357 }
6358 }
6359 #[automatically_derived]
6360 #[doc(hidden)]
6361 impl ::core::convert::From<selfDeregisterReturn>
6362 for UnderlyingRustTuple<'_> {
6363 fn from(value: selfDeregisterReturn) -> Self {
6364 ()
6365 }
6366 }
6367 #[automatically_derived]
6368 #[doc(hidden)]
6369 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6370 for selfDeregisterReturn {
6371 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6372 Self {}
6373 }
6374 }
6375 }
6376 impl selfDeregisterReturn {
6377 fn _tokenize(
6378 &self,
6379 ) -> <selfDeregisterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6380 ()
6381 }
6382 }
6383 #[automatically_derived]
6384 impl alloy_sol_types::SolCall for selfDeregisterCall {
6385 type Parameters<'a> = (
6386 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6387 );
6388 type Token<'a> = <Self::Parameters<
6389 'a,
6390 > as alloy_sol_types::SolType>::Token<'a>;
6391 type Return = selfDeregisterReturn;
6392 type ReturnTuple<'a> = ();
6393 type ReturnToken<'a> = <Self::ReturnTuple<
6394 'a,
6395 > as alloy_sol_types::SolType>::Token<'a>;
6396 const SIGNATURE: &'static str = "selfDeregister(address[])";
6397 const SELECTOR: [u8; 4] = [160u8, 94u8, 15u8, 109u8];
6398 #[inline]
6399 fn new<'a>(
6400 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6401 ) -> Self {
6402 tuple.into()
6403 }
6404 #[inline]
6405 fn tokenize(&self) -> Self::Token<'_> {
6406 (
6407 <alloy::sol_types::sol_data::Array<
6408 alloy::sol_types::sol_data::Address,
6409 > as alloy_sol_types::SolType>::tokenize(&self.nodeAddresses),
6410 )
6411 }
6412 #[inline]
6413 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6414 selfDeregisterReturn::_tokenize(ret)
6415 }
6416 #[inline]
6417 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6418 <Self::ReturnTuple<
6419 '_,
6420 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6421 .map(Into::into)
6422 }
6423 #[inline]
6424 fn abi_decode_returns_validate(
6425 data: &[u8],
6426 ) -> alloy_sol_types::Result<Self::Return> {
6427 <Self::ReturnTuple<
6428 '_,
6429 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6430 .map(Into::into)
6431 }
6432 }
6433 };
6434 #[derive(serde::Serialize, serde::Deserialize)]
6435 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6436 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6441 #[derive(Clone)]
6442 pub struct selfRegisterCall {
6443 #[allow(missing_docs)]
6444 pub nodeAddresses: alloy::sol_types::private::Vec<
6445 alloy::sol_types::private::Address,
6446 >,
6447 }
6448 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6450 #[derive(Clone)]
6451 pub struct selfRegisterReturn {}
6452 #[allow(
6453 non_camel_case_types,
6454 non_snake_case,
6455 clippy::pub_underscore_fields,
6456 clippy::style
6457 )]
6458 const _: () = {
6459 use alloy::sol_types as alloy_sol_types;
6460 {
6461 #[doc(hidden)]
6462 type UnderlyingSolTuple<'a> = (
6463 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6464 );
6465 #[doc(hidden)]
6466 type UnderlyingRustTuple<'a> = (
6467 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
6468 );
6469 #[cfg(test)]
6470 #[allow(dead_code, unreachable_patterns)]
6471 fn _type_assertion(
6472 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6473 ) {
6474 match _t {
6475 alloy_sol_types::private::AssertTypeEq::<
6476 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6477 >(_) => {}
6478 }
6479 }
6480 #[automatically_derived]
6481 #[doc(hidden)]
6482 impl ::core::convert::From<selfRegisterCall> for UnderlyingRustTuple<'_> {
6483 fn from(value: selfRegisterCall) -> Self {
6484 (value.nodeAddresses,)
6485 }
6486 }
6487 #[automatically_derived]
6488 #[doc(hidden)]
6489 impl ::core::convert::From<UnderlyingRustTuple<'_>> for selfRegisterCall {
6490 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6491 Self { nodeAddresses: tuple.0 }
6492 }
6493 }
6494 }
6495 {
6496 #[doc(hidden)]
6497 type UnderlyingSolTuple<'a> = ();
6498 #[doc(hidden)]
6499 type UnderlyingRustTuple<'a> = ();
6500 #[cfg(test)]
6501 #[allow(dead_code, unreachable_patterns)]
6502 fn _type_assertion(
6503 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6504 ) {
6505 match _t {
6506 alloy_sol_types::private::AssertTypeEq::<
6507 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6508 >(_) => {}
6509 }
6510 }
6511 #[automatically_derived]
6512 #[doc(hidden)]
6513 impl ::core::convert::From<selfRegisterReturn> for UnderlyingRustTuple<'_> {
6514 fn from(value: selfRegisterReturn) -> Self {
6515 ()
6516 }
6517 }
6518 #[automatically_derived]
6519 #[doc(hidden)]
6520 impl ::core::convert::From<UnderlyingRustTuple<'_>> for selfRegisterReturn {
6521 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6522 Self {}
6523 }
6524 }
6525 }
6526 impl selfRegisterReturn {
6527 fn _tokenize(
6528 &self,
6529 ) -> <selfRegisterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6530 ()
6531 }
6532 }
6533 #[automatically_derived]
6534 impl alloy_sol_types::SolCall for selfRegisterCall {
6535 type Parameters<'a> = (
6536 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6537 );
6538 type Token<'a> = <Self::Parameters<
6539 'a,
6540 > as alloy_sol_types::SolType>::Token<'a>;
6541 type Return = selfRegisterReturn;
6542 type ReturnTuple<'a> = ();
6543 type ReturnToken<'a> = <Self::ReturnTuple<
6544 'a,
6545 > as alloy_sol_types::SolType>::Token<'a>;
6546 const SIGNATURE: &'static str = "selfRegister(address[])";
6547 const SELECTOR: [u8; 4] = [118u8, 89u8, 58u8, 57u8];
6548 #[inline]
6549 fn new<'a>(
6550 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6551 ) -> Self {
6552 tuple.into()
6553 }
6554 #[inline]
6555 fn tokenize(&self) -> Self::Token<'_> {
6556 (
6557 <alloy::sol_types::sol_data::Array<
6558 alloy::sol_types::sol_data::Address,
6559 > as alloy_sol_types::SolType>::tokenize(&self.nodeAddresses),
6560 )
6561 }
6562 #[inline]
6563 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6564 selfRegisterReturn::_tokenize(ret)
6565 }
6566 #[inline]
6567 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6568 <Self::ReturnTuple<
6569 '_,
6570 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6571 .map(Into::into)
6572 }
6573 #[inline]
6574 fn abi_decode_returns_validate(
6575 data: &[u8],
6576 ) -> alloy_sol_types::Result<Self::Return> {
6577 <Self::ReturnTuple<
6578 '_,
6579 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6580 .map(Into::into)
6581 }
6582 }
6583 };
6584 #[derive(serde::Serialize, serde::Deserialize)]
6585 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6586 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6591 #[derive(Clone)]
6592 pub struct selfSyncCall;
6593 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6595 #[derive(Clone)]
6596 pub struct selfSyncReturn {}
6597 #[allow(
6598 non_camel_case_types,
6599 non_snake_case,
6600 clippy::pub_underscore_fields,
6601 clippy::style
6602 )]
6603 const _: () = {
6604 use alloy::sol_types as alloy_sol_types;
6605 {
6606 #[doc(hidden)]
6607 type UnderlyingSolTuple<'a> = ();
6608 #[doc(hidden)]
6609 type UnderlyingRustTuple<'a> = ();
6610 #[cfg(test)]
6611 #[allow(dead_code, unreachable_patterns)]
6612 fn _type_assertion(
6613 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6614 ) {
6615 match _t {
6616 alloy_sol_types::private::AssertTypeEq::<
6617 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6618 >(_) => {}
6619 }
6620 }
6621 #[automatically_derived]
6622 #[doc(hidden)]
6623 impl ::core::convert::From<selfSyncCall> for UnderlyingRustTuple<'_> {
6624 fn from(value: selfSyncCall) -> Self {
6625 ()
6626 }
6627 }
6628 #[automatically_derived]
6629 #[doc(hidden)]
6630 impl ::core::convert::From<UnderlyingRustTuple<'_>> for selfSyncCall {
6631 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6632 Self
6633 }
6634 }
6635 }
6636 {
6637 #[doc(hidden)]
6638 type UnderlyingSolTuple<'a> = ();
6639 #[doc(hidden)]
6640 type UnderlyingRustTuple<'a> = ();
6641 #[cfg(test)]
6642 #[allow(dead_code, unreachable_patterns)]
6643 fn _type_assertion(
6644 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6645 ) {
6646 match _t {
6647 alloy_sol_types::private::AssertTypeEq::<
6648 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6649 >(_) => {}
6650 }
6651 }
6652 #[automatically_derived]
6653 #[doc(hidden)]
6654 impl ::core::convert::From<selfSyncReturn> for UnderlyingRustTuple<'_> {
6655 fn from(value: selfSyncReturn) -> Self {
6656 ()
6657 }
6658 }
6659 #[automatically_derived]
6660 #[doc(hidden)]
6661 impl ::core::convert::From<UnderlyingRustTuple<'_>> for selfSyncReturn {
6662 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6663 Self {}
6664 }
6665 }
6666 }
6667 impl selfSyncReturn {
6668 fn _tokenize(
6669 &self,
6670 ) -> <selfSyncCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6671 ()
6672 }
6673 }
6674 #[automatically_derived]
6675 impl alloy_sol_types::SolCall for selfSyncCall {
6676 type Parameters<'a> = ();
6677 type Token<'a> = <Self::Parameters<
6678 'a,
6679 > as alloy_sol_types::SolType>::Token<'a>;
6680 type Return = selfSyncReturn;
6681 type ReturnTuple<'a> = ();
6682 type ReturnToken<'a> = <Self::ReturnTuple<
6683 'a,
6684 > as alloy_sol_types::SolType>::Token<'a>;
6685 const SIGNATURE: &'static str = "selfSync()";
6686 const SELECTOR: [u8; 4] = [156u8, 127u8, 100u8, 59u8];
6687 #[inline]
6688 fn new<'a>(
6689 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6690 ) -> Self {
6691 tuple.into()
6692 }
6693 #[inline]
6694 fn tokenize(&self) -> Self::Token<'_> {
6695 ()
6696 }
6697 #[inline]
6698 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6699 selfSyncReturn::_tokenize(ret)
6700 }
6701 #[inline]
6702 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6703 <Self::ReturnTuple<
6704 '_,
6705 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6706 .map(Into::into)
6707 }
6708 #[inline]
6709 fn abi_decode_returns_validate(
6710 data: &[u8],
6711 ) -> alloy_sol_types::Result<Self::Return> {
6712 <Self::ReturnTuple<
6713 '_,
6714 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6715 .map(Into::into)
6716 }
6717 }
6718 };
6719 #[derive(serde::Serialize, serde::Deserialize)]
6720 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6721 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6726 #[derive(Clone)]
6727 pub struct supportsInterfaceCall {
6728 #[allow(missing_docs)]
6729 pub interfaceId: alloy::sol_types::private::FixedBytes<4>,
6730 }
6731 #[derive(serde::Serialize, serde::Deserialize)]
6732 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6733 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6735 #[derive(Clone)]
6736 pub struct supportsInterfaceReturn {
6737 #[allow(missing_docs)]
6738 pub _0: bool,
6739 }
6740 #[allow(
6741 non_camel_case_types,
6742 non_snake_case,
6743 clippy::pub_underscore_fields,
6744 clippy::style
6745 )]
6746 const _: () = {
6747 use alloy::sol_types as alloy_sol_types;
6748 {
6749 #[doc(hidden)]
6750 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6751 #[doc(hidden)]
6752 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
6753 #[cfg(test)]
6754 #[allow(dead_code, unreachable_patterns)]
6755 fn _type_assertion(
6756 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6757 ) {
6758 match _t {
6759 alloy_sol_types::private::AssertTypeEq::<
6760 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6761 >(_) => {}
6762 }
6763 }
6764 #[automatically_derived]
6765 #[doc(hidden)]
6766 impl ::core::convert::From<supportsInterfaceCall>
6767 for UnderlyingRustTuple<'_> {
6768 fn from(value: supportsInterfaceCall) -> Self {
6769 (value.interfaceId,)
6770 }
6771 }
6772 #[automatically_derived]
6773 #[doc(hidden)]
6774 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6775 for supportsInterfaceCall {
6776 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6777 Self { interfaceId: tuple.0 }
6778 }
6779 }
6780 }
6781 {
6782 #[doc(hidden)]
6783 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
6784 #[doc(hidden)]
6785 type UnderlyingRustTuple<'a> = (bool,);
6786 #[cfg(test)]
6787 #[allow(dead_code, unreachable_patterns)]
6788 fn _type_assertion(
6789 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6790 ) {
6791 match _t {
6792 alloy_sol_types::private::AssertTypeEq::<
6793 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6794 >(_) => {}
6795 }
6796 }
6797 #[automatically_derived]
6798 #[doc(hidden)]
6799 impl ::core::convert::From<supportsInterfaceReturn>
6800 for UnderlyingRustTuple<'_> {
6801 fn from(value: supportsInterfaceReturn) -> Self {
6802 (value._0,)
6803 }
6804 }
6805 #[automatically_derived]
6806 #[doc(hidden)]
6807 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6808 for supportsInterfaceReturn {
6809 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6810 Self { _0: tuple.0 }
6811 }
6812 }
6813 }
6814 #[automatically_derived]
6815 impl alloy_sol_types::SolCall for supportsInterfaceCall {
6816 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6817 type Token<'a> = <Self::Parameters<
6818 'a,
6819 > as alloy_sol_types::SolType>::Token<'a>;
6820 type Return = bool;
6821 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
6822 type ReturnToken<'a> = <Self::ReturnTuple<
6823 'a,
6824 > as alloy_sol_types::SolType>::Token<'a>;
6825 const SIGNATURE: &'static str = "supportsInterface(bytes4)";
6826 const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
6827 #[inline]
6828 fn new<'a>(
6829 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6830 ) -> Self {
6831 tuple.into()
6832 }
6833 #[inline]
6834 fn tokenize(&self) -> Self::Token<'_> {
6835 (
6836 <alloy::sol_types::sol_data::FixedBytes<
6837 4,
6838 > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
6839 )
6840 }
6841 #[inline]
6842 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6843 (
6844 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
6845 ret,
6846 ),
6847 )
6848 }
6849 #[inline]
6850 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6851 <Self::ReturnTuple<
6852 '_,
6853 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6854 .map(|r| {
6855 let r: supportsInterfaceReturn = r.into();
6856 r._0
6857 })
6858 }
6859 #[inline]
6860 fn abi_decode_returns_validate(
6861 data: &[u8],
6862 ) -> alloy_sol_types::Result<Self::Return> {
6863 <Self::ReturnTuple<
6864 '_,
6865 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6866 .map(|r| {
6867 let r: supportsInterfaceReturn = r.into();
6868 r._0
6869 })
6870 }
6871 }
6872 };
6873 #[derive(serde::Serialize, serde::Deserialize)]
6874 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6875 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6880 #[derive(Clone)]
6881 pub struct updateRequirementImplementationCall {
6882 #[allow(missing_docs)]
6883 pub _requirementImplementation: alloy::sol_types::private::Address,
6884 }
6885 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6887 #[derive(Clone)]
6888 pub struct updateRequirementImplementationReturn {}
6889 #[allow(
6890 non_camel_case_types,
6891 non_snake_case,
6892 clippy::pub_underscore_fields,
6893 clippy::style
6894 )]
6895 const _: () = {
6896 use alloy::sol_types as alloy_sol_types;
6897 {
6898 #[doc(hidden)]
6899 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6900 #[doc(hidden)]
6901 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6902 #[cfg(test)]
6903 #[allow(dead_code, unreachable_patterns)]
6904 fn _type_assertion(
6905 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6906 ) {
6907 match _t {
6908 alloy_sol_types::private::AssertTypeEq::<
6909 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6910 >(_) => {}
6911 }
6912 }
6913 #[automatically_derived]
6914 #[doc(hidden)]
6915 impl ::core::convert::From<updateRequirementImplementationCall>
6916 for UnderlyingRustTuple<'_> {
6917 fn from(value: updateRequirementImplementationCall) -> Self {
6918 (value._requirementImplementation,)
6919 }
6920 }
6921 #[automatically_derived]
6922 #[doc(hidden)]
6923 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6924 for updateRequirementImplementationCall {
6925 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6926 Self {
6927 _requirementImplementation: tuple.0,
6928 }
6929 }
6930 }
6931 }
6932 {
6933 #[doc(hidden)]
6934 type UnderlyingSolTuple<'a> = ();
6935 #[doc(hidden)]
6936 type UnderlyingRustTuple<'a> = ();
6937 #[cfg(test)]
6938 #[allow(dead_code, unreachable_patterns)]
6939 fn _type_assertion(
6940 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6941 ) {
6942 match _t {
6943 alloy_sol_types::private::AssertTypeEq::<
6944 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6945 >(_) => {}
6946 }
6947 }
6948 #[automatically_derived]
6949 #[doc(hidden)]
6950 impl ::core::convert::From<updateRequirementImplementationReturn>
6951 for UnderlyingRustTuple<'_> {
6952 fn from(value: updateRequirementImplementationReturn) -> Self {
6953 ()
6954 }
6955 }
6956 #[automatically_derived]
6957 #[doc(hidden)]
6958 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6959 for updateRequirementImplementationReturn {
6960 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6961 Self {}
6962 }
6963 }
6964 }
6965 impl updateRequirementImplementationReturn {
6966 fn _tokenize(
6967 &self,
6968 ) -> <updateRequirementImplementationCall as alloy_sol_types::SolCall>::ReturnToken<
6969 '_,
6970 > {
6971 ()
6972 }
6973 }
6974 #[automatically_derived]
6975 impl alloy_sol_types::SolCall for updateRequirementImplementationCall {
6976 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
6977 type Token<'a> = <Self::Parameters<
6978 'a,
6979 > as alloy_sol_types::SolType>::Token<'a>;
6980 type Return = updateRequirementImplementationReturn;
6981 type ReturnTuple<'a> = ();
6982 type ReturnToken<'a> = <Self::ReturnTuple<
6983 'a,
6984 > as alloy_sol_types::SolType>::Token<'a>;
6985 const SIGNATURE: &'static str = "updateRequirementImplementation(address)";
6986 const SELECTOR: [u8; 4] = [39u8, 176u8, 64u8, 161u8];
6987 #[inline]
6988 fn new<'a>(
6989 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6990 ) -> Self {
6991 tuple.into()
6992 }
6993 #[inline]
6994 fn tokenize(&self) -> Self::Token<'_> {
6995 (
6996 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6997 &self._requirementImplementation,
6998 ),
6999 )
7000 }
7001 #[inline]
7002 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7003 updateRequirementImplementationReturn::_tokenize(ret)
7004 }
7005 #[inline]
7006 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7007 <Self::ReturnTuple<
7008 '_,
7009 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7010 .map(Into::into)
7011 }
7012 #[inline]
7013 fn abi_decode_returns_validate(
7014 data: &[u8],
7015 ) -> alloy_sol_types::Result<Self::Return> {
7016 <Self::ReturnTuple<
7017 '_,
7018 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7019 .map(Into::into)
7020 }
7021 }
7022 };
7023 #[derive(serde::Serialize, serde::Deserialize)]
7025 #[derive()]
7026 pub enum HoprNetworkRegistryCalls {
7027 #[allow(missing_docs)]
7028 DEFAULT_ADMIN_ROLE(DEFAULT_ADMIN_ROLECall),
7029 #[allow(missing_docs)]
7030 MANAGER_ROLE(MANAGER_ROLECall),
7031 #[allow(missing_docs)]
7032 countRegisterdNodesPerAccount(countRegisterdNodesPerAccountCall),
7033 #[allow(missing_docs)]
7034 disableRegistry(disableRegistryCall),
7035 #[allow(missing_docs)]
7036 enableRegistry(enableRegistryCall),
7037 #[allow(missing_docs)]
7038 enabled(enabledCall),
7039 #[allow(missing_docs)]
7040 getRoleAdmin(getRoleAdminCall),
7041 #[allow(missing_docs)]
7042 getRoleMember(getRoleMemberCall),
7043 #[allow(missing_docs)]
7044 getRoleMemberCount(getRoleMemberCountCall),
7045 #[allow(missing_docs)]
7046 grantRole(grantRoleCall),
7047 #[allow(missing_docs)]
7048 hasRole(hasRoleCall),
7049 #[allow(missing_docs)]
7050 isAccountEligible(isAccountEligibleCall),
7051 #[allow(missing_docs)]
7052 isNodeRegisteredAndEligible(isNodeRegisteredAndEligibleCall),
7053 #[allow(missing_docs)]
7054 isNodeRegisteredByAccount(isNodeRegisteredByAccountCall),
7055 #[allow(missing_docs)]
7056 managerDeregister(managerDeregisterCall),
7057 #[allow(missing_docs)]
7058 managerForceSync(managerForceSyncCall),
7059 #[allow(missing_docs)]
7060 managerRegister(managerRegisterCall),
7061 #[allow(missing_docs)]
7062 managerSync(managerSyncCall),
7063 #[allow(missing_docs)]
7064 maxAdditionalRegistrations(maxAdditionalRegistrationsCall),
7065 #[allow(missing_docs)]
7066 nodeRegisterdToAccount(nodeRegisterdToAccountCall),
7067 #[allow(missing_docs)]
7068 renounceRole(renounceRoleCall),
7069 #[allow(missing_docs)]
7070 requirementImplementation(requirementImplementationCall),
7071 #[allow(missing_docs)]
7072 revokeRole(revokeRoleCall),
7073 #[allow(missing_docs)]
7074 selfDeregister(selfDeregisterCall),
7075 #[allow(missing_docs)]
7076 selfRegister(selfRegisterCall),
7077 #[allow(missing_docs)]
7078 selfSync(selfSyncCall),
7079 #[allow(missing_docs)]
7080 supportsInterface(supportsInterfaceCall),
7081 #[allow(missing_docs)]
7082 updateRequirementImplementation(updateRequirementImplementationCall),
7083 }
7084 #[automatically_derived]
7085 impl HoprNetworkRegistryCalls {
7086 pub const SELECTORS: &'static [[u8; 4usize]] = &[
7093 [1u8, 255u8, 201u8, 167u8],
7094 [35u8, 141u8, 175u8, 224u8],
7095 [36u8, 138u8, 156u8, 163u8],
7096 [39u8, 176u8, 64u8, 161u8],
7097 [42u8, 45u8, 238u8, 226u8],
7098 [44u8, 51u8, 202u8, 251u8],
7099 [47u8, 47u8, 241u8, 93u8],
7100 [54u8, 86u8, 138u8, 190u8],
7101 [63u8, 165u8, 132u8, 87u8],
7102 [65u8, 182u8, 73u8, 101u8],
7103 [78u8, 177u8, 128u8, 92u8],
7104 [111u8, 251u8, 249u8, 136u8],
7105 [118u8, 89u8, 58u8, 57u8],
7106 [141u8, 117u8, 59u8, 45u8],
7107 [144u8, 16u8, 208u8, 124u8],
7108 [145u8, 209u8, 72u8, 84u8],
7109 [156u8, 127u8, 100u8, 59u8],
7110 [160u8, 94u8, 15u8, 109u8],
7111 [162u8, 23u8, 253u8, 223u8],
7112 [165u8, 96u8, 93u8, 165u8],
7113 [199u8, 236u8, 171u8, 143u8],
7114 [202u8, 21u8, 200u8, 115u8],
7115 [202u8, 245u8, 245u8, 1u8],
7116 [203u8, 235u8, 175u8, 224u8],
7117 [207u8, 179u8, 115u8, 95u8],
7118 [213u8, 71u8, 116u8, 31u8],
7119 [227u8, 210u8, 160u8, 113u8],
7120 [236u8, 135u8, 98u8, 28u8],
7121 ];
7122 }
7123 #[automatically_derived]
7124 impl alloy_sol_types::SolInterface for HoprNetworkRegistryCalls {
7125 const NAME: &'static str = "HoprNetworkRegistryCalls";
7126 const MIN_DATA_LENGTH: usize = 0usize;
7127 const COUNT: usize = 28usize;
7128 #[inline]
7129 fn selector(&self) -> [u8; 4] {
7130 match self {
7131 Self::DEFAULT_ADMIN_ROLE(_) => {
7132 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SELECTOR
7133 }
7134 Self::MANAGER_ROLE(_) => {
7135 <MANAGER_ROLECall as alloy_sol_types::SolCall>::SELECTOR
7136 }
7137 Self::countRegisterdNodesPerAccount(_) => {
7138 <countRegisterdNodesPerAccountCall as alloy_sol_types::SolCall>::SELECTOR
7139 }
7140 Self::disableRegistry(_) => {
7141 <disableRegistryCall as alloy_sol_types::SolCall>::SELECTOR
7142 }
7143 Self::enableRegistry(_) => {
7144 <enableRegistryCall as alloy_sol_types::SolCall>::SELECTOR
7145 }
7146 Self::enabled(_) => <enabledCall as alloy_sol_types::SolCall>::SELECTOR,
7147 Self::getRoleAdmin(_) => {
7148 <getRoleAdminCall as alloy_sol_types::SolCall>::SELECTOR
7149 }
7150 Self::getRoleMember(_) => {
7151 <getRoleMemberCall as alloy_sol_types::SolCall>::SELECTOR
7152 }
7153 Self::getRoleMemberCount(_) => {
7154 <getRoleMemberCountCall as alloy_sol_types::SolCall>::SELECTOR
7155 }
7156 Self::grantRole(_) => {
7157 <grantRoleCall as alloy_sol_types::SolCall>::SELECTOR
7158 }
7159 Self::hasRole(_) => <hasRoleCall as alloy_sol_types::SolCall>::SELECTOR,
7160 Self::isAccountEligible(_) => {
7161 <isAccountEligibleCall as alloy_sol_types::SolCall>::SELECTOR
7162 }
7163 Self::isNodeRegisteredAndEligible(_) => {
7164 <isNodeRegisteredAndEligibleCall as alloy_sol_types::SolCall>::SELECTOR
7165 }
7166 Self::isNodeRegisteredByAccount(_) => {
7167 <isNodeRegisteredByAccountCall as alloy_sol_types::SolCall>::SELECTOR
7168 }
7169 Self::managerDeregister(_) => {
7170 <managerDeregisterCall as alloy_sol_types::SolCall>::SELECTOR
7171 }
7172 Self::managerForceSync(_) => {
7173 <managerForceSyncCall as alloy_sol_types::SolCall>::SELECTOR
7174 }
7175 Self::managerRegister(_) => {
7176 <managerRegisterCall as alloy_sol_types::SolCall>::SELECTOR
7177 }
7178 Self::managerSync(_) => {
7179 <managerSyncCall as alloy_sol_types::SolCall>::SELECTOR
7180 }
7181 Self::maxAdditionalRegistrations(_) => {
7182 <maxAdditionalRegistrationsCall as alloy_sol_types::SolCall>::SELECTOR
7183 }
7184 Self::nodeRegisterdToAccount(_) => {
7185 <nodeRegisterdToAccountCall as alloy_sol_types::SolCall>::SELECTOR
7186 }
7187 Self::renounceRole(_) => {
7188 <renounceRoleCall as alloy_sol_types::SolCall>::SELECTOR
7189 }
7190 Self::requirementImplementation(_) => {
7191 <requirementImplementationCall as alloy_sol_types::SolCall>::SELECTOR
7192 }
7193 Self::revokeRole(_) => {
7194 <revokeRoleCall as alloy_sol_types::SolCall>::SELECTOR
7195 }
7196 Self::selfDeregister(_) => {
7197 <selfDeregisterCall as alloy_sol_types::SolCall>::SELECTOR
7198 }
7199 Self::selfRegister(_) => {
7200 <selfRegisterCall as alloy_sol_types::SolCall>::SELECTOR
7201 }
7202 Self::selfSync(_) => <selfSyncCall as alloy_sol_types::SolCall>::SELECTOR,
7203 Self::supportsInterface(_) => {
7204 <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
7205 }
7206 Self::updateRequirementImplementation(_) => {
7207 <updateRequirementImplementationCall as alloy_sol_types::SolCall>::SELECTOR
7208 }
7209 }
7210 }
7211 #[inline]
7212 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
7213 Self::SELECTORS.get(i).copied()
7214 }
7215 #[inline]
7216 fn valid_selector(selector: [u8; 4]) -> bool {
7217 Self::SELECTORS.binary_search(&selector).is_ok()
7218 }
7219 #[inline]
7220 #[allow(non_snake_case)]
7221 fn abi_decode_raw(
7222 selector: [u8; 4],
7223 data: &[u8],
7224 ) -> alloy_sol_types::Result<Self> {
7225 static DECODE_SHIMS: &[fn(
7226 &[u8],
7227 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls>] = &[
7228 {
7229 fn supportsInterface(
7230 data: &[u8],
7231 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7232 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(
7233 data,
7234 )
7235 .map(HoprNetworkRegistryCalls::supportsInterface)
7236 }
7237 supportsInterface
7238 },
7239 {
7240 fn enabled(
7241 data: &[u8],
7242 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7243 <enabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
7244 .map(HoprNetworkRegistryCalls::enabled)
7245 }
7246 enabled
7247 },
7248 {
7249 fn getRoleAdmin(
7250 data: &[u8],
7251 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7252 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
7253 data,
7254 )
7255 .map(HoprNetworkRegistryCalls::getRoleAdmin)
7256 }
7257 getRoleAdmin
7258 },
7259 {
7260 fn updateRequirementImplementation(
7261 data: &[u8],
7262 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7263 <updateRequirementImplementationCall as alloy_sol_types::SolCall>::abi_decode_raw(
7264 data,
7265 )
7266 .map(
7267 HoprNetworkRegistryCalls::updateRequirementImplementation,
7268 )
7269 }
7270 updateRequirementImplementation
7271 },
7272 {
7273 fn maxAdditionalRegistrations(
7274 data: &[u8],
7275 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7276 <maxAdditionalRegistrationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
7277 data,
7278 )
7279 .map(HoprNetworkRegistryCalls::maxAdditionalRegistrations)
7280 }
7281 maxAdditionalRegistrations
7282 },
7283 {
7284 fn managerSync(
7285 data: &[u8],
7286 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7287 <managerSyncCall as alloy_sol_types::SolCall>::abi_decode_raw(
7288 data,
7289 )
7290 .map(HoprNetworkRegistryCalls::managerSync)
7291 }
7292 managerSync
7293 },
7294 {
7295 fn grantRole(
7296 data: &[u8],
7297 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7298 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
7299 .map(HoprNetworkRegistryCalls::grantRole)
7300 }
7301 grantRole
7302 },
7303 {
7304 fn renounceRole(
7305 data: &[u8],
7306 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7307 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
7308 data,
7309 )
7310 .map(HoprNetworkRegistryCalls::renounceRole)
7311 }
7312 renounceRole
7313 },
7314 {
7315 fn countRegisterdNodesPerAccount(
7316 data: &[u8],
7317 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7318 <countRegisterdNodesPerAccountCall as alloy_sol_types::SolCall>::abi_decode_raw(
7319 data,
7320 )
7321 .map(HoprNetworkRegistryCalls::countRegisterdNodesPerAccount)
7322 }
7323 countRegisterdNodesPerAccount
7324 },
7325 {
7326 fn managerDeregister(
7327 data: &[u8],
7328 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7329 <managerDeregisterCall as alloy_sol_types::SolCall>::abi_decode_raw(
7330 data,
7331 )
7332 .map(HoprNetworkRegistryCalls::managerDeregister)
7333 }
7334 managerDeregister
7335 },
7336 {
7337 fn isNodeRegisteredAndEligible(
7338 data: &[u8],
7339 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7340 <isNodeRegisteredAndEligibleCall as alloy_sol_types::SolCall>::abi_decode_raw(
7341 data,
7342 )
7343 .map(HoprNetworkRegistryCalls::isNodeRegisteredAndEligible)
7344 }
7345 isNodeRegisteredAndEligible
7346 },
7347 {
7348 fn isAccountEligible(
7349 data: &[u8],
7350 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7351 <isAccountEligibleCall as alloy_sol_types::SolCall>::abi_decode_raw(
7352 data,
7353 )
7354 .map(HoprNetworkRegistryCalls::isAccountEligible)
7355 }
7356 isAccountEligible
7357 },
7358 {
7359 fn selfRegister(
7360 data: &[u8],
7361 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7362 <selfRegisterCall as alloy_sol_types::SolCall>::abi_decode_raw(
7363 data,
7364 )
7365 .map(HoprNetworkRegistryCalls::selfRegister)
7366 }
7367 selfRegister
7368 },
7369 {
7370 fn managerRegister(
7371 data: &[u8],
7372 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7373 <managerRegisterCall as alloy_sol_types::SolCall>::abi_decode_raw(
7374 data,
7375 )
7376 .map(HoprNetworkRegistryCalls::managerRegister)
7377 }
7378 managerRegister
7379 },
7380 {
7381 fn getRoleMember(
7382 data: &[u8],
7383 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7384 <getRoleMemberCall as alloy_sol_types::SolCall>::abi_decode_raw(
7385 data,
7386 )
7387 .map(HoprNetworkRegistryCalls::getRoleMember)
7388 }
7389 getRoleMember
7390 },
7391 {
7392 fn hasRole(
7393 data: &[u8],
7394 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7395 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
7396 .map(HoprNetworkRegistryCalls::hasRole)
7397 }
7398 hasRole
7399 },
7400 {
7401 fn selfSync(
7402 data: &[u8],
7403 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7404 <selfSyncCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
7405 .map(HoprNetworkRegistryCalls::selfSync)
7406 }
7407 selfSync
7408 },
7409 {
7410 fn selfDeregister(
7411 data: &[u8],
7412 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7413 <selfDeregisterCall as alloy_sol_types::SolCall>::abi_decode_raw(
7414 data,
7415 )
7416 .map(HoprNetworkRegistryCalls::selfDeregister)
7417 }
7418 selfDeregister
7419 },
7420 {
7421 fn DEFAULT_ADMIN_ROLE(
7422 data: &[u8],
7423 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7424 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
7425 data,
7426 )
7427 .map(HoprNetworkRegistryCalls::DEFAULT_ADMIN_ROLE)
7428 }
7429 DEFAULT_ADMIN_ROLE
7430 },
7431 {
7432 fn isNodeRegisteredByAccount(
7433 data: &[u8],
7434 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7435 <isNodeRegisteredByAccountCall as alloy_sol_types::SolCall>::abi_decode_raw(
7436 data,
7437 )
7438 .map(HoprNetworkRegistryCalls::isNodeRegisteredByAccount)
7439 }
7440 isNodeRegisteredByAccount
7441 },
7442 {
7443 fn nodeRegisterdToAccount(
7444 data: &[u8],
7445 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7446 <nodeRegisterdToAccountCall as alloy_sol_types::SolCall>::abi_decode_raw(
7447 data,
7448 )
7449 .map(HoprNetworkRegistryCalls::nodeRegisterdToAccount)
7450 }
7451 nodeRegisterdToAccount
7452 },
7453 {
7454 fn getRoleMemberCount(
7455 data: &[u8],
7456 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7457 <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw(
7458 data,
7459 )
7460 .map(HoprNetworkRegistryCalls::getRoleMemberCount)
7461 }
7462 getRoleMemberCount
7463 },
7464 {
7465 fn managerForceSync(
7466 data: &[u8],
7467 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7468 <managerForceSyncCall as alloy_sol_types::SolCall>::abi_decode_raw(
7469 data,
7470 )
7471 .map(HoprNetworkRegistryCalls::managerForceSync)
7472 }
7473 managerForceSync
7474 },
7475 {
7476 fn disableRegistry(
7477 data: &[u8],
7478 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7479 <disableRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
7480 data,
7481 )
7482 .map(HoprNetworkRegistryCalls::disableRegistry)
7483 }
7484 disableRegistry
7485 },
7486 {
7487 fn enableRegistry(
7488 data: &[u8],
7489 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7490 <enableRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
7491 data,
7492 )
7493 .map(HoprNetworkRegistryCalls::enableRegistry)
7494 }
7495 enableRegistry
7496 },
7497 {
7498 fn revokeRole(
7499 data: &[u8],
7500 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7501 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
7502 data,
7503 )
7504 .map(HoprNetworkRegistryCalls::revokeRole)
7505 }
7506 revokeRole
7507 },
7508 {
7509 fn requirementImplementation(
7510 data: &[u8],
7511 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7512 <requirementImplementationCall as alloy_sol_types::SolCall>::abi_decode_raw(
7513 data,
7514 )
7515 .map(HoprNetworkRegistryCalls::requirementImplementation)
7516 }
7517 requirementImplementation
7518 },
7519 {
7520 fn MANAGER_ROLE(
7521 data: &[u8],
7522 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7523 <MANAGER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
7524 data,
7525 )
7526 .map(HoprNetworkRegistryCalls::MANAGER_ROLE)
7527 }
7528 MANAGER_ROLE
7529 },
7530 ];
7531 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
7532 return Err(
7533 alloy_sol_types::Error::unknown_selector(
7534 <Self as alloy_sol_types::SolInterface>::NAME,
7535 selector,
7536 ),
7537 );
7538 };
7539 DECODE_SHIMS[idx](data)
7540 }
7541 #[inline]
7542 #[allow(non_snake_case)]
7543 fn abi_decode_raw_validate(
7544 selector: [u8; 4],
7545 data: &[u8],
7546 ) -> alloy_sol_types::Result<Self> {
7547 static DECODE_VALIDATE_SHIMS: &[fn(
7548 &[u8],
7549 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls>] = &[
7550 {
7551 fn supportsInterface(
7552 data: &[u8],
7553 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7554 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7555 data,
7556 )
7557 .map(HoprNetworkRegistryCalls::supportsInterface)
7558 }
7559 supportsInterface
7560 },
7561 {
7562 fn enabled(
7563 data: &[u8],
7564 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7565 <enabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7566 data,
7567 )
7568 .map(HoprNetworkRegistryCalls::enabled)
7569 }
7570 enabled
7571 },
7572 {
7573 fn getRoleAdmin(
7574 data: &[u8],
7575 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7576 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7577 data,
7578 )
7579 .map(HoprNetworkRegistryCalls::getRoleAdmin)
7580 }
7581 getRoleAdmin
7582 },
7583 {
7584 fn updateRequirementImplementation(
7585 data: &[u8],
7586 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7587 <updateRequirementImplementationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7588 data,
7589 )
7590 .map(
7591 HoprNetworkRegistryCalls::updateRequirementImplementation,
7592 )
7593 }
7594 updateRequirementImplementation
7595 },
7596 {
7597 fn maxAdditionalRegistrations(
7598 data: &[u8],
7599 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7600 <maxAdditionalRegistrationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7601 data,
7602 )
7603 .map(HoprNetworkRegistryCalls::maxAdditionalRegistrations)
7604 }
7605 maxAdditionalRegistrations
7606 },
7607 {
7608 fn managerSync(
7609 data: &[u8],
7610 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7611 <managerSyncCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7612 data,
7613 )
7614 .map(HoprNetworkRegistryCalls::managerSync)
7615 }
7616 managerSync
7617 },
7618 {
7619 fn grantRole(
7620 data: &[u8],
7621 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7622 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7623 data,
7624 )
7625 .map(HoprNetworkRegistryCalls::grantRole)
7626 }
7627 grantRole
7628 },
7629 {
7630 fn renounceRole(
7631 data: &[u8],
7632 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7633 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7634 data,
7635 )
7636 .map(HoprNetworkRegistryCalls::renounceRole)
7637 }
7638 renounceRole
7639 },
7640 {
7641 fn countRegisterdNodesPerAccount(
7642 data: &[u8],
7643 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7644 <countRegisterdNodesPerAccountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7645 data,
7646 )
7647 .map(HoprNetworkRegistryCalls::countRegisterdNodesPerAccount)
7648 }
7649 countRegisterdNodesPerAccount
7650 },
7651 {
7652 fn managerDeregister(
7653 data: &[u8],
7654 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7655 <managerDeregisterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7656 data,
7657 )
7658 .map(HoprNetworkRegistryCalls::managerDeregister)
7659 }
7660 managerDeregister
7661 },
7662 {
7663 fn isNodeRegisteredAndEligible(
7664 data: &[u8],
7665 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7666 <isNodeRegisteredAndEligibleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7667 data,
7668 )
7669 .map(HoprNetworkRegistryCalls::isNodeRegisteredAndEligible)
7670 }
7671 isNodeRegisteredAndEligible
7672 },
7673 {
7674 fn isAccountEligible(
7675 data: &[u8],
7676 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7677 <isAccountEligibleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7678 data,
7679 )
7680 .map(HoprNetworkRegistryCalls::isAccountEligible)
7681 }
7682 isAccountEligible
7683 },
7684 {
7685 fn selfRegister(
7686 data: &[u8],
7687 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7688 <selfRegisterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7689 data,
7690 )
7691 .map(HoprNetworkRegistryCalls::selfRegister)
7692 }
7693 selfRegister
7694 },
7695 {
7696 fn managerRegister(
7697 data: &[u8],
7698 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7699 <managerRegisterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7700 data,
7701 )
7702 .map(HoprNetworkRegistryCalls::managerRegister)
7703 }
7704 managerRegister
7705 },
7706 {
7707 fn getRoleMember(
7708 data: &[u8],
7709 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7710 <getRoleMemberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7711 data,
7712 )
7713 .map(HoprNetworkRegistryCalls::getRoleMember)
7714 }
7715 getRoleMember
7716 },
7717 {
7718 fn hasRole(
7719 data: &[u8],
7720 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7721 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7722 data,
7723 )
7724 .map(HoprNetworkRegistryCalls::hasRole)
7725 }
7726 hasRole
7727 },
7728 {
7729 fn selfSync(
7730 data: &[u8],
7731 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7732 <selfSyncCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7733 data,
7734 )
7735 .map(HoprNetworkRegistryCalls::selfSync)
7736 }
7737 selfSync
7738 },
7739 {
7740 fn selfDeregister(
7741 data: &[u8],
7742 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7743 <selfDeregisterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7744 data,
7745 )
7746 .map(HoprNetworkRegistryCalls::selfDeregister)
7747 }
7748 selfDeregister
7749 },
7750 {
7751 fn DEFAULT_ADMIN_ROLE(
7752 data: &[u8],
7753 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7754 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7755 data,
7756 )
7757 .map(HoprNetworkRegistryCalls::DEFAULT_ADMIN_ROLE)
7758 }
7759 DEFAULT_ADMIN_ROLE
7760 },
7761 {
7762 fn isNodeRegisteredByAccount(
7763 data: &[u8],
7764 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7765 <isNodeRegisteredByAccountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7766 data,
7767 )
7768 .map(HoprNetworkRegistryCalls::isNodeRegisteredByAccount)
7769 }
7770 isNodeRegisteredByAccount
7771 },
7772 {
7773 fn nodeRegisterdToAccount(
7774 data: &[u8],
7775 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7776 <nodeRegisterdToAccountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7777 data,
7778 )
7779 .map(HoprNetworkRegistryCalls::nodeRegisterdToAccount)
7780 }
7781 nodeRegisterdToAccount
7782 },
7783 {
7784 fn getRoleMemberCount(
7785 data: &[u8],
7786 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7787 <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7788 data,
7789 )
7790 .map(HoprNetworkRegistryCalls::getRoleMemberCount)
7791 }
7792 getRoleMemberCount
7793 },
7794 {
7795 fn managerForceSync(
7796 data: &[u8],
7797 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7798 <managerForceSyncCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7799 data,
7800 )
7801 .map(HoprNetworkRegistryCalls::managerForceSync)
7802 }
7803 managerForceSync
7804 },
7805 {
7806 fn disableRegistry(
7807 data: &[u8],
7808 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7809 <disableRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7810 data,
7811 )
7812 .map(HoprNetworkRegistryCalls::disableRegistry)
7813 }
7814 disableRegistry
7815 },
7816 {
7817 fn enableRegistry(
7818 data: &[u8],
7819 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7820 <enableRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7821 data,
7822 )
7823 .map(HoprNetworkRegistryCalls::enableRegistry)
7824 }
7825 enableRegistry
7826 },
7827 {
7828 fn revokeRole(
7829 data: &[u8],
7830 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7831 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7832 data,
7833 )
7834 .map(HoprNetworkRegistryCalls::revokeRole)
7835 }
7836 revokeRole
7837 },
7838 {
7839 fn requirementImplementation(
7840 data: &[u8],
7841 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7842 <requirementImplementationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7843 data,
7844 )
7845 .map(HoprNetworkRegistryCalls::requirementImplementation)
7846 }
7847 requirementImplementation
7848 },
7849 {
7850 fn MANAGER_ROLE(
7851 data: &[u8],
7852 ) -> alloy_sol_types::Result<HoprNetworkRegistryCalls> {
7853 <MANAGER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
7854 data,
7855 )
7856 .map(HoprNetworkRegistryCalls::MANAGER_ROLE)
7857 }
7858 MANAGER_ROLE
7859 },
7860 ];
7861 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
7862 return Err(
7863 alloy_sol_types::Error::unknown_selector(
7864 <Self as alloy_sol_types::SolInterface>::NAME,
7865 selector,
7866 ),
7867 );
7868 };
7869 DECODE_VALIDATE_SHIMS[idx](data)
7870 }
7871 #[inline]
7872 fn abi_encoded_size(&self) -> usize {
7873 match self {
7874 Self::DEFAULT_ADMIN_ROLE(inner) => {
7875 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
7876 inner,
7877 )
7878 }
7879 Self::MANAGER_ROLE(inner) => {
7880 <MANAGER_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
7881 inner,
7882 )
7883 }
7884 Self::countRegisterdNodesPerAccount(inner) => {
7885 <countRegisterdNodesPerAccountCall as alloy_sol_types::SolCall>::abi_encoded_size(
7886 inner,
7887 )
7888 }
7889 Self::disableRegistry(inner) => {
7890 <disableRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
7891 inner,
7892 )
7893 }
7894 Self::enableRegistry(inner) => {
7895 <enableRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
7896 inner,
7897 )
7898 }
7899 Self::enabled(inner) => {
7900 <enabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7901 }
7902 Self::getRoleAdmin(inner) => {
7903 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
7904 inner,
7905 )
7906 }
7907 Self::getRoleMember(inner) => {
7908 <getRoleMemberCall as alloy_sol_types::SolCall>::abi_encoded_size(
7909 inner,
7910 )
7911 }
7912 Self::getRoleMemberCount(inner) => {
7913 <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
7914 inner,
7915 )
7916 }
7917 Self::grantRole(inner) => {
7918 <grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7919 }
7920 Self::hasRole(inner) => {
7921 <hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7922 }
7923 Self::isAccountEligible(inner) => {
7924 <isAccountEligibleCall as alloy_sol_types::SolCall>::abi_encoded_size(
7925 inner,
7926 )
7927 }
7928 Self::isNodeRegisteredAndEligible(inner) => {
7929 <isNodeRegisteredAndEligibleCall as alloy_sol_types::SolCall>::abi_encoded_size(
7930 inner,
7931 )
7932 }
7933 Self::isNodeRegisteredByAccount(inner) => {
7934 <isNodeRegisteredByAccountCall as alloy_sol_types::SolCall>::abi_encoded_size(
7935 inner,
7936 )
7937 }
7938 Self::managerDeregister(inner) => {
7939 <managerDeregisterCall as alloy_sol_types::SolCall>::abi_encoded_size(
7940 inner,
7941 )
7942 }
7943 Self::managerForceSync(inner) => {
7944 <managerForceSyncCall as alloy_sol_types::SolCall>::abi_encoded_size(
7945 inner,
7946 )
7947 }
7948 Self::managerRegister(inner) => {
7949 <managerRegisterCall as alloy_sol_types::SolCall>::abi_encoded_size(
7950 inner,
7951 )
7952 }
7953 Self::managerSync(inner) => {
7954 <managerSyncCall as alloy_sol_types::SolCall>::abi_encoded_size(
7955 inner,
7956 )
7957 }
7958 Self::maxAdditionalRegistrations(inner) => {
7959 <maxAdditionalRegistrationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
7960 inner,
7961 )
7962 }
7963 Self::nodeRegisterdToAccount(inner) => {
7964 <nodeRegisterdToAccountCall as alloy_sol_types::SolCall>::abi_encoded_size(
7965 inner,
7966 )
7967 }
7968 Self::renounceRole(inner) => {
7969 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(
7970 inner,
7971 )
7972 }
7973 Self::requirementImplementation(inner) => {
7974 <requirementImplementationCall as alloy_sol_types::SolCall>::abi_encoded_size(
7975 inner,
7976 )
7977 }
7978 Self::revokeRole(inner) => {
7979 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7980 }
7981 Self::selfDeregister(inner) => {
7982 <selfDeregisterCall as alloy_sol_types::SolCall>::abi_encoded_size(
7983 inner,
7984 )
7985 }
7986 Self::selfRegister(inner) => {
7987 <selfRegisterCall as alloy_sol_types::SolCall>::abi_encoded_size(
7988 inner,
7989 )
7990 }
7991 Self::selfSync(inner) => {
7992 <selfSyncCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7993 }
7994 Self::supportsInterface(inner) => {
7995 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
7996 inner,
7997 )
7998 }
7999 Self::updateRequirementImplementation(inner) => {
8000 <updateRequirementImplementationCall as alloy_sol_types::SolCall>::abi_encoded_size(
8001 inner,
8002 )
8003 }
8004 }
8005 }
8006 #[inline]
8007 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
8008 match self {
8009 Self::DEFAULT_ADMIN_ROLE(inner) => {
8010 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8011 inner,
8012 out,
8013 )
8014 }
8015 Self::MANAGER_ROLE(inner) => {
8016 <MANAGER_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8017 inner,
8018 out,
8019 )
8020 }
8021 Self::countRegisterdNodesPerAccount(inner) => {
8022 <countRegisterdNodesPerAccountCall as alloy_sol_types::SolCall>::abi_encode_raw(
8023 inner,
8024 out,
8025 )
8026 }
8027 Self::disableRegistry(inner) => {
8028 <disableRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
8029 inner,
8030 out,
8031 )
8032 }
8033 Self::enableRegistry(inner) => {
8034 <enableRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
8035 inner,
8036 out,
8037 )
8038 }
8039 Self::enabled(inner) => {
8040 <enabledCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8041 }
8042 Self::getRoleAdmin(inner) => {
8043 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
8044 inner,
8045 out,
8046 )
8047 }
8048 Self::getRoleMember(inner) => {
8049 <getRoleMemberCall as alloy_sol_types::SolCall>::abi_encode_raw(
8050 inner,
8051 out,
8052 )
8053 }
8054 Self::getRoleMemberCount(inner) => {
8055 <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
8056 inner,
8057 out,
8058 )
8059 }
8060 Self::grantRole(inner) => {
8061 <grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8062 inner,
8063 out,
8064 )
8065 }
8066 Self::hasRole(inner) => {
8067 <hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8068 }
8069 Self::isAccountEligible(inner) => {
8070 <isAccountEligibleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8071 inner,
8072 out,
8073 )
8074 }
8075 Self::isNodeRegisteredAndEligible(inner) => {
8076 <isNodeRegisteredAndEligibleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8077 inner,
8078 out,
8079 )
8080 }
8081 Self::isNodeRegisteredByAccount(inner) => {
8082 <isNodeRegisteredByAccountCall as alloy_sol_types::SolCall>::abi_encode_raw(
8083 inner,
8084 out,
8085 )
8086 }
8087 Self::managerDeregister(inner) => {
8088 <managerDeregisterCall as alloy_sol_types::SolCall>::abi_encode_raw(
8089 inner,
8090 out,
8091 )
8092 }
8093 Self::managerForceSync(inner) => {
8094 <managerForceSyncCall as alloy_sol_types::SolCall>::abi_encode_raw(
8095 inner,
8096 out,
8097 )
8098 }
8099 Self::managerRegister(inner) => {
8100 <managerRegisterCall as alloy_sol_types::SolCall>::abi_encode_raw(
8101 inner,
8102 out,
8103 )
8104 }
8105 Self::managerSync(inner) => {
8106 <managerSyncCall as alloy_sol_types::SolCall>::abi_encode_raw(
8107 inner,
8108 out,
8109 )
8110 }
8111 Self::maxAdditionalRegistrations(inner) => {
8112 <maxAdditionalRegistrationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
8113 inner,
8114 out,
8115 )
8116 }
8117 Self::nodeRegisterdToAccount(inner) => {
8118 <nodeRegisterdToAccountCall as alloy_sol_types::SolCall>::abi_encode_raw(
8119 inner,
8120 out,
8121 )
8122 }
8123 Self::renounceRole(inner) => {
8124 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8125 inner,
8126 out,
8127 )
8128 }
8129 Self::requirementImplementation(inner) => {
8130 <requirementImplementationCall as alloy_sol_types::SolCall>::abi_encode_raw(
8131 inner,
8132 out,
8133 )
8134 }
8135 Self::revokeRole(inner) => {
8136 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8137 inner,
8138 out,
8139 )
8140 }
8141 Self::selfDeregister(inner) => {
8142 <selfDeregisterCall as alloy_sol_types::SolCall>::abi_encode_raw(
8143 inner,
8144 out,
8145 )
8146 }
8147 Self::selfRegister(inner) => {
8148 <selfRegisterCall as alloy_sol_types::SolCall>::abi_encode_raw(
8149 inner,
8150 out,
8151 )
8152 }
8153 Self::selfSync(inner) => {
8154 <selfSyncCall as alloy_sol_types::SolCall>::abi_encode_raw(
8155 inner,
8156 out,
8157 )
8158 }
8159 Self::supportsInterface(inner) => {
8160 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
8161 inner,
8162 out,
8163 )
8164 }
8165 Self::updateRequirementImplementation(inner) => {
8166 <updateRequirementImplementationCall as alloy_sol_types::SolCall>::abi_encode_raw(
8167 inner,
8168 out,
8169 )
8170 }
8171 }
8172 }
8173 }
8174 #[derive(serde::Serialize, serde::Deserialize)]
8176 #[derive(Debug, PartialEq, Eq, Hash)]
8177 pub enum HoprNetworkRegistryErrors {
8178 #[allow(missing_docs)]
8179 ArrayLengthNotMatch(ArrayLengthNotMatch),
8180 #[allow(missing_docs)]
8181 CannotOperateForNode(CannotOperateForNode),
8182 #[allow(missing_docs)]
8183 GloballyDisabledRegistry(GloballyDisabledRegistry),
8184 #[allow(missing_docs)]
8185 GloballyEnabledRegistry(GloballyEnabledRegistry),
8186 #[allow(missing_docs)]
8187 NodeAlreadyRegisterd(NodeAlreadyRegisterd),
8188 #[allow(missing_docs)]
8189 NodeNotYetRegisterd(NodeNotYetRegisterd),
8190 #[allow(missing_docs)]
8191 NodeRegisterdToOtherAccount(NodeRegisterdToOtherAccount),
8192 #[allow(missing_docs)]
8193 NotEnoughAllowanceToRegisterNode(NotEnoughAllowanceToRegisterNode),
8194 }
8195 #[automatically_derived]
8196 impl HoprNetworkRegistryErrors {
8197 pub const SELECTORS: &'static [[u8; 4usize]] = &[
8204 [7u8, 65u8, 73u8, 103u8],
8205 [15u8, 185u8, 189u8, 92u8],
8206 [91u8, 83u8, 59u8, 161u8],
8207 [177u8, 195u8, 200u8, 168u8],
8208 [191u8, 79u8, 221u8, 115u8],
8209 [196u8, 38u8, 56u8, 187u8],
8210 [237u8, 26u8, 12u8, 119u8],
8211 [237u8, 136u8, 47u8, 113u8],
8212 ];
8213 }
8214 #[automatically_derived]
8215 impl alloy_sol_types::SolInterface for HoprNetworkRegistryErrors {
8216 const NAME: &'static str = "HoprNetworkRegistryErrors";
8217 const MIN_DATA_LENGTH: usize = 0usize;
8218 const COUNT: usize = 8usize;
8219 #[inline]
8220 fn selector(&self) -> [u8; 4] {
8221 match self {
8222 Self::ArrayLengthNotMatch(_) => {
8223 <ArrayLengthNotMatch as alloy_sol_types::SolError>::SELECTOR
8224 }
8225 Self::CannotOperateForNode(_) => {
8226 <CannotOperateForNode as alloy_sol_types::SolError>::SELECTOR
8227 }
8228 Self::GloballyDisabledRegistry(_) => {
8229 <GloballyDisabledRegistry as alloy_sol_types::SolError>::SELECTOR
8230 }
8231 Self::GloballyEnabledRegistry(_) => {
8232 <GloballyEnabledRegistry as alloy_sol_types::SolError>::SELECTOR
8233 }
8234 Self::NodeAlreadyRegisterd(_) => {
8235 <NodeAlreadyRegisterd as alloy_sol_types::SolError>::SELECTOR
8236 }
8237 Self::NodeNotYetRegisterd(_) => {
8238 <NodeNotYetRegisterd as alloy_sol_types::SolError>::SELECTOR
8239 }
8240 Self::NodeRegisterdToOtherAccount(_) => {
8241 <NodeRegisterdToOtherAccount as alloy_sol_types::SolError>::SELECTOR
8242 }
8243 Self::NotEnoughAllowanceToRegisterNode(_) => {
8244 <NotEnoughAllowanceToRegisterNode as alloy_sol_types::SolError>::SELECTOR
8245 }
8246 }
8247 }
8248 #[inline]
8249 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
8250 Self::SELECTORS.get(i).copied()
8251 }
8252 #[inline]
8253 fn valid_selector(selector: [u8; 4]) -> bool {
8254 Self::SELECTORS.binary_search(&selector).is_ok()
8255 }
8256 #[inline]
8257 #[allow(non_snake_case)]
8258 fn abi_decode_raw(
8259 selector: [u8; 4],
8260 data: &[u8],
8261 ) -> alloy_sol_types::Result<Self> {
8262 static DECODE_SHIMS: &[fn(
8263 &[u8],
8264 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors>] = &[
8265 {
8266 fn CannotOperateForNode(
8267 data: &[u8],
8268 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8269 <CannotOperateForNode as alloy_sol_types::SolError>::abi_decode_raw(
8270 data,
8271 )
8272 .map(HoprNetworkRegistryErrors::CannotOperateForNode)
8273 }
8274 CannotOperateForNode
8275 },
8276 {
8277 fn NotEnoughAllowanceToRegisterNode(
8278 data: &[u8],
8279 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8280 <NotEnoughAllowanceToRegisterNode as alloy_sol_types::SolError>::abi_decode_raw(
8281 data,
8282 )
8283 .map(
8284 HoprNetworkRegistryErrors::NotEnoughAllowanceToRegisterNode,
8285 )
8286 }
8287 NotEnoughAllowanceToRegisterNode
8288 },
8289 {
8290 fn NodeAlreadyRegisterd(
8291 data: &[u8],
8292 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8293 <NodeAlreadyRegisterd as alloy_sol_types::SolError>::abi_decode_raw(
8294 data,
8295 )
8296 .map(HoprNetworkRegistryErrors::NodeAlreadyRegisterd)
8297 }
8298 NodeAlreadyRegisterd
8299 },
8300 {
8301 fn NodeNotYetRegisterd(
8302 data: &[u8],
8303 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8304 <NodeNotYetRegisterd as alloy_sol_types::SolError>::abi_decode_raw(
8305 data,
8306 )
8307 .map(HoprNetworkRegistryErrors::NodeNotYetRegisterd)
8308 }
8309 NodeNotYetRegisterd
8310 },
8311 {
8312 fn NodeRegisterdToOtherAccount(
8313 data: &[u8],
8314 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8315 <NodeRegisterdToOtherAccount as alloy_sol_types::SolError>::abi_decode_raw(
8316 data,
8317 )
8318 .map(HoprNetworkRegistryErrors::NodeRegisterdToOtherAccount)
8319 }
8320 NodeRegisterdToOtherAccount
8321 },
8322 {
8323 fn GloballyDisabledRegistry(
8324 data: &[u8],
8325 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8326 <GloballyDisabledRegistry as alloy_sol_types::SolError>::abi_decode_raw(
8327 data,
8328 )
8329 .map(HoprNetworkRegistryErrors::GloballyDisabledRegistry)
8330 }
8331 GloballyDisabledRegistry
8332 },
8333 {
8334 fn GloballyEnabledRegistry(
8335 data: &[u8],
8336 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8337 <GloballyEnabledRegistry as alloy_sol_types::SolError>::abi_decode_raw(
8338 data,
8339 )
8340 .map(HoprNetworkRegistryErrors::GloballyEnabledRegistry)
8341 }
8342 GloballyEnabledRegistry
8343 },
8344 {
8345 fn ArrayLengthNotMatch(
8346 data: &[u8],
8347 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8348 <ArrayLengthNotMatch as alloy_sol_types::SolError>::abi_decode_raw(
8349 data,
8350 )
8351 .map(HoprNetworkRegistryErrors::ArrayLengthNotMatch)
8352 }
8353 ArrayLengthNotMatch
8354 },
8355 ];
8356 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
8357 return Err(
8358 alloy_sol_types::Error::unknown_selector(
8359 <Self as alloy_sol_types::SolInterface>::NAME,
8360 selector,
8361 ),
8362 );
8363 };
8364 DECODE_SHIMS[idx](data)
8365 }
8366 #[inline]
8367 #[allow(non_snake_case)]
8368 fn abi_decode_raw_validate(
8369 selector: [u8; 4],
8370 data: &[u8],
8371 ) -> alloy_sol_types::Result<Self> {
8372 static DECODE_VALIDATE_SHIMS: &[fn(
8373 &[u8],
8374 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors>] = &[
8375 {
8376 fn CannotOperateForNode(
8377 data: &[u8],
8378 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8379 <CannotOperateForNode as alloy_sol_types::SolError>::abi_decode_raw_validate(
8380 data,
8381 )
8382 .map(HoprNetworkRegistryErrors::CannotOperateForNode)
8383 }
8384 CannotOperateForNode
8385 },
8386 {
8387 fn NotEnoughAllowanceToRegisterNode(
8388 data: &[u8],
8389 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8390 <NotEnoughAllowanceToRegisterNode as alloy_sol_types::SolError>::abi_decode_raw_validate(
8391 data,
8392 )
8393 .map(
8394 HoprNetworkRegistryErrors::NotEnoughAllowanceToRegisterNode,
8395 )
8396 }
8397 NotEnoughAllowanceToRegisterNode
8398 },
8399 {
8400 fn NodeAlreadyRegisterd(
8401 data: &[u8],
8402 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8403 <NodeAlreadyRegisterd as alloy_sol_types::SolError>::abi_decode_raw_validate(
8404 data,
8405 )
8406 .map(HoprNetworkRegistryErrors::NodeAlreadyRegisterd)
8407 }
8408 NodeAlreadyRegisterd
8409 },
8410 {
8411 fn NodeNotYetRegisterd(
8412 data: &[u8],
8413 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8414 <NodeNotYetRegisterd as alloy_sol_types::SolError>::abi_decode_raw_validate(
8415 data,
8416 )
8417 .map(HoprNetworkRegistryErrors::NodeNotYetRegisterd)
8418 }
8419 NodeNotYetRegisterd
8420 },
8421 {
8422 fn NodeRegisterdToOtherAccount(
8423 data: &[u8],
8424 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8425 <NodeRegisterdToOtherAccount as alloy_sol_types::SolError>::abi_decode_raw_validate(
8426 data,
8427 )
8428 .map(HoprNetworkRegistryErrors::NodeRegisterdToOtherAccount)
8429 }
8430 NodeRegisterdToOtherAccount
8431 },
8432 {
8433 fn GloballyDisabledRegistry(
8434 data: &[u8],
8435 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8436 <GloballyDisabledRegistry as alloy_sol_types::SolError>::abi_decode_raw_validate(
8437 data,
8438 )
8439 .map(HoprNetworkRegistryErrors::GloballyDisabledRegistry)
8440 }
8441 GloballyDisabledRegistry
8442 },
8443 {
8444 fn GloballyEnabledRegistry(
8445 data: &[u8],
8446 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8447 <GloballyEnabledRegistry as alloy_sol_types::SolError>::abi_decode_raw_validate(
8448 data,
8449 )
8450 .map(HoprNetworkRegistryErrors::GloballyEnabledRegistry)
8451 }
8452 GloballyEnabledRegistry
8453 },
8454 {
8455 fn ArrayLengthNotMatch(
8456 data: &[u8],
8457 ) -> alloy_sol_types::Result<HoprNetworkRegistryErrors> {
8458 <ArrayLengthNotMatch as alloy_sol_types::SolError>::abi_decode_raw_validate(
8459 data,
8460 )
8461 .map(HoprNetworkRegistryErrors::ArrayLengthNotMatch)
8462 }
8463 ArrayLengthNotMatch
8464 },
8465 ];
8466 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
8467 return Err(
8468 alloy_sol_types::Error::unknown_selector(
8469 <Self as alloy_sol_types::SolInterface>::NAME,
8470 selector,
8471 ),
8472 );
8473 };
8474 DECODE_VALIDATE_SHIMS[idx](data)
8475 }
8476 #[inline]
8477 fn abi_encoded_size(&self) -> usize {
8478 match self {
8479 Self::ArrayLengthNotMatch(inner) => {
8480 <ArrayLengthNotMatch as alloy_sol_types::SolError>::abi_encoded_size(
8481 inner,
8482 )
8483 }
8484 Self::CannotOperateForNode(inner) => {
8485 <CannotOperateForNode as alloy_sol_types::SolError>::abi_encoded_size(
8486 inner,
8487 )
8488 }
8489 Self::GloballyDisabledRegistry(inner) => {
8490 <GloballyDisabledRegistry as alloy_sol_types::SolError>::abi_encoded_size(
8491 inner,
8492 )
8493 }
8494 Self::GloballyEnabledRegistry(inner) => {
8495 <GloballyEnabledRegistry as alloy_sol_types::SolError>::abi_encoded_size(
8496 inner,
8497 )
8498 }
8499 Self::NodeAlreadyRegisterd(inner) => {
8500 <NodeAlreadyRegisterd as alloy_sol_types::SolError>::abi_encoded_size(
8501 inner,
8502 )
8503 }
8504 Self::NodeNotYetRegisterd(inner) => {
8505 <NodeNotYetRegisterd as alloy_sol_types::SolError>::abi_encoded_size(
8506 inner,
8507 )
8508 }
8509 Self::NodeRegisterdToOtherAccount(inner) => {
8510 <NodeRegisterdToOtherAccount as alloy_sol_types::SolError>::abi_encoded_size(
8511 inner,
8512 )
8513 }
8514 Self::NotEnoughAllowanceToRegisterNode(inner) => {
8515 <NotEnoughAllowanceToRegisterNode as alloy_sol_types::SolError>::abi_encoded_size(
8516 inner,
8517 )
8518 }
8519 }
8520 }
8521 #[inline]
8522 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
8523 match self {
8524 Self::ArrayLengthNotMatch(inner) => {
8525 <ArrayLengthNotMatch as alloy_sol_types::SolError>::abi_encode_raw(
8526 inner,
8527 out,
8528 )
8529 }
8530 Self::CannotOperateForNode(inner) => {
8531 <CannotOperateForNode as alloy_sol_types::SolError>::abi_encode_raw(
8532 inner,
8533 out,
8534 )
8535 }
8536 Self::GloballyDisabledRegistry(inner) => {
8537 <GloballyDisabledRegistry as alloy_sol_types::SolError>::abi_encode_raw(
8538 inner,
8539 out,
8540 )
8541 }
8542 Self::GloballyEnabledRegistry(inner) => {
8543 <GloballyEnabledRegistry as alloy_sol_types::SolError>::abi_encode_raw(
8544 inner,
8545 out,
8546 )
8547 }
8548 Self::NodeAlreadyRegisterd(inner) => {
8549 <NodeAlreadyRegisterd as alloy_sol_types::SolError>::abi_encode_raw(
8550 inner,
8551 out,
8552 )
8553 }
8554 Self::NodeNotYetRegisterd(inner) => {
8555 <NodeNotYetRegisterd as alloy_sol_types::SolError>::abi_encode_raw(
8556 inner,
8557 out,
8558 )
8559 }
8560 Self::NodeRegisterdToOtherAccount(inner) => {
8561 <NodeRegisterdToOtherAccount as alloy_sol_types::SolError>::abi_encode_raw(
8562 inner,
8563 out,
8564 )
8565 }
8566 Self::NotEnoughAllowanceToRegisterNode(inner) => {
8567 <NotEnoughAllowanceToRegisterNode as alloy_sol_types::SolError>::abi_encode_raw(
8568 inner,
8569 out,
8570 )
8571 }
8572 }
8573 }
8574 }
8575 #[derive(serde::Serialize, serde::Deserialize)]
8577 #[derive(Debug, PartialEq, Eq, Hash)]
8578 pub enum HoprNetworkRegistryEvents {
8579 #[allow(missing_docs)]
8580 Deregistered(Deregistered),
8581 #[allow(missing_docs)]
8582 DeregisteredByManager(DeregisteredByManager),
8583 #[allow(missing_docs)]
8584 EligibilityUpdated(EligibilityUpdated),
8585 #[allow(missing_docs)]
8586 NetworkRegistryStatusUpdated(NetworkRegistryStatusUpdated),
8587 #[allow(missing_docs)]
8588 Registered(Registered),
8589 #[allow(missing_docs)]
8590 RegisteredByManager(RegisteredByManager),
8591 #[allow(missing_docs)]
8592 RequirementUpdated(RequirementUpdated),
8593 #[allow(missing_docs)]
8594 RoleAdminChanged(RoleAdminChanged),
8595 #[allow(missing_docs)]
8596 RoleGranted(RoleGranted),
8597 #[allow(missing_docs)]
8598 RoleRevoked(RoleRevoked),
8599 }
8600 #[automatically_derived]
8601 impl HoprNetworkRegistryEvents {
8602 pub const SELECTORS: &'static [[u8; 32usize]] = &[
8609 [
8610 4u8, 225u8, 234u8, 164u8, 218u8, 24u8, 247u8, 231u8, 66u8, 164u8, 237u8,
8611 187u8, 233u8, 237u8, 227u8, 108u8, 223u8, 117u8, 247u8, 147u8, 187u8,
8612 3u8, 171u8, 33u8, 88u8, 192u8, 135u8, 127u8, 28u8, 175u8, 43u8, 147u8,
8613 ],
8614 [
8615 10u8, 49u8, 238u8, 157u8, 70u8, 168u8, 40u8, 136u8, 75u8, 129u8, 0u8,
8616 60u8, 132u8, 152u8, 21u8, 110u8, 166u8, 170u8, 21u8, 185u8, 181u8, 75u8,
8617 221u8, 14u8, 240u8, 181u8, 51u8, 217u8, 235u8, 165u8, 126u8, 85u8,
8618 ],
8619 [
8620 21u8, 154u8, 138u8, 233u8, 72u8, 252u8, 198u8, 231u8, 248u8, 181u8, 73u8,
8621 92u8, 13u8, 115u8, 233u8, 21u8, 152u8, 68u8, 10u8, 248u8, 166u8, 40u8,
8622 23u8, 36u8, 108u8, 9u8, 237u8, 194u8, 194u8, 141u8, 186u8, 138u8,
8623 ],
8624 [
8625 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
8626 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
8627 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
8628 ],
8629 [
8630 138u8, 196u8, 178u8, 235u8, 119u8, 73u8, 247u8, 92u8, 91u8, 153u8, 184u8,
8631 152u8, 229u8, 71u8, 253u8, 97u8, 93u8, 215u8, 164u8, 36u8, 230u8, 131u8,
8632 86u8, 234u8, 25u8, 107u8, 125u8, 174u8, 116u8, 45u8, 108u8, 50u8,
8633 ],
8634 [
8635 139u8, 200u8, 95u8, 37u8, 227u8, 233u8, 51u8, 151u8, 143u8, 9u8, 148u8,
8636 8u8, 179u8, 187u8, 62u8, 183u8, 99u8, 11u8, 118u8, 247u8, 69u8, 95u8,
8637 46u8, 32u8, 91u8, 203u8, 192u8, 167u8, 128u8, 225u8, 126u8, 114u8,
8638 ],
8639 [
8640 145u8, 118u8, 10u8, 16u8, 1u8, 245u8, 49u8, 236u8, 43u8, 238u8, 134u8,
8641 2u8, 190u8, 85u8, 173u8, 43u8, 17u8, 89u8, 70u8, 94u8, 223u8, 245u8,
8642 187u8, 205u8, 65u8, 210u8, 7u8, 3u8, 116u8, 42u8, 77u8, 66u8,
8643 ],
8644 [
8645 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
8646 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
8647 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
8648 ],
8649 [
8650 226u8, 153u8, 79u8, 141u8, 111u8, 96u8, 10u8, 212u8, 115u8, 219u8, 168u8,
8651 44u8, 10u8, 137u8, 10u8, 183u8, 175u8, 250u8, 203u8, 134u8, 13u8, 51u8,
8652 101u8, 244u8, 116u8, 186u8, 163u8, 220u8, 4u8, 162u8, 229u8, 87u8,
8653 ],
8654 [
8655 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
8656 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
8657 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
8658 ],
8659 ];
8660 }
8661 #[automatically_derived]
8662 impl alloy_sol_types::SolEventInterface for HoprNetworkRegistryEvents {
8663 const NAME: &'static str = "HoprNetworkRegistryEvents";
8664 const COUNT: usize = 10usize;
8665 fn decode_raw_log(
8666 topics: &[alloy_sol_types::Word],
8667 data: &[u8],
8668 ) -> alloy_sol_types::Result<Self> {
8669 match topics.first().copied() {
8670 Some(<Deregistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8671 <Deregistered as alloy_sol_types::SolEvent>::decode_raw_log(
8672 topics,
8673 data,
8674 )
8675 .map(Self::Deregistered)
8676 }
8677 Some(
8678 <DeregisteredByManager as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
8679 ) => {
8680 <DeregisteredByManager as alloy_sol_types::SolEvent>::decode_raw_log(
8681 topics,
8682 data,
8683 )
8684 .map(Self::DeregisteredByManager)
8685 }
8686 Some(
8687 <EligibilityUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
8688 ) => {
8689 <EligibilityUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
8690 topics,
8691 data,
8692 )
8693 .map(Self::EligibilityUpdated)
8694 }
8695 Some(
8696 <NetworkRegistryStatusUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
8697 ) => {
8698 <NetworkRegistryStatusUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
8699 topics,
8700 data,
8701 )
8702 .map(Self::NetworkRegistryStatusUpdated)
8703 }
8704 Some(<Registered as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8705 <Registered as alloy_sol_types::SolEvent>::decode_raw_log(
8706 topics,
8707 data,
8708 )
8709 .map(Self::Registered)
8710 }
8711 Some(
8712 <RegisteredByManager as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
8713 ) => {
8714 <RegisteredByManager as alloy_sol_types::SolEvent>::decode_raw_log(
8715 topics,
8716 data,
8717 )
8718 .map(Self::RegisteredByManager)
8719 }
8720 Some(
8721 <RequirementUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
8722 ) => {
8723 <RequirementUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
8724 topics,
8725 data,
8726 )
8727 .map(Self::RequirementUpdated)
8728 }
8729 Some(<RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8730 <RoleAdminChanged as alloy_sol_types::SolEvent>::decode_raw_log(
8731 topics,
8732 data,
8733 )
8734 .map(Self::RoleAdminChanged)
8735 }
8736 Some(<RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8737 <RoleGranted as alloy_sol_types::SolEvent>::decode_raw_log(
8738 topics,
8739 data,
8740 )
8741 .map(Self::RoleGranted)
8742 }
8743 Some(<RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8744 <RoleRevoked as alloy_sol_types::SolEvent>::decode_raw_log(
8745 topics,
8746 data,
8747 )
8748 .map(Self::RoleRevoked)
8749 }
8750 _ => {
8751 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
8752 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
8753 log: alloy_sol_types::private::Box::new(
8754 alloy_sol_types::private::LogData::new_unchecked(
8755 topics.to_vec(),
8756 data.to_vec().into(),
8757 ),
8758 ),
8759 })
8760 }
8761 }
8762 }
8763 }
8764 #[automatically_derived]
8765 impl alloy_sol_types::private::IntoLogData for HoprNetworkRegistryEvents {
8766 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
8767 match self {
8768 Self::Deregistered(inner) => {
8769 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8770 }
8771 Self::DeregisteredByManager(inner) => {
8772 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8773 }
8774 Self::EligibilityUpdated(inner) => {
8775 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8776 }
8777 Self::NetworkRegistryStatusUpdated(inner) => {
8778 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8779 }
8780 Self::Registered(inner) => {
8781 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8782 }
8783 Self::RegisteredByManager(inner) => {
8784 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8785 }
8786 Self::RequirementUpdated(inner) => {
8787 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8788 }
8789 Self::RoleAdminChanged(inner) => {
8790 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8791 }
8792 Self::RoleGranted(inner) => {
8793 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8794 }
8795 Self::RoleRevoked(inner) => {
8796 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8797 }
8798 }
8799 }
8800 fn into_log_data(self) -> alloy_sol_types::private::LogData {
8801 match self {
8802 Self::Deregistered(inner) => {
8803 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8804 }
8805 Self::DeregisteredByManager(inner) => {
8806 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8807 }
8808 Self::EligibilityUpdated(inner) => {
8809 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8810 }
8811 Self::NetworkRegistryStatusUpdated(inner) => {
8812 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8813 }
8814 Self::Registered(inner) => {
8815 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8816 }
8817 Self::RegisteredByManager(inner) => {
8818 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8819 }
8820 Self::RequirementUpdated(inner) => {
8821 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8822 }
8823 Self::RoleAdminChanged(inner) => {
8824 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8825 }
8826 Self::RoleGranted(inner) => {
8827 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8828 }
8829 Self::RoleRevoked(inner) => {
8830 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8831 }
8832 }
8833 }
8834 }
8835 use alloy::contract as alloy_contract;
8836 #[inline]
8840 pub const fn new<
8841 P: alloy_contract::private::Provider<N>,
8842 N: alloy_contract::private::Network,
8843 >(
8844 address: alloy_sol_types::private::Address,
8845 provider: P,
8846 ) -> HoprNetworkRegistryInstance<P, N> {
8847 HoprNetworkRegistryInstance::<P, N>::new(address, provider)
8848 }
8849 #[inline]
8855 pub fn deploy<
8856 P: alloy_contract::private::Provider<N>,
8857 N: alloy_contract::private::Network,
8858 >(
8859 provider: P,
8860 _requirementImplementation: alloy::sol_types::private::Address,
8861 _newOwner: alloy::sol_types::private::Address,
8862 _manager: alloy::sol_types::private::Address,
8863 ) -> impl ::core::future::Future<
8864 Output = alloy_contract::Result<HoprNetworkRegistryInstance<P, N>>,
8865 > {
8866 HoprNetworkRegistryInstance::<
8867 P,
8868 N,
8869 >::deploy(provider, _requirementImplementation, _newOwner, _manager)
8870 }
8871 #[inline]
8877 pub fn deploy_builder<
8878 P: alloy_contract::private::Provider<N>,
8879 N: alloy_contract::private::Network,
8880 >(
8881 provider: P,
8882 _requirementImplementation: alloy::sol_types::private::Address,
8883 _newOwner: alloy::sol_types::private::Address,
8884 _manager: alloy::sol_types::private::Address,
8885 ) -> alloy_contract::RawCallBuilder<P, N> {
8886 HoprNetworkRegistryInstance::<
8887 P,
8888 N,
8889 >::deploy_builder(provider, _requirementImplementation, _newOwner, _manager)
8890 }
8891 #[derive(Clone)]
8903 pub struct HoprNetworkRegistryInstance<P, N = alloy_contract::private::Ethereum> {
8904 address: alloy_sol_types::private::Address,
8905 provider: P,
8906 _network: ::core::marker::PhantomData<N>,
8907 }
8908 #[automatically_derived]
8909 impl<P, N> ::core::fmt::Debug for HoprNetworkRegistryInstance<P, N> {
8910 #[inline]
8911 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8912 f.debug_tuple("HoprNetworkRegistryInstance").field(&self.address).finish()
8913 }
8914 }
8915 #[automatically_derived]
8917 impl<
8918 P: alloy_contract::private::Provider<N>,
8919 N: alloy_contract::private::Network,
8920 > HoprNetworkRegistryInstance<P, N> {
8921 #[inline]
8925 pub const fn new(
8926 address: alloy_sol_types::private::Address,
8927 provider: P,
8928 ) -> Self {
8929 Self {
8930 address,
8931 provider,
8932 _network: ::core::marker::PhantomData,
8933 }
8934 }
8935 #[inline]
8941 pub async fn deploy(
8942 provider: P,
8943 _requirementImplementation: alloy::sol_types::private::Address,
8944 _newOwner: alloy::sol_types::private::Address,
8945 _manager: alloy::sol_types::private::Address,
8946 ) -> alloy_contract::Result<HoprNetworkRegistryInstance<P, N>> {
8947 let call_builder = Self::deploy_builder(
8948 provider,
8949 _requirementImplementation,
8950 _newOwner,
8951 _manager,
8952 );
8953 let contract_address = call_builder.deploy().await?;
8954 Ok(Self::new(contract_address, call_builder.provider))
8955 }
8956 #[inline]
8962 pub fn deploy_builder(
8963 provider: P,
8964 _requirementImplementation: alloy::sol_types::private::Address,
8965 _newOwner: alloy::sol_types::private::Address,
8966 _manager: alloy::sol_types::private::Address,
8967 ) -> alloy_contract::RawCallBuilder<P, N> {
8968 alloy_contract::RawCallBuilder::new_raw_deploy(
8969 provider,
8970 [
8971 &BYTECODE[..],
8972 &alloy_sol_types::SolConstructor::abi_encode(
8973 &constructorCall {
8974 _requirementImplementation,
8975 _newOwner,
8976 _manager,
8977 },
8978 )[..],
8979 ]
8980 .concat()
8981 .into(),
8982 )
8983 }
8984 #[inline]
8986 pub const fn address(&self) -> &alloy_sol_types::private::Address {
8987 &self.address
8988 }
8989 #[inline]
8991 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
8992 self.address = address;
8993 }
8994 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
8996 self.set_address(address);
8997 self
8998 }
8999 #[inline]
9001 pub const fn provider(&self) -> &P {
9002 &self.provider
9003 }
9004 }
9005 impl<P: ::core::clone::Clone, N> HoprNetworkRegistryInstance<&P, N> {
9006 #[inline]
9008 pub fn with_cloned_provider(self) -> HoprNetworkRegistryInstance<P, N> {
9009 HoprNetworkRegistryInstance {
9010 address: self.address,
9011 provider: ::core::clone::Clone::clone(&self.provider),
9012 _network: ::core::marker::PhantomData,
9013 }
9014 }
9015 }
9016 #[automatically_derived]
9018 impl<
9019 P: alloy_contract::private::Provider<N>,
9020 N: alloy_contract::private::Network,
9021 > HoprNetworkRegistryInstance<P, N> {
9022 pub fn call_builder<C: alloy_sol_types::SolCall>(
9027 &self,
9028 call: &C,
9029 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
9030 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
9031 }
9032 pub fn DEFAULT_ADMIN_ROLE(
9034 &self,
9035 ) -> alloy_contract::SolCallBuilder<&P, DEFAULT_ADMIN_ROLECall, N> {
9036 self.call_builder(&DEFAULT_ADMIN_ROLECall)
9037 }
9038 pub fn MANAGER_ROLE(
9040 &self,
9041 ) -> alloy_contract::SolCallBuilder<&P, MANAGER_ROLECall, N> {
9042 self.call_builder(&MANAGER_ROLECall)
9043 }
9044 pub fn countRegisterdNodesPerAccount(
9046 &self,
9047 _0: alloy::sol_types::private::Address,
9048 ) -> alloy_contract::SolCallBuilder<&P, countRegisterdNodesPerAccountCall, N> {
9049 self.call_builder(&countRegisterdNodesPerAccountCall(_0))
9050 }
9051 pub fn disableRegistry(
9053 &self,
9054 ) -> alloy_contract::SolCallBuilder<&P, disableRegistryCall, N> {
9055 self.call_builder(&disableRegistryCall)
9056 }
9057 pub fn enableRegistry(
9059 &self,
9060 ) -> alloy_contract::SolCallBuilder<&P, enableRegistryCall, N> {
9061 self.call_builder(&enableRegistryCall)
9062 }
9063 pub fn enabled(&self) -> alloy_contract::SolCallBuilder<&P, enabledCall, N> {
9065 self.call_builder(&enabledCall)
9066 }
9067 pub fn getRoleAdmin(
9069 &self,
9070 role: alloy::sol_types::private::FixedBytes<32>,
9071 ) -> alloy_contract::SolCallBuilder<&P, getRoleAdminCall, N> {
9072 self.call_builder(&getRoleAdminCall { role })
9073 }
9074 pub fn getRoleMember(
9076 &self,
9077 role: alloy::sol_types::private::FixedBytes<32>,
9078 index: alloy::sol_types::private::primitives::aliases::U256,
9079 ) -> alloy_contract::SolCallBuilder<&P, getRoleMemberCall, N> {
9080 self.call_builder(&getRoleMemberCall { role, index })
9081 }
9082 pub fn getRoleMemberCount(
9084 &self,
9085 role: alloy::sol_types::private::FixedBytes<32>,
9086 ) -> alloy_contract::SolCallBuilder<&P, getRoleMemberCountCall, N> {
9087 self.call_builder(&getRoleMemberCountCall { role })
9088 }
9089 pub fn grantRole(
9091 &self,
9092 role: alloy::sol_types::private::FixedBytes<32>,
9093 account: alloy::sol_types::private::Address,
9094 ) -> alloy_contract::SolCallBuilder<&P, grantRoleCall, N> {
9095 self.call_builder(&grantRoleCall { role, account })
9096 }
9097 pub fn hasRole(
9099 &self,
9100 role: alloy::sol_types::private::FixedBytes<32>,
9101 account: alloy::sol_types::private::Address,
9102 ) -> alloy_contract::SolCallBuilder<&P, hasRoleCall, N> {
9103 self.call_builder(&hasRoleCall { role, account })
9104 }
9105 pub fn isAccountEligible(
9107 &self,
9108 stakingAccount: alloy::sol_types::private::Address,
9109 ) -> alloy_contract::SolCallBuilder<&P, isAccountEligibleCall, N> {
9110 self.call_builder(
9111 &isAccountEligibleCall {
9112 stakingAccount,
9113 },
9114 )
9115 }
9116 pub fn isNodeRegisteredAndEligible(
9118 &self,
9119 nodeAddress: alloy::sol_types::private::Address,
9120 ) -> alloy_contract::SolCallBuilder<&P, isNodeRegisteredAndEligibleCall, N> {
9121 self.call_builder(
9122 &isNodeRegisteredAndEligibleCall {
9123 nodeAddress,
9124 },
9125 )
9126 }
9127 pub fn isNodeRegisteredByAccount(
9129 &self,
9130 nodeAddress: alloy::sol_types::private::Address,
9131 account: alloy::sol_types::private::Address,
9132 ) -> alloy_contract::SolCallBuilder<&P, isNodeRegisteredByAccountCall, N> {
9133 self.call_builder(
9134 &isNodeRegisteredByAccountCall {
9135 nodeAddress,
9136 account,
9137 },
9138 )
9139 }
9140 pub fn managerDeregister(
9142 &self,
9143 nodeAddresses: alloy::sol_types::private::Vec<
9144 alloy::sol_types::private::Address,
9145 >,
9146 ) -> alloy_contract::SolCallBuilder<&P, managerDeregisterCall, N> {
9147 self.call_builder(
9148 &managerDeregisterCall {
9149 nodeAddresses,
9150 },
9151 )
9152 }
9153 pub fn managerForceSync(
9155 &self,
9156 stakingAccounts: alloy::sol_types::private::Vec<
9157 alloy::sol_types::private::Address,
9158 >,
9159 eligibilities: alloy::sol_types::private::Vec<bool>,
9160 ) -> alloy_contract::SolCallBuilder<&P, managerForceSyncCall, N> {
9161 self.call_builder(
9162 &managerForceSyncCall {
9163 stakingAccounts,
9164 eligibilities,
9165 },
9166 )
9167 }
9168 pub fn managerRegister(
9170 &self,
9171 stakingAccounts: alloy::sol_types::private::Vec<
9172 alloy::sol_types::private::Address,
9173 >,
9174 nodeAddresses: alloy::sol_types::private::Vec<
9175 alloy::sol_types::private::Address,
9176 >,
9177 ) -> alloy_contract::SolCallBuilder<&P, managerRegisterCall, N> {
9178 self.call_builder(
9179 &managerRegisterCall {
9180 stakingAccounts,
9181 nodeAddresses,
9182 },
9183 )
9184 }
9185 pub fn managerSync(
9187 &self,
9188 stakingAccounts: alloy::sol_types::private::Vec<
9189 alloy::sol_types::private::Address,
9190 >,
9191 ) -> alloy_contract::SolCallBuilder<&P, managerSyncCall, N> {
9192 self.call_builder(&managerSyncCall { stakingAccounts })
9193 }
9194 pub fn maxAdditionalRegistrations(
9196 &self,
9197 stakingAccount: alloy::sol_types::private::Address,
9198 ) -> alloy_contract::SolCallBuilder<&P, maxAdditionalRegistrationsCall, N> {
9199 self.call_builder(
9200 &maxAdditionalRegistrationsCall {
9201 stakingAccount,
9202 },
9203 )
9204 }
9205 pub fn nodeRegisterdToAccount(
9207 &self,
9208 _0: alloy::sol_types::private::Address,
9209 ) -> alloy_contract::SolCallBuilder<&P, nodeRegisterdToAccountCall, N> {
9210 self.call_builder(&nodeRegisterdToAccountCall(_0))
9211 }
9212 pub fn renounceRole(
9214 &self,
9215 role: alloy::sol_types::private::FixedBytes<32>,
9216 account: alloy::sol_types::private::Address,
9217 ) -> alloy_contract::SolCallBuilder<&P, renounceRoleCall, N> {
9218 self.call_builder(&renounceRoleCall { role, account })
9219 }
9220 pub fn requirementImplementation(
9222 &self,
9223 ) -> alloy_contract::SolCallBuilder<&P, requirementImplementationCall, N> {
9224 self.call_builder(&requirementImplementationCall)
9225 }
9226 pub fn revokeRole(
9228 &self,
9229 role: alloy::sol_types::private::FixedBytes<32>,
9230 account: alloy::sol_types::private::Address,
9231 ) -> alloy_contract::SolCallBuilder<&P, revokeRoleCall, N> {
9232 self.call_builder(&revokeRoleCall { role, account })
9233 }
9234 pub fn selfDeregister(
9236 &self,
9237 nodeAddresses: alloy::sol_types::private::Vec<
9238 alloy::sol_types::private::Address,
9239 >,
9240 ) -> alloy_contract::SolCallBuilder<&P, selfDeregisterCall, N> {
9241 self.call_builder(
9242 &selfDeregisterCall {
9243 nodeAddresses,
9244 },
9245 )
9246 }
9247 pub fn selfRegister(
9249 &self,
9250 nodeAddresses: alloy::sol_types::private::Vec<
9251 alloy::sol_types::private::Address,
9252 >,
9253 ) -> alloy_contract::SolCallBuilder<&P, selfRegisterCall, N> {
9254 self.call_builder(&selfRegisterCall { nodeAddresses })
9255 }
9256 pub fn selfSync(&self) -> alloy_contract::SolCallBuilder<&P, selfSyncCall, N> {
9258 self.call_builder(&selfSyncCall)
9259 }
9260 pub fn supportsInterface(
9262 &self,
9263 interfaceId: alloy::sol_types::private::FixedBytes<4>,
9264 ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
9265 self.call_builder(
9266 &supportsInterfaceCall {
9267 interfaceId,
9268 },
9269 )
9270 }
9271 pub fn updateRequirementImplementation(
9273 &self,
9274 _requirementImplementation: alloy::sol_types::private::Address,
9275 ) -> alloy_contract::SolCallBuilder<&P, updateRequirementImplementationCall, N> {
9276 self.call_builder(
9277 &updateRequirementImplementationCall {
9278 _requirementImplementation,
9279 },
9280 )
9281 }
9282 }
9283 #[automatically_derived]
9285 impl<
9286 P: alloy_contract::private::Provider<N>,
9287 N: alloy_contract::private::Network,
9288 > HoprNetworkRegistryInstance<P, N> {
9289 pub fn event_filter<E: alloy_sol_types::SolEvent>(
9294 &self,
9295 ) -> alloy_contract::Event<&P, E, N> {
9296 alloy_contract::Event::new_sol(&self.provider, &self.address)
9297 }
9298 pub fn Deregistered_filter(&self) -> alloy_contract::Event<&P, Deregistered, N> {
9300 self.event_filter::<Deregistered>()
9301 }
9302 pub fn DeregisteredByManager_filter(
9304 &self,
9305 ) -> alloy_contract::Event<&P, DeregisteredByManager, N> {
9306 self.event_filter::<DeregisteredByManager>()
9307 }
9308 pub fn EligibilityUpdated_filter(
9310 &self,
9311 ) -> alloy_contract::Event<&P, EligibilityUpdated, N> {
9312 self.event_filter::<EligibilityUpdated>()
9313 }
9314 pub fn NetworkRegistryStatusUpdated_filter(
9316 &self,
9317 ) -> alloy_contract::Event<&P, NetworkRegistryStatusUpdated, N> {
9318 self.event_filter::<NetworkRegistryStatusUpdated>()
9319 }
9320 pub fn Registered_filter(&self) -> alloy_contract::Event<&P, Registered, N> {
9322 self.event_filter::<Registered>()
9323 }
9324 pub fn RegisteredByManager_filter(
9326 &self,
9327 ) -> alloy_contract::Event<&P, RegisteredByManager, N> {
9328 self.event_filter::<RegisteredByManager>()
9329 }
9330 pub fn RequirementUpdated_filter(
9332 &self,
9333 ) -> alloy_contract::Event<&P, RequirementUpdated, N> {
9334 self.event_filter::<RequirementUpdated>()
9335 }
9336 pub fn RoleAdminChanged_filter(
9338 &self,
9339 ) -> alloy_contract::Event<&P, RoleAdminChanged, N> {
9340 self.event_filter::<RoleAdminChanged>()
9341 }
9342 pub fn RoleGranted_filter(&self) -> alloy_contract::Event<&P, RoleGranted, N> {
9344 self.event_filter::<RoleGranted>()
9345 }
9346 pub fn RoleRevoked_filter(&self) -> alloy_contract::Event<&P, RoleRevoked, N> {
9348 self.event_filter::<RoleRevoked>()
9349 }
9350 }
9351}