1#[allow(
511 non_camel_case_types,
512 non_snake_case,
513 clippy::pub_underscore_fields,
514 clippy::style,
515 clippy::empty_structs_with_brackets
516)]
517pub mod HoprSafeProxyForNetworkRegistry {
518 use super::*;
519 use alloy::sol_types as alloy_sol_types;
520 #[rustfmt::skip]
526 #[allow(clippy::all)]
527 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
528 b"`\x80`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0\x12\x818\x03\x80b\0\x12\x81\x839\x81\x01`@\x81\x90Rb\0\x004\x91b\0\x02\xDAV[b\0\0A`\0\x87b\0\0\xF3V[b\0\0\\`\0\x80Q` b\0\x12a\x839\x81Q\x91R\x87b\0\0\xF3V[b\0\0w`\0\x80Q` b\0\x12a\x839\x81Q\x91R\x86b\0\0\xF3V[b\0\0\x82\x84b\0\x01\x03V[b\0\0\x8D\x83b\0\x016V[`\x02\x80T`\x01`\x01`\xA0\x1B\x03\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x85\x81\x16\x91\x82\x17\x90\x93U`\x03\x80T\x90\x92\x16\x92\x84\x16\x92\x83\x17\x90\x91U`@Q\x7Fw\xB9\xCBO\x87\xFE\xAB\x1E\xBD\x81K\xB6\x94\xB7\xD5\x14\xEE-\xC1\xF0\xAB\xD4\xC3\x95\x7FF\x82\x9C.$\x9D\xFF\x90`\0\x90\xA3PPPPPPb\0\x03`V[b\0\0\xFF\x82\x82b\0\x01\x80V[PPV[`\x04\x81\x90U`@Q\x81\x90\x7F\xAD\xFA\x8E\xCB!\xB6\x96.\xBC\xD0\xAD\xBD\x9A\xB9\x85\xB7\xB4\xC5\xB5\xEB;\r\xEA\xD6\x83\x17\x15e\xC7\xBF\xE1q\x90`\0\x90\xA2PV[`\x05\x80T`\x01`\x01`\x80\x1B\x03\x19\x16`\x01`\x01`\x80\x1B\x03\x83\x16\x90\x81\x17\x90\x91U`@Q\x7F\xAF\x1D\x15\x99\xB5\xC7\xDA\x9A \x04\xB5z\xC1G\x84\x19\x97\x18\xA9\x03d\xAEG\xF2z\xC8\x94\x92o\x06U\xFC\x90`\0\x90\xA2PV[b\0\x01\x8C\x82\x82b\0\x01\xABV[`\0\x82\x81R`\x01` R`@\x90 b\0\x01\xA6\x90\x82b\0\x02KV[PPPV[`\0\x82\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x90 T`\xFF\x16b\0\0\xFFW`\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\x02\x073\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\x02b\x83`\x01`\x01`\xA0\x1B\x03\x84\x16b\0\x02kV[\x90P[\x92\x91PPV[`\0\x81\x81R`\x01\x83\x01` R`@\x81 Tb\0\x02\xB4WP\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\x02eV[P`\0b\0\x02eV[\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x02\xD5W`\0\x80\xFD[\x91\x90PV[`\0\x80`\0\x80`\0\x80`\xC0\x87\x89\x03\x12\x15b\0\x02\xF4W`\0\x80\xFD[b\0\x02\xFF\x87b\0\x02\xBDV[\x95Pb\0\x03\x0F` \x88\x01b\0\x02\xBDV[`@\x88\x01Q``\x89\x01Q\x91\x96P\x94P`\x01`\x01`\x80\x1B\x03\x81\x16\x81\x14b\0\x034W`\0\x80\xFD[\x92Pb\0\x03D`\x80\x88\x01b\0\x02\xBDV[\x91Pb\0\x03T`\xA0\x88\x01b\0\x02\xBDV[\x90P\x92\x95P\x92\x95P\x92\x95V[a\x0E\xF1\x80b\0\x03p`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x01\x16W`\x005`\xE0\x1C\x80c\xA2\x17\xFD\xDF\x11a\0\xA2W\x80c\xD8Z\xD0D\x11a\0qW\x80c\xD8Z\xD0D\x14a\x02TW\x80c\xEC\x87b\x1C\x14a\x02gW\x80c\xF1\x1Fw\xF9\x14a\x02\x8EW\x80c\xF2^q\x08\x14a\x02\x97W\x80c\xFC\x0CTj\x14a\x02\xC2W`\0\x80\xFD[\x80c\xA2\x17\xFD\xDF\x14a\x02\x13W\x80c\xB3TN\x82\x14a\x02\x1BW\x80c\xCA\x15\xC8s\x14a\x02.W\x80c\xD5Gt\x1F\x14a\x02AW`\0\x80\xFD[\x80cZ\xBES\x08\x11a\0\xE9W\x80cZ\xBES\x08\x14a\x01\x9CW\x80c^\xF53)\x14a\x01\xAFW\x80cjJ@A\x14a\x01\xC2W\x80c\x90\x10\xD0|\x14a\x01\xEDW\x80c\x91\xD1HT\x14a\x02\0W`\0\x80\xFD[\x80c\x01\xFF\xC9\xA7\x14a\x01\x1BW\x80c$\x8A\x9C\xA3\x14a\x01CW\x80c//\xF1]\x14a\x01tW\x80c6V\x8A\xBE\x14a\x01\x89W[`\0\x80\xFD[a\x01.a\x01)6`\x04a\x0B\xCDV[a\x02\xD5V[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01fa\x01Q6`\x04a\x0B\xF7V[`\0\x90\x81R` \x81\x90R`@\x90 `\x01\x01T\x90V[`@Q\x90\x81R` \x01a\x01:V[a\x01\x87a\x01\x826`\x04a\x0C%V[a\x03\0V[\0[a\x01\x87a\x01\x976`\x04a\x0C%V[a\x03*V[a\x01\x87a\x01\xAA6`\x04a\x0CUV[a\x03\xADV[a\x01\x87a\x01\xBD6`\x04a\x0B\xF7V[a\x04\x0EV[`\x03Ta\x01\xD5\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01:V[a\x01\xD5a\x01\xFB6`\x04a\x0C~V[a\x04cV[a\x01.a\x02\x0E6`\x04a\x0C%V[a\x04\x82V[a\x01f`\0\x81V[a\x01fa\x02)6`\x04a\x0C\xA0V[a\x04\xABV[a\x01fa\x02<6`\x04a\x0B\xF7V[a\x05?V[a\x01\x87a\x02O6`\x04a\x0C%V[a\x05VV[a\x01.a\x02b6`\x04a\x0C\xBDV[a\x05{V[a\x01f\x7F$\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\x81V[a\x01f`\x04T\x81V[`\x05Ta\x02\xAA\x90`\x01`\x01`\x80\x1B\x03\x16\x81V[`@Q`\x01`\x01`\x80\x1B\x03\x90\x91\x16\x81R` \x01a\x01:V[`\x02Ta\x01\xD5\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16c5\x87Oc`\xE1\x1B\x14\x80a\x02\xFAWPa\x02\xFA\x82a\x06\0V[\x92\x91PPV[`\0\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x03\x1B\x81a\x06%V[a\x03%\x83\x83a\x062V[PPPV[`\x01`\x01`\xA0\x1B\x03\x81\x163\x14a\x03\x9FW`@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\x03\xA9\x82\x82a\x06TV[PPV[\x7F$\x1E\xCF\x16\xD7\x9D\x0F\x8D\xBF\xB9,\xBC\x07\xFE\x17\x84\x04%\x97l\xF0f\x7F\x02/\xE9\x87|\xAA\x83\x1B\x08a\x03\xD7\x81a\x06%V[`\x05T`\x01`\x01`\x80\x1B\x03\x80\x84\x16\x91\x16\x03a\x04\x05W`@Qc\xC2?l\xCB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xA9\x82a\x06vV[\x7F$\x1E\xCF\x16\xD7\x9D\x0F\x8D\xBF\xB9,\xBC\x07\xFE\x17\x84\x04%\x97l\xF0f\x7F\x02/\xE9\x87|\xAA\x83\x1B\x08a\x048\x81a\x06%V[\x81`\x04T\x03a\x04ZW`@Qc\xC2?l\xCB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xA9\x82a\x06\xC9V[`\0\x82\x81R`\x01` R`@\x81 a\x04{\x90\x83a\x06\xFCV[\x93\x92PPPV[`\0\x91\x82R` \x82\x81R`@\x80\x84 `\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16\x84R\x91\x90R\x90 T`\xFF\x16\x90V[`\x04\x80T`\x02T`\x05T`@Qc{\xB9PI`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16\x95\x82\x01\x95\x90\x95R`\x01`\x01`\x80\x1B\x03\x90\x91\x16`$\x82\x01R`\0\x93\x90\x91\x16\x90c\xF7r\xA0\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x11W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x055\x91\x90a\x0C\xEBV[a\x02\xFA\x91\x90a\r\x1AV[`\0\x81\x81R`\x01` R`@\x81 a\x02\xFA\x90a\x07\x08V[`\0\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x05q\x81a\x06%V[a\x03%\x83\x83a\x06TV[`\x03T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R`\0\x92\x85\x82\x16\x92\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xCBW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xEF\x91\x90a\r<V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x93\x92PPPV[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cZ\x05\x18\x0F`\xE0\x1B\x14\x80a\x02\xFAWPa\x02\xFA\x82a\x07\x12V[a\x06/\x813a\x07GV[PV[a\x06<\x82\x82a\x07\xA0V[`\0\x82\x81R`\x01` R`@\x90 a\x03%\x90\x82a\x08$V[a\x06^\x82\x82a\x089V[`\0\x82\x81R`\x01` R`@\x90 a\x03%\x90\x82a\x08\x9EV[`\x05\x80To\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01`\x01`\x80\x1B\x03\x83\x16\x90\x81\x17\x90\x91U`@Q\x7F\xAF\x1D\x15\x99\xB5\xC7\xDA\x9A \x04\xB5z\xC1G\x84\x19\x97\x18\xA9\x03d\xAEG\xF2z\xC8\x94\x92o\x06U\xFC\x90`\0\x90\xA2PV[`\x04\x81\x90U`@Q\x81\x90\x7F\xAD\xFA\x8E\xCB!\xB6\x96.\xBC\xD0\xAD\xBD\x9A\xB9\x85\xB7\xB4\xC5\xB5\xEB;\r\xEA\xD6\x83\x17\x15e\xC7\xBF\xE1q\x90`\0\x90\xA2PV[`\0a\x04{\x83\x83a\x08\xB3V[`\0a\x02\xFA\x82T\x90V[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cye\xDB\x0B`\xE0\x1B\x14\x80a\x02\xFAWPc\x01\xFF\xC9\xA7`\xE0\x1B`\x01`\x01`\xE0\x1B\x03\x19\x83\x16\x14a\x02\xFAV[a\x07Q\x82\x82a\x04\x82V[a\x03\xA9Wa\x07^\x81a\x08\xDDV[a\x07i\x83` a\x08\xEFV[`@Q` \x01a\x07z\x92\x91\x90a\r}V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90RbF\x1B\xCD`\xE5\x1B\x82Ra\x03\x96\x91`\x04\x01a\r\xF2V[a\x07\xAA\x82\x82a\x04\x82V[a\x03\xA9W`\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\x07\xE03\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\x04{\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\n\x8BV[a\x08C\x82\x82a\x04\x82V[\x15a\x03\xA9W`\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\x04{\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\n\xDAV[`\0\x82`\0\x01\x82\x81T\x81\x10a\x08\xCAWa\x08\xCAa\x0E%V[\x90`\0R` `\0 \x01T\x90P\x92\x91PPV[``a\x02\xFA`\x01`\x01`\xA0\x1B\x03\x83\x16`\x14[```\0a\x08\xFE\x83`\x02a\x0E;V[a\t\t\x90`\x02a\x0ERV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t!Wa\t!a\x0EeV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\tKW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P`\x03`\xFC\x1B\x81`\0\x81Q\x81\x10a\tfWa\tfa\x0E%V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\x0F`\xFB\x1B\x81`\x01\x81Q\x81\x10a\t\x95Wa\t\x95a\x0E%V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\0a\t\xB9\x84`\x02a\x0E;V[a\t\xC4\x90`\x01a\x0ERV[\x90P[`\x01\x81\x11\x15a\n<Wo\x18\x18\x99\x19\x9A\x1A\x9B\x1B\x9C\x1C\xB0\xB11\xB22\xB3`\x81\x1B\x85`\x0F\x16`\x10\x81\x10a\t\xF8Wa\t\xF8a\x0E%V[\x1A`\xF8\x1B\x82\x82\x81Q\x81\x10a\n\x0EWa\n\x0Ea\x0E%V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\x04\x94\x90\x94\x1C\x93a\n5\x81a\x0E{V[\x90Pa\t\xC7V[P\x83\x15a\x04{W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FStrings: hex length insufficient`D\x82\x01R`d\x01a\x03\x96V[`\0\x81\x81R`\x01\x83\x01` R`@\x81 Ta\n\xD2WP\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\x02\xFAV[P`\0a\x02\xFAV[`\0\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a\x0B\xC3W`\0a\n\xFE`\x01\x83a\x0E\x92V[\x85T\x90\x91P`\0\x90a\x0B\x12\x90`\x01\x90a\x0E\x92V[\x90P\x81\x81\x14a\x0BwW`\0\x86`\0\x01\x82\x81T\x81\x10a\x0B2Wa\x0B2a\x0E%V[\x90`\0R` `\0 \x01T\x90P\x80\x87`\0\x01\x84\x81T\x81\x10a\x0BUWa\x0BUa\x0E%V[`\0\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80a\x0B\x88Wa\x0B\x88a\x0E\xA5V[`\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\x02\xFAV[`\0\x91PPa\x02\xFAV[`\0` \x82\x84\x03\x12\x15a\x0B\xDFW`\0\x80\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x04{W`\0\x80\xFD[`\0` \x82\x84\x03\x12\x15a\x0C\tW`\0\x80\xFD[P5\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x06/W`\0\x80\xFD[`\0\x80`@\x83\x85\x03\x12\x15a\x0C8W`\0\x80\xFD[\x825\x91P` \x83\x015a\x0CJ\x81a\x0C\x10V[\x80\x91PP\x92P\x92\x90PV[`\0` \x82\x84\x03\x12\x15a\x0CgW`\0\x80\xFD[\x815`\x01`\x01`\x80\x1B\x03\x81\x16\x81\x14a\x04{W`\0\x80\xFD[`\0\x80`@\x83\x85\x03\x12\x15a\x0C\x91W`\0\x80\xFD[PP\x805\x92` \x90\x91\x015\x91PV[`\0` \x82\x84\x03\x12\x15a\x0C\xB2W`\0\x80\xFD[\x815a\x04{\x81a\x0C\x10V[`\0\x80`@\x83\x85\x03\x12\x15a\x0C\xD0W`\0\x80\xFD[\x825a\x0C\xDB\x81a\x0C\x10V[\x91P` \x83\x015a\x0CJ\x81a\x0C\x10V[`\0` \x82\x84\x03\x12\x15a\x0C\xFDW`\0\x80\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[`\0\x82a\r7WcNH{q`\xE0\x1B`\0R`\x12`\x04R`$`\0\xFD[P\x04\x90V[`\0` \x82\x84\x03\x12\x15a\rNW`\0\x80\xFD[\x81Qa\x04{\x81a\x0C\x10V[`\0[\x83\x81\x10\x15a\rtW\x81\x81\x01Q\x83\x82\x01R` \x01a\r\\V[PP`\0\x91\x01RV[\x7FAccessControl: account \0\0\0\0\0\0\0\0\0\x81R`\0\x83Qa\r\xB5\x81`\x17\x85\x01` \x88\x01a\rYV[p\x01\x03K\x99\x03kK\x9B\x9BKs9\x03\x93{c)`}\x1B`\x17\x91\x84\x01\x91\x82\x01R\x83Qa\r\xE6\x81`(\x84\x01` \x88\x01a\rYV[\x01`(\x01\x94\x93PPPPV[` \x81R`\0\x82Q\x80` \x84\x01Ra\x0E\x11\x81`@\x85\x01` \x87\x01a\rYV[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02\xFAWa\x02\xFAa\r\x04V[\x80\x82\x01\x80\x82\x11\x15a\x02\xFAWa\x02\xFAa\r\x04V[cNH{q`\xE0\x1B`\0R`A`\x04R`$`\0\xFD[`\0\x81a\x0E\x8AWa\x0E\x8Aa\r\x04V[P`\0\x19\x01\x90V[\x81\x81\x03\x81\x81\x11\x15a\x02\xFAWa\x02\xFAa\r\x04V[cNH{q`\xE0\x1B`\0R`1`\x04R`$`\0\xFD\xFE\xA2dipfsX\"\x12 6(D`\x98G\xE7$\xB3\x1E \x80\xDE\xD7x\x19<\xDC\x8DH\xE3}\x90\xB5\xBF9\xDC6\x8B\xDD\xEC\xC2dsolcC\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",
529 );
530 #[rustfmt::skip]
536 #[allow(clippy::all)]
537 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
538 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x01\x16W`\x005`\xE0\x1C\x80c\xA2\x17\xFD\xDF\x11a\0\xA2W\x80c\xD8Z\xD0D\x11a\0qW\x80c\xD8Z\xD0D\x14a\x02TW\x80c\xEC\x87b\x1C\x14a\x02gW\x80c\xF1\x1Fw\xF9\x14a\x02\x8EW\x80c\xF2^q\x08\x14a\x02\x97W\x80c\xFC\x0CTj\x14a\x02\xC2W`\0\x80\xFD[\x80c\xA2\x17\xFD\xDF\x14a\x02\x13W\x80c\xB3TN\x82\x14a\x02\x1BW\x80c\xCA\x15\xC8s\x14a\x02.W\x80c\xD5Gt\x1F\x14a\x02AW`\0\x80\xFD[\x80cZ\xBES\x08\x11a\0\xE9W\x80cZ\xBES\x08\x14a\x01\x9CW\x80c^\xF53)\x14a\x01\xAFW\x80cjJ@A\x14a\x01\xC2W\x80c\x90\x10\xD0|\x14a\x01\xEDW\x80c\x91\xD1HT\x14a\x02\0W`\0\x80\xFD[\x80c\x01\xFF\xC9\xA7\x14a\x01\x1BW\x80c$\x8A\x9C\xA3\x14a\x01CW\x80c//\xF1]\x14a\x01tW\x80c6V\x8A\xBE\x14a\x01\x89W[`\0\x80\xFD[a\x01.a\x01)6`\x04a\x0B\xCDV[a\x02\xD5V[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01fa\x01Q6`\x04a\x0B\xF7V[`\0\x90\x81R` \x81\x90R`@\x90 `\x01\x01T\x90V[`@Q\x90\x81R` \x01a\x01:V[a\x01\x87a\x01\x826`\x04a\x0C%V[a\x03\0V[\0[a\x01\x87a\x01\x976`\x04a\x0C%V[a\x03*V[a\x01\x87a\x01\xAA6`\x04a\x0CUV[a\x03\xADV[a\x01\x87a\x01\xBD6`\x04a\x0B\xF7V[a\x04\x0EV[`\x03Ta\x01\xD5\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01:V[a\x01\xD5a\x01\xFB6`\x04a\x0C~V[a\x04cV[a\x01.a\x02\x0E6`\x04a\x0C%V[a\x04\x82V[a\x01f`\0\x81V[a\x01fa\x02)6`\x04a\x0C\xA0V[a\x04\xABV[a\x01fa\x02<6`\x04a\x0B\xF7V[a\x05?V[a\x01\x87a\x02O6`\x04a\x0C%V[a\x05VV[a\x01.a\x02b6`\x04a\x0C\xBDV[a\x05{V[a\x01f\x7F$\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\x81V[a\x01f`\x04T\x81V[`\x05Ta\x02\xAA\x90`\x01`\x01`\x80\x1B\x03\x16\x81V[`@Q`\x01`\x01`\x80\x1B\x03\x90\x91\x16\x81R` \x01a\x01:V[`\x02Ta\x01\xD5\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16c5\x87Oc`\xE1\x1B\x14\x80a\x02\xFAWPa\x02\xFA\x82a\x06\0V[\x92\x91PPV[`\0\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x03\x1B\x81a\x06%V[a\x03%\x83\x83a\x062V[PPPV[`\x01`\x01`\xA0\x1B\x03\x81\x163\x14a\x03\x9FW`@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\x03\xA9\x82\x82a\x06TV[PPV[\x7F$\x1E\xCF\x16\xD7\x9D\x0F\x8D\xBF\xB9,\xBC\x07\xFE\x17\x84\x04%\x97l\xF0f\x7F\x02/\xE9\x87|\xAA\x83\x1B\x08a\x03\xD7\x81a\x06%V[`\x05T`\x01`\x01`\x80\x1B\x03\x80\x84\x16\x91\x16\x03a\x04\x05W`@Qc\xC2?l\xCB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xA9\x82a\x06vV[\x7F$\x1E\xCF\x16\xD7\x9D\x0F\x8D\xBF\xB9,\xBC\x07\xFE\x17\x84\x04%\x97l\xF0f\x7F\x02/\xE9\x87|\xAA\x83\x1B\x08a\x048\x81a\x06%V[\x81`\x04T\x03a\x04ZW`@Qc\xC2?l\xCB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xA9\x82a\x06\xC9V[`\0\x82\x81R`\x01` R`@\x81 a\x04{\x90\x83a\x06\xFCV[\x93\x92PPPV[`\0\x91\x82R` \x82\x81R`@\x80\x84 `\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16\x84R\x91\x90R\x90 T`\xFF\x16\x90V[`\x04\x80T`\x02T`\x05T`@Qc{\xB9PI`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16\x95\x82\x01\x95\x90\x95R`\x01`\x01`\x80\x1B\x03\x90\x91\x16`$\x82\x01R`\0\x93\x90\x91\x16\x90c\xF7r\xA0\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x11W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x055\x91\x90a\x0C\xEBV[a\x02\xFA\x91\x90a\r\x1AV[`\0\x81\x81R`\x01` R`@\x81 a\x02\xFA\x90a\x07\x08V[`\0\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x05q\x81a\x06%V[a\x03%\x83\x83a\x06TV[`\x03T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R`\0\x92\x85\x82\x16\x92\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xCBW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xEF\x91\x90a\r<V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x93\x92PPPV[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cZ\x05\x18\x0F`\xE0\x1B\x14\x80a\x02\xFAWPa\x02\xFA\x82a\x07\x12V[a\x06/\x813a\x07GV[PV[a\x06<\x82\x82a\x07\xA0V[`\0\x82\x81R`\x01` R`@\x90 a\x03%\x90\x82a\x08$V[a\x06^\x82\x82a\x089V[`\0\x82\x81R`\x01` R`@\x90 a\x03%\x90\x82a\x08\x9EV[`\x05\x80To\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01`\x01`\x80\x1B\x03\x83\x16\x90\x81\x17\x90\x91U`@Q\x7F\xAF\x1D\x15\x99\xB5\xC7\xDA\x9A \x04\xB5z\xC1G\x84\x19\x97\x18\xA9\x03d\xAEG\xF2z\xC8\x94\x92o\x06U\xFC\x90`\0\x90\xA2PV[`\x04\x81\x90U`@Q\x81\x90\x7F\xAD\xFA\x8E\xCB!\xB6\x96.\xBC\xD0\xAD\xBD\x9A\xB9\x85\xB7\xB4\xC5\xB5\xEB;\r\xEA\xD6\x83\x17\x15e\xC7\xBF\xE1q\x90`\0\x90\xA2PV[`\0a\x04{\x83\x83a\x08\xB3V[`\0a\x02\xFA\x82T\x90V[`\0`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cye\xDB\x0B`\xE0\x1B\x14\x80a\x02\xFAWPc\x01\xFF\xC9\xA7`\xE0\x1B`\x01`\x01`\xE0\x1B\x03\x19\x83\x16\x14a\x02\xFAV[a\x07Q\x82\x82a\x04\x82V[a\x03\xA9Wa\x07^\x81a\x08\xDDV[a\x07i\x83` a\x08\xEFV[`@Q` \x01a\x07z\x92\x91\x90a\r}V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90RbF\x1B\xCD`\xE5\x1B\x82Ra\x03\x96\x91`\x04\x01a\r\xF2V[a\x07\xAA\x82\x82a\x04\x82V[a\x03\xA9W`\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\x07\xE03\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\x04{\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\n\x8BV[a\x08C\x82\x82a\x04\x82V[\x15a\x03\xA9W`\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\x04{\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\n\xDAV[`\0\x82`\0\x01\x82\x81T\x81\x10a\x08\xCAWa\x08\xCAa\x0E%V[\x90`\0R` `\0 \x01T\x90P\x92\x91PPV[``a\x02\xFA`\x01`\x01`\xA0\x1B\x03\x83\x16`\x14[```\0a\x08\xFE\x83`\x02a\x0E;V[a\t\t\x90`\x02a\x0ERV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t!Wa\t!a\x0EeV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\tKW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P`\x03`\xFC\x1B\x81`\0\x81Q\x81\x10a\tfWa\tfa\x0E%V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\x0F`\xFB\x1B\x81`\x01\x81Q\x81\x10a\t\x95Wa\t\x95a\x0E%V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\0a\t\xB9\x84`\x02a\x0E;V[a\t\xC4\x90`\x01a\x0ERV[\x90P[`\x01\x81\x11\x15a\n<Wo\x18\x18\x99\x19\x9A\x1A\x9B\x1B\x9C\x1C\xB0\xB11\xB22\xB3`\x81\x1B\x85`\x0F\x16`\x10\x81\x10a\t\xF8Wa\t\xF8a\x0E%V[\x1A`\xF8\x1B\x82\x82\x81Q\x81\x10a\n\x0EWa\n\x0Ea\x0E%V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81`\0\x1A\x90SP`\x04\x94\x90\x94\x1C\x93a\n5\x81a\x0E{V[\x90Pa\t\xC7V[P\x83\x15a\x04{W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FStrings: hex length insufficient`D\x82\x01R`d\x01a\x03\x96V[`\0\x81\x81R`\x01\x83\x01` R`@\x81 Ta\n\xD2WP\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\x02\xFAV[P`\0a\x02\xFAV[`\0\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a\x0B\xC3W`\0a\n\xFE`\x01\x83a\x0E\x92V[\x85T\x90\x91P`\0\x90a\x0B\x12\x90`\x01\x90a\x0E\x92V[\x90P\x81\x81\x14a\x0BwW`\0\x86`\0\x01\x82\x81T\x81\x10a\x0B2Wa\x0B2a\x0E%V[\x90`\0R` `\0 \x01T\x90P\x80\x87`\0\x01\x84\x81T\x81\x10a\x0BUWa\x0BUa\x0E%V[`\0\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80a\x0B\x88Wa\x0B\x88a\x0E\xA5V[`\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\x02\xFAV[`\0\x91PPa\x02\xFAV[`\0` \x82\x84\x03\x12\x15a\x0B\xDFW`\0\x80\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x04{W`\0\x80\xFD[`\0` \x82\x84\x03\x12\x15a\x0C\tW`\0\x80\xFD[P5\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x06/W`\0\x80\xFD[`\0\x80`@\x83\x85\x03\x12\x15a\x0C8W`\0\x80\xFD[\x825\x91P` \x83\x015a\x0CJ\x81a\x0C\x10V[\x80\x91PP\x92P\x92\x90PV[`\0` \x82\x84\x03\x12\x15a\x0CgW`\0\x80\xFD[\x815`\x01`\x01`\x80\x1B\x03\x81\x16\x81\x14a\x04{W`\0\x80\xFD[`\0\x80`@\x83\x85\x03\x12\x15a\x0C\x91W`\0\x80\xFD[PP\x805\x92` \x90\x91\x015\x91PV[`\0` \x82\x84\x03\x12\x15a\x0C\xB2W`\0\x80\xFD[\x815a\x04{\x81a\x0C\x10V[`\0\x80`@\x83\x85\x03\x12\x15a\x0C\xD0W`\0\x80\xFD[\x825a\x0C\xDB\x81a\x0C\x10V[\x91P` \x83\x015a\x0CJ\x81a\x0C\x10V[`\0` \x82\x84\x03\x12\x15a\x0C\xFDW`\0\x80\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[`\0\x82a\r7WcNH{q`\xE0\x1B`\0R`\x12`\x04R`$`\0\xFD[P\x04\x90V[`\0` \x82\x84\x03\x12\x15a\rNW`\0\x80\xFD[\x81Qa\x04{\x81a\x0C\x10V[`\0[\x83\x81\x10\x15a\rtW\x81\x81\x01Q\x83\x82\x01R` \x01a\r\\V[PP`\0\x91\x01RV[\x7FAccessControl: account \0\0\0\0\0\0\0\0\0\x81R`\0\x83Qa\r\xB5\x81`\x17\x85\x01` \x88\x01a\rYV[p\x01\x03K\x99\x03kK\x9B\x9BKs9\x03\x93{c)`}\x1B`\x17\x91\x84\x01\x91\x82\x01R\x83Qa\r\xE6\x81`(\x84\x01` \x88\x01a\rYV[\x01`(\x01\x94\x93PPPPV[` \x81R`\0\x82Q\x80` \x84\x01Ra\x0E\x11\x81`@\x85\x01` \x87\x01a\rYV[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02\xFAWa\x02\xFAa\r\x04V[\x80\x82\x01\x80\x82\x11\x15a\x02\xFAWa\x02\xFAa\r\x04V[cNH{q`\xE0\x1B`\0R`A`\x04R`$`\0\xFD[`\0\x81a\x0E\x8AWa\x0E\x8Aa\r\x04V[P`\0\x19\x01\x90V[\x81\x81\x03\x81\x81\x11\x15a\x02\xFAWa\x02\xFAa\r\x04V[cNH{q`\xE0\x1B`\0R`1`\x04R`$`\0\xFD\xFE\xA2dipfsX\"\x12 6(D`\x98G\xE7$\xB3\x1E \x80\xDE\xD7x\x19<\xDC\x8DH\xE3}\x90\xB5\xBF9\xDC6\x8B\xDD\xEC\xC2dsolcC\0\x08\x13\x003",
539 );
540 #[derive(serde::Serialize, serde::Deserialize)]
541 #[derive(Default, Debug, PartialEq, Eq, Hash)]
542 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
547 #[derive(Clone)]
548 pub struct SameValue;
549 #[allow(
550 non_camel_case_types,
551 non_snake_case,
552 clippy::pub_underscore_fields,
553 clippy::style
554 )]
555 const _: () = {
556 use alloy::sol_types as alloy_sol_types;
557 #[doc(hidden)]
558 type UnderlyingSolTuple<'a> = ();
559 #[doc(hidden)]
560 type UnderlyingRustTuple<'a> = ();
561 #[cfg(test)]
562 #[allow(dead_code, unreachable_patterns)]
563 fn _type_assertion(
564 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
565 ) {
566 match _t {
567 alloy_sol_types::private::AssertTypeEq::<
568 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
569 >(_) => {}
570 }
571 }
572 #[automatically_derived]
573 #[doc(hidden)]
574 impl ::core::convert::From<SameValue> for UnderlyingRustTuple<'_> {
575 fn from(value: SameValue) -> Self {
576 ()
577 }
578 }
579 #[automatically_derived]
580 #[doc(hidden)]
581 impl ::core::convert::From<UnderlyingRustTuple<'_>> for SameValue {
582 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
583 Self
584 }
585 }
586 #[automatically_derived]
587 impl alloy_sol_types::SolError for SameValue {
588 type Parameters<'a> = UnderlyingSolTuple<'a>;
589 type Token<'a> = <Self::Parameters<
590 'a,
591 > as alloy_sol_types::SolType>::Token<'a>;
592 const SIGNATURE: &'static str = "SameValue()";
593 const SELECTOR: [u8; 4] = [194u8, 63u8, 108u8, 203u8];
594 #[inline]
595 fn new<'a>(
596 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
597 ) -> Self {
598 tuple.into()
599 }
600 #[inline]
601 fn tokenize(&self) -> Self::Token<'_> {
602 ()
603 }
604 #[inline]
605 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
606 <Self::Parameters<
607 '_,
608 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
609 .map(Self::new)
610 }
611 }
612 };
613 #[derive(serde::Serialize, serde::Deserialize)]
614 #[derive(Default, Debug, PartialEq, Eq, Hash)]
615 #[allow(
620 non_camel_case_types,
621 non_snake_case,
622 clippy::pub_underscore_fields,
623 clippy::style
624 )]
625 #[derive(Clone)]
626 pub struct RoleAdminChanged {
627 #[allow(missing_docs)]
628 pub role: alloy::sol_types::private::FixedBytes<32>,
629 #[allow(missing_docs)]
630 pub previousAdminRole: alloy::sol_types::private::FixedBytes<32>,
631 #[allow(missing_docs)]
632 pub newAdminRole: alloy::sol_types::private::FixedBytes<32>,
633 }
634 #[allow(
635 non_camel_case_types,
636 non_snake_case,
637 clippy::pub_underscore_fields,
638 clippy::style
639 )]
640 const _: () = {
641 use alloy::sol_types as alloy_sol_types;
642 #[automatically_derived]
643 impl alloy_sol_types::SolEvent for RoleAdminChanged {
644 type DataTuple<'a> = ();
645 type DataToken<'a> = <Self::DataTuple<
646 'a,
647 > as alloy_sol_types::SolType>::Token<'a>;
648 type TopicList = (
649 alloy_sol_types::sol_data::FixedBytes<32>,
650 alloy::sol_types::sol_data::FixedBytes<32>,
651 alloy::sol_types::sol_data::FixedBytes<32>,
652 alloy::sol_types::sol_data::FixedBytes<32>,
653 );
654 const SIGNATURE: &'static str = "RoleAdminChanged(bytes32,bytes32,bytes32)";
655 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
656 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
657 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
658 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
659 ]);
660 const ANONYMOUS: bool = false;
661 #[allow(unused_variables)]
662 #[inline]
663 fn new(
664 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
665 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
666 ) -> Self {
667 Self {
668 role: topics.1,
669 previousAdminRole: topics.2,
670 newAdminRole: topics.3,
671 }
672 }
673 #[inline]
674 fn check_signature(
675 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
676 ) -> alloy_sol_types::Result<()> {
677 if topics.0 != Self::SIGNATURE_HASH {
678 return Err(
679 alloy_sol_types::Error::invalid_event_signature_hash(
680 Self::SIGNATURE,
681 topics.0,
682 Self::SIGNATURE_HASH,
683 ),
684 );
685 }
686 Ok(())
687 }
688 #[inline]
689 fn tokenize_body(&self) -> Self::DataToken<'_> {
690 ()
691 }
692 #[inline]
693 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
694 (
695 Self::SIGNATURE_HASH.into(),
696 self.role.clone(),
697 self.previousAdminRole.clone(),
698 self.newAdminRole.clone(),
699 )
700 }
701 #[inline]
702 fn encode_topics_raw(
703 &self,
704 out: &mut [alloy_sol_types::abi::token::WordToken],
705 ) -> alloy_sol_types::Result<()> {
706 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
707 return Err(alloy_sol_types::Error::Overrun);
708 }
709 out[0usize] = alloy_sol_types::abi::token::WordToken(
710 Self::SIGNATURE_HASH,
711 );
712 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
713 32,
714 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
715 out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
716 32,
717 > as alloy_sol_types::EventTopic>::encode_topic(&self.previousAdminRole);
718 out[3usize] = <alloy::sol_types::sol_data::FixedBytes<
719 32,
720 > as alloy_sol_types::EventTopic>::encode_topic(&self.newAdminRole);
721 Ok(())
722 }
723 }
724 #[automatically_derived]
725 impl alloy_sol_types::private::IntoLogData for RoleAdminChanged {
726 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
727 From::from(self)
728 }
729 fn into_log_data(self) -> alloy_sol_types::private::LogData {
730 From::from(&self)
731 }
732 }
733 #[automatically_derived]
734 impl From<&RoleAdminChanged> for alloy_sol_types::private::LogData {
735 #[inline]
736 fn from(this: &RoleAdminChanged) -> alloy_sol_types::private::LogData {
737 alloy_sol_types::SolEvent::encode_log_data(this)
738 }
739 }
740 };
741 #[derive(serde::Serialize, serde::Deserialize)]
742 #[derive(Default, Debug, PartialEq, Eq, Hash)]
743 #[allow(
748 non_camel_case_types,
749 non_snake_case,
750 clippy::pub_underscore_fields,
751 clippy::style
752 )]
753 #[derive(Clone)]
754 pub struct RoleGranted {
755 #[allow(missing_docs)]
756 pub role: alloy::sol_types::private::FixedBytes<32>,
757 #[allow(missing_docs)]
758 pub account: alloy::sol_types::private::Address,
759 #[allow(missing_docs)]
760 pub sender: alloy::sol_types::private::Address,
761 }
762 #[allow(
763 non_camel_case_types,
764 non_snake_case,
765 clippy::pub_underscore_fields,
766 clippy::style
767 )]
768 const _: () = {
769 use alloy::sol_types as alloy_sol_types;
770 #[automatically_derived]
771 impl alloy_sol_types::SolEvent for RoleGranted {
772 type DataTuple<'a> = ();
773 type DataToken<'a> = <Self::DataTuple<
774 'a,
775 > as alloy_sol_types::SolType>::Token<'a>;
776 type TopicList = (
777 alloy_sol_types::sol_data::FixedBytes<32>,
778 alloy::sol_types::sol_data::FixedBytes<32>,
779 alloy::sol_types::sol_data::Address,
780 alloy::sol_types::sol_data::Address,
781 );
782 const SIGNATURE: &'static str = "RoleGranted(bytes32,address,address)";
783 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
784 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
785 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
786 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
787 ]);
788 const ANONYMOUS: bool = false;
789 #[allow(unused_variables)]
790 #[inline]
791 fn new(
792 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
793 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
794 ) -> Self {
795 Self {
796 role: topics.1,
797 account: topics.2,
798 sender: topics.3,
799 }
800 }
801 #[inline]
802 fn check_signature(
803 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
804 ) -> alloy_sol_types::Result<()> {
805 if topics.0 != Self::SIGNATURE_HASH {
806 return Err(
807 alloy_sol_types::Error::invalid_event_signature_hash(
808 Self::SIGNATURE,
809 topics.0,
810 Self::SIGNATURE_HASH,
811 ),
812 );
813 }
814 Ok(())
815 }
816 #[inline]
817 fn tokenize_body(&self) -> Self::DataToken<'_> {
818 ()
819 }
820 #[inline]
821 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
822 (
823 Self::SIGNATURE_HASH.into(),
824 self.role.clone(),
825 self.account.clone(),
826 self.sender.clone(),
827 )
828 }
829 #[inline]
830 fn encode_topics_raw(
831 &self,
832 out: &mut [alloy_sol_types::abi::token::WordToken],
833 ) -> alloy_sol_types::Result<()> {
834 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
835 return Err(alloy_sol_types::Error::Overrun);
836 }
837 out[0usize] = alloy_sol_types::abi::token::WordToken(
838 Self::SIGNATURE_HASH,
839 );
840 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
841 32,
842 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
843 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
844 &self.account,
845 );
846 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
847 &self.sender,
848 );
849 Ok(())
850 }
851 }
852 #[automatically_derived]
853 impl alloy_sol_types::private::IntoLogData for RoleGranted {
854 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
855 From::from(self)
856 }
857 fn into_log_data(self) -> alloy_sol_types::private::LogData {
858 From::from(&self)
859 }
860 }
861 #[automatically_derived]
862 impl From<&RoleGranted> for alloy_sol_types::private::LogData {
863 #[inline]
864 fn from(this: &RoleGranted) -> alloy_sol_types::private::LogData {
865 alloy_sol_types::SolEvent::encode_log_data(this)
866 }
867 }
868 };
869 #[derive(serde::Serialize, serde::Deserialize)]
870 #[derive(Default, Debug, PartialEq, Eq, Hash)]
871 #[allow(
876 non_camel_case_types,
877 non_snake_case,
878 clippy::pub_underscore_fields,
879 clippy::style
880 )]
881 #[derive(Clone)]
882 pub struct RoleRevoked {
883 #[allow(missing_docs)]
884 pub role: alloy::sol_types::private::FixedBytes<32>,
885 #[allow(missing_docs)]
886 pub account: alloy::sol_types::private::Address,
887 #[allow(missing_docs)]
888 pub sender: alloy::sol_types::private::Address,
889 }
890 #[allow(
891 non_camel_case_types,
892 non_snake_case,
893 clippy::pub_underscore_fields,
894 clippy::style
895 )]
896 const _: () = {
897 use alloy::sol_types as alloy_sol_types;
898 #[automatically_derived]
899 impl alloy_sol_types::SolEvent for RoleRevoked {
900 type DataTuple<'a> = ();
901 type DataToken<'a> = <Self::DataTuple<
902 'a,
903 > as alloy_sol_types::SolType>::Token<'a>;
904 type TopicList = (
905 alloy_sol_types::sol_data::FixedBytes<32>,
906 alloy::sol_types::sol_data::FixedBytes<32>,
907 alloy::sol_types::sol_data::Address,
908 alloy::sol_types::sol_data::Address,
909 );
910 const SIGNATURE: &'static str = "RoleRevoked(bytes32,address,address)";
911 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
912 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
913 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
914 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
915 ]);
916 const ANONYMOUS: bool = false;
917 #[allow(unused_variables)]
918 #[inline]
919 fn new(
920 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
921 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
922 ) -> Self {
923 Self {
924 role: topics.1,
925 account: topics.2,
926 sender: topics.3,
927 }
928 }
929 #[inline]
930 fn check_signature(
931 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
932 ) -> alloy_sol_types::Result<()> {
933 if topics.0 != Self::SIGNATURE_HASH {
934 return Err(
935 alloy_sol_types::Error::invalid_event_signature_hash(
936 Self::SIGNATURE,
937 topics.0,
938 Self::SIGNATURE_HASH,
939 ),
940 );
941 }
942 Ok(())
943 }
944 #[inline]
945 fn tokenize_body(&self) -> Self::DataToken<'_> {
946 ()
947 }
948 #[inline]
949 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
950 (
951 Self::SIGNATURE_HASH.into(),
952 self.role.clone(),
953 self.account.clone(),
954 self.sender.clone(),
955 )
956 }
957 #[inline]
958 fn encode_topics_raw(
959 &self,
960 out: &mut [alloy_sol_types::abi::token::WordToken],
961 ) -> alloy_sol_types::Result<()> {
962 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
963 return Err(alloy_sol_types::Error::Overrun);
964 }
965 out[0usize] = alloy_sol_types::abi::token::WordToken(
966 Self::SIGNATURE_HASH,
967 );
968 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
969 32,
970 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
971 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
972 &self.account,
973 );
974 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
975 &self.sender,
976 );
977 Ok(())
978 }
979 }
980 #[automatically_derived]
981 impl alloy_sol_types::private::IntoLogData for RoleRevoked {
982 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
983 From::from(self)
984 }
985 fn into_log_data(self) -> alloy_sol_types::private::LogData {
986 From::from(&self)
987 }
988 }
989 #[automatically_derived]
990 impl From<&RoleRevoked> for alloy_sol_types::private::LogData {
991 #[inline]
992 fn from(this: &RoleRevoked) -> alloy_sol_types::private::LogData {
993 alloy_sol_types::SolEvent::encode_log_data(this)
994 }
995 }
996 };
997 #[derive(serde::Serialize, serde::Deserialize)]
998 #[derive(Default, Debug, PartialEq, Eq, Hash)]
999 #[allow(
1004 non_camel_case_types,
1005 non_snake_case,
1006 clippy::pub_underscore_fields,
1007 clippy::style
1008 )]
1009 #[derive(Clone)]
1010 pub struct SnapshotUpdated {
1011 #[allow(missing_docs)]
1012 pub blockNumber: u128,
1013 }
1014 #[allow(
1015 non_camel_case_types,
1016 non_snake_case,
1017 clippy::pub_underscore_fields,
1018 clippy::style
1019 )]
1020 const _: () = {
1021 use alloy::sol_types as alloy_sol_types;
1022 #[automatically_derived]
1023 impl alloy_sol_types::SolEvent for SnapshotUpdated {
1024 type DataTuple<'a> = ();
1025 type DataToken<'a> = <Self::DataTuple<
1026 'a,
1027 > as alloy_sol_types::SolType>::Token<'a>;
1028 type TopicList = (
1029 alloy_sol_types::sol_data::FixedBytes<32>,
1030 alloy::sol_types::sol_data::Uint<128>,
1031 );
1032 const SIGNATURE: &'static str = "SnapshotUpdated(uint128)";
1033 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1034 175u8, 29u8, 21u8, 153u8, 181u8, 199u8, 218u8, 154u8, 32u8, 4u8, 181u8,
1035 122u8, 193u8, 71u8, 132u8, 25u8, 151u8, 24u8, 169u8, 3u8, 100u8, 174u8,
1036 71u8, 242u8, 122u8, 200u8, 148u8, 146u8, 111u8, 6u8, 85u8, 252u8,
1037 ]);
1038 const ANONYMOUS: bool = false;
1039 #[allow(unused_variables)]
1040 #[inline]
1041 fn new(
1042 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1043 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1044 ) -> Self {
1045 Self { blockNumber: topics.1 }
1046 }
1047 #[inline]
1048 fn check_signature(
1049 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1050 ) -> alloy_sol_types::Result<()> {
1051 if topics.0 != Self::SIGNATURE_HASH {
1052 return Err(
1053 alloy_sol_types::Error::invalid_event_signature_hash(
1054 Self::SIGNATURE,
1055 topics.0,
1056 Self::SIGNATURE_HASH,
1057 ),
1058 );
1059 }
1060 Ok(())
1061 }
1062 #[inline]
1063 fn tokenize_body(&self) -> Self::DataToken<'_> {
1064 ()
1065 }
1066 #[inline]
1067 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1068 (Self::SIGNATURE_HASH.into(), self.blockNumber.clone())
1069 }
1070 #[inline]
1071 fn encode_topics_raw(
1072 &self,
1073 out: &mut [alloy_sol_types::abi::token::WordToken],
1074 ) -> alloy_sol_types::Result<()> {
1075 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1076 return Err(alloy_sol_types::Error::Overrun);
1077 }
1078 out[0usize] = alloy_sol_types::abi::token::WordToken(
1079 Self::SIGNATURE_HASH,
1080 );
1081 out[1usize] = <alloy::sol_types::sol_data::Uint<
1082 128,
1083 > as alloy_sol_types::EventTopic>::encode_topic(&self.blockNumber);
1084 Ok(())
1085 }
1086 }
1087 #[automatically_derived]
1088 impl alloy_sol_types::private::IntoLogData for SnapshotUpdated {
1089 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1090 From::from(self)
1091 }
1092 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1093 From::from(&self)
1094 }
1095 }
1096 #[automatically_derived]
1097 impl From<&SnapshotUpdated> for alloy_sol_types::private::LogData {
1098 #[inline]
1099 fn from(this: &SnapshotUpdated) -> alloy_sol_types::private::LogData {
1100 alloy_sol_types::SolEvent::encode_log_data(this)
1101 }
1102 }
1103 };
1104 #[derive(serde::Serialize, serde::Deserialize)]
1105 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1106 #[allow(
1111 non_camel_case_types,
1112 non_snake_case,
1113 clippy::pub_underscore_fields,
1114 clippy::style
1115 )]
1116 #[derive(Clone)]
1117 pub struct ThresholdUpdated {
1118 #[allow(missing_docs)]
1119 pub threshold: alloy::sol_types::private::primitives::aliases::U256,
1120 }
1121 #[allow(
1122 non_camel_case_types,
1123 non_snake_case,
1124 clippy::pub_underscore_fields,
1125 clippy::style
1126 )]
1127 const _: () = {
1128 use alloy::sol_types as alloy_sol_types;
1129 #[automatically_derived]
1130 impl alloy_sol_types::SolEvent for ThresholdUpdated {
1131 type DataTuple<'a> = ();
1132 type DataToken<'a> = <Self::DataTuple<
1133 'a,
1134 > as alloy_sol_types::SolType>::Token<'a>;
1135 type TopicList = (
1136 alloy_sol_types::sol_data::FixedBytes<32>,
1137 alloy::sol_types::sol_data::Uint<256>,
1138 );
1139 const SIGNATURE: &'static str = "ThresholdUpdated(uint256)";
1140 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1141 173u8, 250u8, 142u8, 203u8, 33u8, 182u8, 150u8, 46u8, 188u8, 208u8,
1142 173u8, 189u8, 154u8, 185u8, 133u8, 183u8, 180u8, 197u8, 181u8, 235u8,
1143 59u8, 13u8, 234u8, 214u8, 131u8, 23u8, 21u8, 101u8, 199u8, 191u8, 225u8,
1144 113u8,
1145 ]);
1146 const ANONYMOUS: bool = false;
1147 #[allow(unused_variables)]
1148 #[inline]
1149 fn new(
1150 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1151 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1152 ) -> Self {
1153 Self { threshold: topics.1 }
1154 }
1155 #[inline]
1156 fn check_signature(
1157 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1158 ) -> alloy_sol_types::Result<()> {
1159 if topics.0 != Self::SIGNATURE_HASH {
1160 return Err(
1161 alloy_sol_types::Error::invalid_event_signature_hash(
1162 Self::SIGNATURE,
1163 topics.0,
1164 Self::SIGNATURE_HASH,
1165 ),
1166 );
1167 }
1168 Ok(())
1169 }
1170 #[inline]
1171 fn tokenize_body(&self) -> Self::DataToken<'_> {
1172 ()
1173 }
1174 #[inline]
1175 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1176 (Self::SIGNATURE_HASH.into(), self.threshold.clone())
1177 }
1178 #[inline]
1179 fn encode_topics_raw(
1180 &self,
1181 out: &mut [alloy_sol_types::abi::token::WordToken],
1182 ) -> alloy_sol_types::Result<()> {
1183 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1184 return Err(alloy_sol_types::Error::Overrun);
1185 }
1186 out[0usize] = alloy_sol_types::abi::token::WordToken(
1187 Self::SIGNATURE_HASH,
1188 );
1189 out[1usize] = <alloy::sol_types::sol_data::Uint<
1190 256,
1191 > as alloy_sol_types::EventTopic>::encode_topic(&self.threshold);
1192 Ok(())
1193 }
1194 }
1195 #[automatically_derived]
1196 impl alloy_sol_types::private::IntoLogData for ThresholdUpdated {
1197 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1198 From::from(self)
1199 }
1200 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1201 From::from(&self)
1202 }
1203 }
1204 #[automatically_derived]
1205 impl From<&ThresholdUpdated> for alloy_sol_types::private::LogData {
1206 #[inline]
1207 fn from(this: &ThresholdUpdated) -> alloy_sol_types::private::LogData {
1208 alloy_sol_types::SolEvent::encode_log_data(this)
1209 }
1210 }
1211 };
1212 #[derive(serde::Serialize, serde::Deserialize)]
1213 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1214 #[allow(
1219 non_camel_case_types,
1220 non_snake_case,
1221 clippy::pub_underscore_fields,
1222 clippy::style
1223 )]
1224 #[derive(Clone)]
1225 pub struct TokenAndRegistryUpdated {
1226 #[allow(missing_docs)]
1227 pub token: alloy::sol_types::private::Address,
1228 #[allow(missing_docs)]
1229 pub nodeSafeRegistry: alloy::sol_types::private::Address,
1230 }
1231 #[allow(
1232 non_camel_case_types,
1233 non_snake_case,
1234 clippy::pub_underscore_fields,
1235 clippy::style
1236 )]
1237 const _: () = {
1238 use alloy::sol_types as alloy_sol_types;
1239 #[automatically_derived]
1240 impl alloy_sol_types::SolEvent for TokenAndRegistryUpdated {
1241 type DataTuple<'a> = ();
1242 type DataToken<'a> = <Self::DataTuple<
1243 'a,
1244 > as alloy_sol_types::SolType>::Token<'a>;
1245 type TopicList = (
1246 alloy_sol_types::sol_data::FixedBytes<32>,
1247 alloy::sol_types::sol_data::Address,
1248 alloy::sol_types::sol_data::Address,
1249 );
1250 const SIGNATURE: &'static str = "TokenAndRegistryUpdated(address,address)";
1251 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1252 119u8, 185u8, 203u8, 79u8, 135u8, 254u8, 171u8, 30u8, 189u8, 129u8, 75u8,
1253 182u8, 148u8, 183u8, 213u8, 20u8, 238u8, 45u8, 193u8, 240u8, 171u8,
1254 212u8, 195u8, 149u8, 127u8, 70u8, 130u8, 156u8, 46u8, 36u8, 157u8, 255u8,
1255 ]);
1256 const ANONYMOUS: bool = false;
1257 #[allow(unused_variables)]
1258 #[inline]
1259 fn new(
1260 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1261 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1262 ) -> Self {
1263 Self {
1264 token: topics.1,
1265 nodeSafeRegistry: topics.2,
1266 }
1267 }
1268 #[inline]
1269 fn check_signature(
1270 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1271 ) -> alloy_sol_types::Result<()> {
1272 if topics.0 != Self::SIGNATURE_HASH {
1273 return Err(
1274 alloy_sol_types::Error::invalid_event_signature_hash(
1275 Self::SIGNATURE,
1276 topics.0,
1277 Self::SIGNATURE_HASH,
1278 ),
1279 );
1280 }
1281 Ok(())
1282 }
1283 #[inline]
1284 fn tokenize_body(&self) -> Self::DataToken<'_> {
1285 ()
1286 }
1287 #[inline]
1288 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1289 (
1290 Self::SIGNATURE_HASH.into(),
1291 self.token.clone(),
1292 self.nodeSafeRegistry.clone(),
1293 )
1294 }
1295 #[inline]
1296 fn encode_topics_raw(
1297 &self,
1298 out: &mut [alloy_sol_types::abi::token::WordToken],
1299 ) -> alloy_sol_types::Result<()> {
1300 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1301 return Err(alloy_sol_types::Error::Overrun);
1302 }
1303 out[0usize] = alloy_sol_types::abi::token::WordToken(
1304 Self::SIGNATURE_HASH,
1305 );
1306 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1307 &self.token,
1308 );
1309 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1310 &self.nodeSafeRegistry,
1311 );
1312 Ok(())
1313 }
1314 }
1315 #[automatically_derived]
1316 impl alloy_sol_types::private::IntoLogData for TokenAndRegistryUpdated {
1317 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1318 From::from(self)
1319 }
1320 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1321 From::from(&self)
1322 }
1323 }
1324 #[automatically_derived]
1325 impl From<&TokenAndRegistryUpdated> for alloy_sol_types::private::LogData {
1326 #[inline]
1327 fn from(
1328 this: &TokenAndRegistryUpdated,
1329 ) -> alloy_sol_types::private::LogData {
1330 alloy_sol_types::SolEvent::encode_log_data(this)
1331 }
1332 }
1333 };
1334 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1339 #[derive(Clone)]
1340 pub struct constructorCall {
1341 #[allow(missing_docs)]
1342 pub _owner: alloy::sol_types::private::Address,
1343 #[allow(missing_docs)]
1344 pub _manager: alloy::sol_types::private::Address,
1345 #[allow(missing_docs)]
1346 pub _stakeThreshold: alloy::sol_types::private::primitives::aliases::U256,
1347 #[allow(missing_docs)]
1348 pub _snapshotBlockNumber: u128,
1349 #[allow(missing_docs)]
1350 pub _token: alloy::sol_types::private::Address,
1351 #[allow(missing_docs)]
1352 pub _nodeSafeRegistry: alloy::sol_types::private::Address,
1353 }
1354 const _: () = {
1355 use alloy::sol_types as alloy_sol_types;
1356 {
1357 #[doc(hidden)]
1358 type UnderlyingSolTuple<'a> = (
1359 alloy::sol_types::sol_data::Address,
1360 alloy::sol_types::sol_data::Address,
1361 alloy::sol_types::sol_data::Uint<256>,
1362 alloy::sol_types::sol_data::Uint<128>,
1363 alloy::sol_types::sol_data::Address,
1364 alloy::sol_types::sol_data::Address,
1365 );
1366 #[doc(hidden)]
1367 type UnderlyingRustTuple<'a> = (
1368 alloy::sol_types::private::Address,
1369 alloy::sol_types::private::Address,
1370 alloy::sol_types::private::primitives::aliases::U256,
1371 u128,
1372 alloy::sol_types::private::Address,
1373 alloy::sol_types::private::Address,
1374 );
1375 #[cfg(test)]
1376 #[allow(dead_code, unreachable_patterns)]
1377 fn _type_assertion(
1378 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1379 ) {
1380 match _t {
1381 alloy_sol_types::private::AssertTypeEq::<
1382 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1383 >(_) => {}
1384 }
1385 }
1386 #[automatically_derived]
1387 #[doc(hidden)]
1388 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
1389 fn from(value: constructorCall) -> Self {
1390 (
1391 value._owner,
1392 value._manager,
1393 value._stakeThreshold,
1394 value._snapshotBlockNumber,
1395 value._token,
1396 value._nodeSafeRegistry,
1397 )
1398 }
1399 }
1400 #[automatically_derived]
1401 #[doc(hidden)]
1402 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
1403 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1404 Self {
1405 _owner: tuple.0,
1406 _manager: tuple.1,
1407 _stakeThreshold: tuple.2,
1408 _snapshotBlockNumber: tuple.3,
1409 _token: tuple.4,
1410 _nodeSafeRegistry: tuple.5,
1411 }
1412 }
1413 }
1414 }
1415 #[automatically_derived]
1416 impl alloy_sol_types::SolConstructor for constructorCall {
1417 type Parameters<'a> = (
1418 alloy::sol_types::sol_data::Address,
1419 alloy::sol_types::sol_data::Address,
1420 alloy::sol_types::sol_data::Uint<256>,
1421 alloy::sol_types::sol_data::Uint<128>,
1422 alloy::sol_types::sol_data::Address,
1423 alloy::sol_types::sol_data::Address,
1424 );
1425 type Token<'a> = <Self::Parameters<
1426 'a,
1427 > as alloy_sol_types::SolType>::Token<'a>;
1428 #[inline]
1429 fn new<'a>(
1430 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1431 ) -> Self {
1432 tuple.into()
1433 }
1434 #[inline]
1435 fn tokenize(&self) -> Self::Token<'_> {
1436 (
1437 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1438 &self._owner,
1439 ),
1440 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1441 &self._manager,
1442 ),
1443 <alloy::sol_types::sol_data::Uint<
1444 256,
1445 > as alloy_sol_types::SolType>::tokenize(&self._stakeThreshold),
1446 <alloy::sol_types::sol_data::Uint<
1447 128,
1448 > as alloy_sol_types::SolType>::tokenize(&self._snapshotBlockNumber),
1449 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1450 &self._token,
1451 ),
1452 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1453 &self._nodeSafeRegistry,
1454 ),
1455 )
1456 }
1457 }
1458 };
1459 #[derive(serde::Serialize, serde::Deserialize)]
1460 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1461 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1466 #[derive(Clone)]
1467 pub struct DEFAULT_ADMIN_ROLECall;
1468 #[derive(serde::Serialize, serde::Deserialize)]
1469 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1470 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1472 #[derive(Clone)]
1473 pub struct DEFAULT_ADMIN_ROLEReturn {
1474 #[allow(missing_docs)]
1475 pub _0: alloy::sol_types::private::FixedBytes<32>,
1476 }
1477 #[allow(
1478 non_camel_case_types,
1479 non_snake_case,
1480 clippy::pub_underscore_fields,
1481 clippy::style
1482 )]
1483 const _: () = {
1484 use alloy::sol_types as alloy_sol_types;
1485 {
1486 #[doc(hidden)]
1487 type UnderlyingSolTuple<'a> = ();
1488 #[doc(hidden)]
1489 type UnderlyingRustTuple<'a> = ();
1490 #[cfg(test)]
1491 #[allow(dead_code, unreachable_patterns)]
1492 fn _type_assertion(
1493 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1494 ) {
1495 match _t {
1496 alloy_sol_types::private::AssertTypeEq::<
1497 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1498 >(_) => {}
1499 }
1500 }
1501 #[automatically_derived]
1502 #[doc(hidden)]
1503 impl ::core::convert::From<DEFAULT_ADMIN_ROLECall>
1504 for UnderlyingRustTuple<'_> {
1505 fn from(value: DEFAULT_ADMIN_ROLECall) -> Self {
1506 ()
1507 }
1508 }
1509 #[automatically_derived]
1510 #[doc(hidden)]
1511 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1512 for DEFAULT_ADMIN_ROLECall {
1513 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1514 Self
1515 }
1516 }
1517 }
1518 {
1519 #[doc(hidden)]
1520 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1521 #[doc(hidden)]
1522 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1523 #[cfg(test)]
1524 #[allow(dead_code, unreachable_patterns)]
1525 fn _type_assertion(
1526 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1527 ) {
1528 match _t {
1529 alloy_sol_types::private::AssertTypeEq::<
1530 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1531 >(_) => {}
1532 }
1533 }
1534 #[automatically_derived]
1535 #[doc(hidden)]
1536 impl ::core::convert::From<DEFAULT_ADMIN_ROLEReturn>
1537 for UnderlyingRustTuple<'_> {
1538 fn from(value: DEFAULT_ADMIN_ROLEReturn) -> Self {
1539 (value._0,)
1540 }
1541 }
1542 #[automatically_derived]
1543 #[doc(hidden)]
1544 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1545 for DEFAULT_ADMIN_ROLEReturn {
1546 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1547 Self { _0: tuple.0 }
1548 }
1549 }
1550 }
1551 #[automatically_derived]
1552 impl alloy_sol_types::SolCall for DEFAULT_ADMIN_ROLECall {
1553 type Parameters<'a> = ();
1554 type Token<'a> = <Self::Parameters<
1555 'a,
1556 > as alloy_sol_types::SolType>::Token<'a>;
1557 type Return = alloy::sol_types::private::FixedBytes<32>;
1558 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1559 type ReturnToken<'a> = <Self::ReturnTuple<
1560 'a,
1561 > as alloy_sol_types::SolType>::Token<'a>;
1562 const SIGNATURE: &'static str = "DEFAULT_ADMIN_ROLE()";
1563 const SELECTOR: [u8; 4] = [162u8, 23u8, 253u8, 223u8];
1564 #[inline]
1565 fn new<'a>(
1566 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1567 ) -> Self {
1568 tuple.into()
1569 }
1570 #[inline]
1571 fn tokenize(&self) -> Self::Token<'_> {
1572 ()
1573 }
1574 #[inline]
1575 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1576 (
1577 <alloy::sol_types::sol_data::FixedBytes<
1578 32,
1579 > as alloy_sol_types::SolType>::tokenize(ret),
1580 )
1581 }
1582 #[inline]
1583 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1584 <Self::ReturnTuple<
1585 '_,
1586 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1587 .map(|r| {
1588 let r: DEFAULT_ADMIN_ROLEReturn = r.into();
1589 r._0
1590 })
1591 }
1592 #[inline]
1593 fn abi_decode_returns_validate(
1594 data: &[u8],
1595 ) -> alloy_sol_types::Result<Self::Return> {
1596 <Self::ReturnTuple<
1597 '_,
1598 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1599 .map(|r| {
1600 let r: DEFAULT_ADMIN_ROLEReturn = r.into();
1601 r._0
1602 })
1603 }
1604 }
1605 };
1606 #[derive(serde::Serialize, serde::Deserialize)]
1607 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1608 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1613 #[derive(Clone)]
1614 pub struct MANAGER_ROLECall;
1615 #[derive(serde::Serialize, serde::Deserialize)]
1616 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1617 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1619 #[derive(Clone)]
1620 pub struct MANAGER_ROLEReturn {
1621 #[allow(missing_docs)]
1622 pub _0: alloy::sol_types::private::FixedBytes<32>,
1623 }
1624 #[allow(
1625 non_camel_case_types,
1626 non_snake_case,
1627 clippy::pub_underscore_fields,
1628 clippy::style
1629 )]
1630 const _: () = {
1631 use alloy::sol_types as alloy_sol_types;
1632 {
1633 #[doc(hidden)]
1634 type UnderlyingSolTuple<'a> = ();
1635 #[doc(hidden)]
1636 type UnderlyingRustTuple<'a> = ();
1637 #[cfg(test)]
1638 #[allow(dead_code, unreachable_patterns)]
1639 fn _type_assertion(
1640 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1641 ) {
1642 match _t {
1643 alloy_sol_types::private::AssertTypeEq::<
1644 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1645 >(_) => {}
1646 }
1647 }
1648 #[automatically_derived]
1649 #[doc(hidden)]
1650 impl ::core::convert::From<MANAGER_ROLECall> for UnderlyingRustTuple<'_> {
1651 fn from(value: MANAGER_ROLECall) -> Self {
1652 ()
1653 }
1654 }
1655 #[automatically_derived]
1656 #[doc(hidden)]
1657 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MANAGER_ROLECall {
1658 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1659 Self
1660 }
1661 }
1662 }
1663 {
1664 #[doc(hidden)]
1665 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1666 #[doc(hidden)]
1667 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1668 #[cfg(test)]
1669 #[allow(dead_code, unreachable_patterns)]
1670 fn _type_assertion(
1671 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1672 ) {
1673 match _t {
1674 alloy_sol_types::private::AssertTypeEq::<
1675 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1676 >(_) => {}
1677 }
1678 }
1679 #[automatically_derived]
1680 #[doc(hidden)]
1681 impl ::core::convert::From<MANAGER_ROLEReturn> for UnderlyingRustTuple<'_> {
1682 fn from(value: MANAGER_ROLEReturn) -> Self {
1683 (value._0,)
1684 }
1685 }
1686 #[automatically_derived]
1687 #[doc(hidden)]
1688 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MANAGER_ROLEReturn {
1689 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1690 Self { _0: tuple.0 }
1691 }
1692 }
1693 }
1694 #[automatically_derived]
1695 impl alloy_sol_types::SolCall for MANAGER_ROLECall {
1696 type Parameters<'a> = ();
1697 type Token<'a> = <Self::Parameters<
1698 'a,
1699 > as alloy_sol_types::SolType>::Token<'a>;
1700 type Return = alloy::sol_types::private::FixedBytes<32>;
1701 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1702 type ReturnToken<'a> = <Self::ReturnTuple<
1703 'a,
1704 > as alloy_sol_types::SolType>::Token<'a>;
1705 const SIGNATURE: &'static str = "MANAGER_ROLE()";
1706 const SELECTOR: [u8; 4] = [236u8, 135u8, 98u8, 28u8];
1707 #[inline]
1708 fn new<'a>(
1709 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1710 ) -> Self {
1711 tuple.into()
1712 }
1713 #[inline]
1714 fn tokenize(&self) -> Self::Token<'_> {
1715 ()
1716 }
1717 #[inline]
1718 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1719 (
1720 <alloy::sol_types::sol_data::FixedBytes<
1721 32,
1722 > as alloy_sol_types::SolType>::tokenize(ret),
1723 )
1724 }
1725 #[inline]
1726 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1727 <Self::ReturnTuple<
1728 '_,
1729 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1730 .map(|r| {
1731 let r: MANAGER_ROLEReturn = r.into();
1732 r._0
1733 })
1734 }
1735 #[inline]
1736 fn abi_decode_returns_validate(
1737 data: &[u8],
1738 ) -> alloy_sol_types::Result<Self::Return> {
1739 <Self::ReturnTuple<
1740 '_,
1741 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1742 .map(|r| {
1743 let r: MANAGER_ROLEReturn = r.into();
1744 r._0
1745 })
1746 }
1747 }
1748 };
1749 #[derive(serde::Serialize, serde::Deserialize)]
1750 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1751 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1756 #[derive(Clone)]
1757 pub struct canOperateForCall {
1758 #[allow(missing_docs)]
1759 pub stakingAccount: alloy::sol_types::private::Address,
1760 #[allow(missing_docs)]
1761 pub nodeAddress: alloy::sol_types::private::Address,
1762 }
1763 #[derive(serde::Serialize, serde::Deserialize)]
1764 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1765 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1767 #[derive(Clone)]
1768 pub struct canOperateForReturn {
1769 #[allow(missing_docs)]
1770 pub eligiblity: bool,
1771 }
1772 #[allow(
1773 non_camel_case_types,
1774 non_snake_case,
1775 clippy::pub_underscore_fields,
1776 clippy::style
1777 )]
1778 const _: () = {
1779 use alloy::sol_types as alloy_sol_types;
1780 {
1781 #[doc(hidden)]
1782 type UnderlyingSolTuple<'a> = (
1783 alloy::sol_types::sol_data::Address,
1784 alloy::sol_types::sol_data::Address,
1785 );
1786 #[doc(hidden)]
1787 type UnderlyingRustTuple<'a> = (
1788 alloy::sol_types::private::Address,
1789 alloy::sol_types::private::Address,
1790 );
1791 #[cfg(test)]
1792 #[allow(dead_code, unreachable_patterns)]
1793 fn _type_assertion(
1794 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1795 ) {
1796 match _t {
1797 alloy_sol_types::private::AssertTypeEq::<
1798 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1799 >(_) => {}
1800 }
1801 }
1802 #[automatically_derived]
1803 #[doc(hidden)]
1804 impl ::core::convert::From<canOperateForCall> for UnderlyingRustTuple<'_> {
1805 fn from(value: canOperateForCall) -> Self {
1806 (value.stakingAccount, value.nodeAddress)
1807 }
1808 }
1809 #[automatically_derived]
1810 #[doc(hidden)]
1811 impl ::core::convert::From<UnderlyingRustTuple<'_>> for canOperateForCall {
1812 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1813 Self {
1814 stakingAccount: tuple.0,
1815 nodeAddress: tuple.1,
1816 }
1817 }
1818 }
1819 }
1820 {
1821 #[doc(hidden)]
1822 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1823 #[doc(hidden)]
1824 type UnderlyingRustTuple<'a> = (bool,);
1825 #[cfg(test)]
1826 #[allow(dead_code, unreachable_patterns)]
1827 fn _type_assertion(
1828 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1829 ) {
1830 match _t {
1831 alloy_sol_types::private::AssertTypeEq::<
1832 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1833 >(_) => {}
1834 }
1835 }
1836 #[automatically_derived]
1837 #[doc(hidden)]
1838 impl ::core::convert::From<canOperateForReturn> for UnderlyingRustTuple<'_> {
1839 fn from(value: canOperateForReturn) -> Self {
1840 (value.eligiblity,)
1841 }
1842 }
1843 #[automatically_derived]
1844 #[doc(hidden)]
1845 impl ::core::convert::From<UnderlyingRustTuple<'_>> for canOperateForReturn {
1846 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1847 Self { eligiblity: tuple.0 }
1848 }
1849 }
1850 }
1851 #[automatically_derived]
1852 impl alloy_sol_types::SolCall for canOperateForCall {
1853 type Parameters<'a> = (
1854 alloy::sol_types::sol_data::Address,
1855 alloy::sol_types::sol_data::Address,
1856 );
1857 type Token<'a> = <Self::Parameters<
1858 'a,
1859 > as alloy_sol_types::SolType>::Token<'a>;
1860 type Return = bool;
1861 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1862 type ReturnToken<'a> = <Self::ReturnTuple<
1863 'a,
1864 > as alloy_sol_types::SolType>::Token<'a>;
1865 const SIGNATURE: &'static str = "canOperateFor(address,address)";
1866 const SELECTOR: [u8; 4] = [216u8, 90u8, 208u8, 68u8];
1867 #[inline]
1868 fn new<'a>(
1869 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1870 ) -> Self {
1871 tuple.into()
1872 }
1873 #[inline]
1874 fn tokenize(&self) -> Self::Token<'_> {
1875 (
1876 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1877 &self.stakingAccount,
1878 ),
1879 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1880 &self.nodeAddress,
1881 ),
1882 )
1883 }
1884 #[inline]
1885 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1886 (
1887 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
1888 ret,
1889 ),
1890 )
1891 }
1892 #[inline]
1893 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1894 <Self::ReturnTuple<
1895 '_,
1896 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1897 .map(|r| {
1898 let r: canOperateForReturn = r.into();
1899 r.eligiblity
1900 })
1901 }
1902 #[inline]
1903 fn abi_decode_returns_validate(
1904 data: &[u8],
1905 ) -> alloy_sol_types::Result<Self::Return> {
1906 <Self::ReturnTuple<
1907 '_,
1908 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1909 .map(|r| {
1910 let r: canOperateForReturn = r.into();
1911 r.eligiblity
1912 })
1913 }
1914 }
1915 };
1916 #[derive(serde::Serialize, serde::Deserialize)]
1917 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1918 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1923 #[derive(Clone)]
1924 pub struct getRoleAdminCall {
1925 #[allow(missing_docs)]
1926 pub role: alloy::sol_types::private::FixedBytes<32>,
1927 }
1928 #[derive(serde::Serialize, serde::Deserialize)]
1929 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1930 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1932 #[derive(Clone)]
1933 pub struct getRoleAdminReturn {
1934 #[allow(missing_docs)]
1935 pub _0: alloy::sol_types::private::FixedBytes<32>,
1936 }
1937 #[allow(
1938 non_camel_case_types,
1939 non_snake_case,
1940 clippy::pub_underscore_fields,
1941 clippy::style
1942 )]
1943 const _: () = {
1944 use alloy::sol_types as alloy_sol_types;
1945 {
1946 #[doc(hidden)]
1947 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1948 #[doc(hidden)]
1949 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1950 #[cfg(test)]
1951 #[allow(dead_code, unreachable_patterns)]
1952 fn _type_assertion(
1953 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1954 ) {
1955 match _t {
1956 alloy_sol_types::private::AssertTypeEq::<
1957 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1958 >(_) => {}
1959 }
1960 }
1961 #[automatically_derived]
1962 #[doc(hidden)]
1963 impl ::core::convert::From<getRoleAdminCall> for UnderlyingRustTuple<'_> {
1964 fn from(value: getRoleAdminCall) -> Self {
1965 (value.role,)
1966 }
1967 }
1968 #[automatically_derived]
1969 #[doc(hidden)]
1970 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminCall {
1971 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1972 Self { role: tuple.0 }
1973 }
1974 }
1975 }
1976 {
1977 #[doc(hidden)]
1978 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1979 #[doc(hidden)]
1980 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1981 #[cfg(test)]
1982 #[allow(dead_code, unreachable_patterns)]
1983 fn _type_assertion(
1984 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1985 ) {
1986 match _t {
1987 alloy_sol_types::private::AssertTypeEq::<
1988 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1989 >(_) => {}
1990 }
1991 }
1992 #[automatically_derived]
1993 #[doc(hidden)]
1994 impl ::core::convert::From<getRoleAdminReturn> for UnderlyingRustTuple<'_> {
1995 fn from(value: getRoleAdminReturn) -> Self {
1996 (value._0,)
1997 }
1998 }
1999 #[automatically_derived]
2000 #[doc(hidden)]
2001 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminReturn {
2002 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2003 Self { _0: tuple.0 }
2004 }
2005 }
2006 }
2007 #[automatically_derived]
2008 impl alloy_sol_types::SolCall for getRoleAdminCall {
2009 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2010 type Token<'a> = <Self::Parameters<
2011 'a,
2012 > as alloy_sol_types::SolType>::Token<'a>;
2013 type Return = alloy::sol_types::private::FixedBytes<32>;
2014 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2015 type ReturnToken<'a> = <Self::ReturnTuple<
2016 'a,
2017 > as alloy_sol_types::SolType>::Token<'a>;
2018 const SIGNATURE: &'static str = "getRoleAdmin(bytes32)";
2019 const SELECTOR: [u8; 4] = [36u8, 138u8, 156u8, 163u8];
2020 #[inline]
2021 fn new<'a>(
2022 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2023 ) -> Self {
2024 tuple.into()
2025 }
2026 #[inline]
2027 fn tokenize(&self) -> Self::Token<'_> {
2028 (
2029 <alloy::sol_types::sol_data::FixedBytes<
2030 32,
2031 > as alloy_sol_types::SolType>::tokenize(&self.role),
2032 )
2033 }
2034 #[inline]
2035 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2036 (
2037 <alloy::sol_types::sol_data::FixedBytes<
2038 32,
2039 > as alloy_sol_types::SolType>::tokenize(ret),
2040 )
2041 }
2042 #[inline]
2043 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2044 <Self::ReturnTuple<
2045 '_,
2046 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2047 .map(|r| {
2048 let r: getRoleAdminReturn = r.into();
2049 r._0
2050 })
2051 }
2052 #[inline]
2053 fn abi_decode_returns_validate(
2054 data: &[u8],
2055 ) -> alloy_sol_types::Result<Self::Return> {
2056 <Self::ReturnTuple<
2057 '_,
2058 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2059 .map(|r| {
2060 let r: getRoleAdminReturn = r.into();
2061 r._0
2062 })
2063 }
2064 }
2065 };
2066 #[derive(serde::Serialize, serde::Deserialize)]
2067 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2068 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2073 #[derive(Clone)]
2074 pub struct getRoleMemberCall {
2075 #[allow(missing_docs)]
2076 pub role: alloy::sol_types::private::FixedBytes<32>,
2077 #[allow(missing_docs)]
2078 pub index: alloy::sol_types::private::primitives::aliases::U256,
2079 }
2080 #[derive(serde::Serialize, serde::Deserialize)]
2081 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2082 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2084 #[derive(Clone)]
2085 pub struct getRoleMemberReturn {
2086 #[allow(missing_docs)]
2087 pub _0: alloy::sol_types::private::Address,
2088 }
2089 #[allow(
2090 non_camel_case_types,
2091 non_snake_case,
2092 clippy::pub_underscore_fields,
2093 clippy::style
2094 )]
2095 const _: () = {
2096 use alloy::sol_types as alloy_sol_types;
2097 {
2098 #[doc(hidden)]
2099 type UnderlyingSolTuple<'a> = (
2100 alloy::sol_types::sol_data::FixedBytes<32>,
2101 alloy::sol_types::sol_data::Uint<256>,
2102 );
2103 #[doc(hidden)]
2104 type UnderlyingRustTuple<'a> = (
2105 alloy::sol_types::private::FixedBytes<32>,
2106 alloy::sol_types::private::primitives::aliases::U256,
2107 );
2108 #[cfg(test)]
2109 #[allow(dead_code, unreachable_patterns)]
2110 fn _type_assertion(
2111 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2112 ) {
2113 match _t {
2114 alloy_sol_types::private::AssertTypeEq::<
2115 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2116 >(_) => {}
2117 }
2118 }
2119 #[automatically_derived]
2120 #[doc(hidden)]
2121 impl ::core::convert::From<getRoleMemberCall> for UnderlyingRustTuple<'_> {
2122 fn from(value: getRoleMemberCall) -> Self {
2123 (value.role, value.index)
2124 }
2125 }
2126 #[automatically_derived]
2127 #[doc(hidden)]
2128 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberCall {
2129 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2130 Self {
2131 role: tuple.0,
2132 index: tuple.1,
2133 }
2134 }
2135 }
2136 }
2137 {
2138 #[doc(hidden)]
2139 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2140 #[doc(hidden)]
2141 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2142 #[cfg(test)]
2143 #[allow(dead_code, unreachable_patterns)]
2144 fn _type_assertion(
2145 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2146 ) {
2147 match _t {
2148 alloy_sol_types::private::AssertTypeEq::<
2149 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2150 >(_) => {}
2151 }
2152 }
2153 #[automatically_derived]
2154 #[doc(hidden)]
2155 impl ::core::convert::From<getRoleMemberReturn> for UnderlyingRustTuple<'_> {
2156 fn from(value: getRoleMemberReturn) -> Self {
2157 (value._0,)
2158 }
2159 }
2160 #[automatically_derived]
2161 #[doc(hidden)]
2162 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberReturn {
2163 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2164 Self { _0: tuple.0 }
2165 }
2166 }
2167 }
2168 #[automatically_derived]
2169 impl alloy_sol_types::SolCall for getRoleMemberCall {
2170 type Parameters<'a> = (
2171 alloy::sol_types::sol_data::FixedBytes<32>,
2172 alloy::sol_types::sol_data::Uint<256>,
2173 );
2174 type Token<'a> = <Self::Parameters<
2175 'a,
2176 > as alloy_sol_types::SolType>::Token<'a>;
2177 type Return = alloy::sol_types::private::Address;
2178 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2179 type ReturnToken<'a> = <Self::ReturnTuple<
2180 'a,
2181 > as alloy_sol_types::SolType>::Token<'a>;
2182 const SIGNATURE: &'static str = "getRoleMember(bytes32,uint256)";
2183 const SELECTOR: [u8; 4] = [144u8, 16u8, 208u8, 124u8];
2184 #[inline]
2185 fn new<'a>(
2186 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2187 ) -> Self {
2188 tuple.into()
2189 }
2190 #[inline]
2191 fn tokenize(&self) -> Self::Token<'_> {
2192 (
2193 <alloy::sol_types::sol_data::FixedBytes<
2194 32,
2195 > as alloy_sol_types::SolType>::tokenize(&self.role),
2196 <alloy::sol_types::sol_data::Uint<
2197 256,
2198 > as alloy_sol_types::SolType>::tokenize(&self.index),
2199 )
2200 }
2201 #[inline]
2202 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2203 (
2204 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2205 ret,
2206 ),
2207 )
2208 }
2209 #[inline]
2210 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2211 <Self::ReturnTuple<
2212 '_,
2213 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2214 .map(|r| {
2215 let r: getRoleMemberReturn = r.into();
2216 r._0
2217 })
2218 }
2219 #[inline]
2220 fn abi_decode_returns_validate(
2221 data: &[u8],
2222 ) -> alloy_sol_types::Result<Self::Return> {
2223 <Self::ReturnTuple<
2224 '_,
2225 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2226 .map(|r| {
2227 let r: getRoleMemberReturn = r.into();
2228 r._0
2229 })
2230 }
2231 }
2232 };
2233 #[derive(serde::Serialize, serde::Deserialize)]
2234 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2235 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2240 #[derive(Clone)]
2241 pub struct getRoleMemberCountCall {
2242 #[allow(missing_docs)]
2243 pub role: alloy::sol_types::private::FixedBytes<32>,
2244 }
2245 #[derive(serde::Serialize, serde::Deserialize)]
2246 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2247 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2249 #[derive(Clone)]
2250 pub struct getRoleMemberCountReturn {
2251 #[allow(missing_docs)]
2252 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2253 }
2254 #[allow(
2255 non_camel_case_types,
2256 non_snake_case,
2257 clippy::pub_underscore_fields,
2258 clippy::style
2259 )]
2260 const _: () = {
2261 use alloy::sol_types as alloy_sol_types;
2262 {
2263 #[doc(hidden)]
2264 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2265 #[doc(hidden)]
2266 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
2267 #[cfg(test)]
2268 #[allow(dead_code, unreachable_patterns)]
2269 fn _type_assertion(
2270 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2271 ) {
2272 match _t {
2273 alloy_sol_types::private::AssertTypeEq::<
2274 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2275 >(_) => {}
2276 }
2277 }
2278 #[automatically_derived]
2279 #[doc(hidden)]
2280 impl ::core::convert::From<getRoleMemberCountCall>
2281 for UnderlyingRustTuple<'_> {
2282 fn from(value: getRoleMemberCountCall) -> Self {
2283 (value.role,)
2284 }
2285 }
2286 #[automatically_derived]
2287 #[doc(hidden)]
2288 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2289 for getRoleMemberCountCall {
2290 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2291 Self { role: tuple.0 }
2292 }
2293 }
2294 }
2295 {
2296 #[doc(hidden)]
2297 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2298 #[doc(hidden)]
2299 type UnderlyingRustTuple<'a> = (
2300 alloy::sol_types::private::primitives::aliases::U256,
2301 );
2302 #[cfg(test)]
2303 #[allow(dead_code, unreachable_patterns)]
2304 fn _type_assertion(
2305 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2306 ) {
2307 match _t {
2308 alloy_sol_types::private::AssertTypeEq::<
2309 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2310 >(_) => {}
2311 }
2312 }
2313 #[automatically_derived]
2314 #[doc(hidden)]
2315 impl ::core::convert::From<getRoleMemberCountReturn>
2316 for UnderlyingRustTuple<'_> {
2317 fn from(value: getRoleMemberCountReturn) -> Self {
2318 (value._0,)
2319 }
2320 }
2321 #[automatically_derived]
2322 #[doc(hidden)]
2323 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2324 for getRoleMemberCountReturn {
2325 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2326 Self { _0: tuple.0 }
2327 }
2328 }
2329 }
2330 #[automatically_derived]
2331 impl alloy_sol_types::SolCall for getRoleMemberCountCall {
2332 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2333 type Token<'a> = <Self::Parameters<
2334 'a,
2335 > as alloy_sol_types::SolType>::Token<'a>;
2336 type Return = alloy::sol_types::private::primitives::aliases::U256;
2337 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2338 type ReturnToken<'a> = <Self::ReturnTuple<
2339 'a,
2340 > as alloy_sol_types::SolType>::Token<'a>;
2341 const SIGNATURE: &'static str = "getRoleMemberCount(bytes32)";
2342 const SELECTOR: [u8; 4] = [202u8, 21u8, 200u8, 115u8];
2343 #[inline]
2344 fn new<'a>(
2345 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2346 ) -> Self {
2347 tuple.into()
2348 }
2349 #[inline]
2350 fn tokenize(&self) -> Self::Token<'_> {
2351 (
2352 <alloy::sol_types::sol_data::FixedBytes<
2353 32,
2354 > as alloy_sol_types::SolType>::tokenize(&self.role),
2355 )
2356 }
2357 #[inline]
2358 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2359 (
2360 <alloy::sol_types::sol_data::Uint<
2361 256,
2362 > as alloy_sol_types::SolType>::tokenize(ret),
2363 )
2364 }
2365 #[inline]
2366 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2367 <Self::ReturnTuple<
2368 '_,
2369 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2370 .map(|r| {
2371 let r: getRoleMemberCountReturn = r.into();
2372 r._0
2373 })
2374 }
2375 #[inline]
2376 fn abi_decode_returns_validate(
2377 data: &[u8],
2378 ) -> alloy_sol_types::Result<Self::Return> {
2379 <Self::ReturnTuple<
2380 '_,
2381 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2382 .map(|r| {
2383 let r: getRoleMemberCountReturn = r.into();
2384 r._0
2385 })
2386 }
2387 }
2388 };
2389 #[derive(serde::Serialize, serde::Deserialize)]
2390 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2391 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2396 #[derive(Clone)]
2397 pub struct grantRoleCall {
2398 #[allow(missing_docs)]
2399 pub role: alloy::sol_types::private::FixedBytes<32>,
2400 #[allow(missing_docs)]
2401 pub account: alloy::sol_types::private::Address,
2402 }
2403 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2405 #[derive(Clone)]
2406 pub struct grantRoleReturn {}
2407 #[allow(
2408 non_camel_case_types,
2409 non_snake_case,
2410 clippy::pub_underscore_fields,
2411 clippy::style
2412 )]
2413 const _: () = {
2414 use alloy::sol_types as alloy_sol_types;
2415 {
2416 #[doc(hidden)]
2417 type UnderlyingSolTuple<'a> = (
2418 alloy::sol_types::sol_data::FixedBytes<32>,
2419 alloy::sol_types::sol_data::Address,
2420 );
2421 #[doc(hidden)]
2422 type UnderlyingRustTuple<'a> = (
2423 alloy::sol_types::private::FixedBytes<32>,
2424 alloy::sol_types::private::Address,
2425 );
2426 #[cfg(test)]
2427 #[allow(dead_code, unreachable_patterns)]
2428 fn _type_assertion(
2429 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2430 ) {
2431 match _t {
2432 alloy_sol_types::private::AssertTypeEq::<
2433 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2434 >(_) => {}
2435 }
2436 }
2437 #[automatically_derived]
2438 #[doc(hidden)]
2439 impl ::core::convert::From<grantRoleCall> for UnderlyingRustTuple<'_> {
2440 fn from(value: grantRoleCall) -> Self {
2441 (value.role, value.account)
2442 }
2443 }
2444 #[automatically_derived]
2445 #[doc(hidden)]
2446 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
2447 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2448 Self {
2449 role: tuple.0,
2450 account: tuple.1,
2451 }
2452 }
2453 }
2454 }
2455 {
2456 #[doc(hidden)]
2457 type UnderlyingSolTuple<'a> = ();
2458 #[doc(hidden)]
2459 type UnderlyingRustTuple<'a> = ();
2460 #[cfg(test)]
2461 #[allow(dead_code, unreachable_patterns)]
2462 fn _type_assertion(
2463 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2464 ) {
2465 match _t {
2466 alloy_sol_types::private::AssertTypeEq::<
2467 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2468 >(_) => {}
2469 }
2470 }
2471 #[automatically_derived]
2472 #[doc(hidden)]
2473 impl ::core::convert::From<grantRoleReturn> for UnderlyingRustTuple<'_> {
2474 fn from(value: grantRoleReturn) -> Self {
2475 ()
2476 }
2477 }
2478 #[automatically_derived]
2479 #[doc(hidden)]
2480 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
2481 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2482 Self {}
2483 }
2484 }
2485 }
2486 impl grantRoleReturn {
2487 fn _tokenize(
2488 &self,
2489 ) -> <grantRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2490 ()
2491 }
2492 }
2493 #[automatically_derived]
2494 impl alloy_sol_types::SolCall for grantRoleCall {
2495 type Parameters<'a> = (
2496 alloy::sol_types::sol_data::FixedBytes<32>,
2497 alloy::sol_types::sol_data::Address,
2498 );
2499 type Token<'a> = <Self::Parameters<
2500 'a,
2501 > as alloy_sol_types::SolType>::Token<'a>;
2502 type Return = grantRoleReturn;
2503 type ReturnTuple<'a> = ();
2504 type ReturnToken<'a> = <Self::ReturnTuple<
2505 'a,
2506 > as alloy_sol_types::SolType>::Token<'a>;
2507 const SIGNATURE: &'static str = "grantRole(bytes32,address)";
2508 const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
2509 #[inline]
2510 fn new<'a>(
2511 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2512 ) -> Self {
2513 tuple.into()
2514 }
2515 #[inline]
2516 fn tokenize(&self) -> Self::Token<'_> {
2517 (
2518 <alloy::sol_types::sol_data::FixedBytes<
2519 32,
2520 > as alloy_sol_types::SolType>::tokenize(&self.role),
2521 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2522 &self.account,
2523 ),
2524 )
2525 }
2526 #[inline]
2527 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2528 grantRoleReturn::_tokenize(ret)
2529 }
2530 #[inline]
2531 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2532 <Self::ReturnTuple<
2533 '_,
2534 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2535 .map(Into::into)
2536 }
2537 #[inline]
2538 fn abi_decode_returns_validate(
2539 data: &[u8],
2540 ) -> alloy_sol_types::Result<Self::Return> {
2541 <Self::ReturnTuple<
2542 '_,
2543 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2544 .map(Into::into)
2545 }
2546 }
2547 };
2548 #[derive(serde::Serialize, serde::Deserialize)]
2549 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2550 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2555 #[derive(Clone)]
2556 pub struct hasRoleCall {
2557 #[allow(missing_docs)]
2558 pub role: alloy::sol_types::private::FixedBytes<32>,
2559 #[allow(missing_docs)]
2560 pub account: alloy::sol_types::private::Address,
2561 }
2562 #[derive(serde::Serialize, serde::Deserialize)]
2563 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2564 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2566 #[derive(Clone)]
2567 pub struct hasRoleReturn {
2568 #[allow(missing_docs)]
2569 pub _0: bool,
2570 }
2571 #[allow(
2572 non_camel_case_types,
2573 non_snake_case,
2574 clippy::pub_underscore_fields,
2575 clippy::style
2576 )]
2577 const _: () = {
2578 use alloy::sol_types as alloy_sol_types;
2579 {
2580 #[doc(hidden)]
2581 type UnderlyingSolTuple<'a> = (
2582 alloy::sol_types::sol_data::FixedBytes<32>,
2583 alloy::sol_types::sol_data::Address,
2584 );
2585 #[doc(hidden)]
2586 type UnderlyingRustTuple<'a> = (
2587 alloy::sol_types::private::FixedBytes<32>,
2588 alloy::sol_types::private::Address,
2589 );
2590 #[cfg(test)]
2591 #[allow(dead_code, unreachable_patterns)]
2592 fn _type_assertion(
2593 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2594 ) {
2595 match _t {
2596 alloy_sol_types::private::AssertTypeEq::<
2597 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2598 >(_) => {}
2599 }
2600 }
2601 #[automatically_derived]
2602 #[doc(hidden)]
2603 impl ::core::convert::From<hasRoleCall> for UnderlyingRustTuple<'_> {
2604 fn from(value: hasRoleCall) -> Self {
2605 (value.role, value.account)
2606 }
2607 }
2608 #[automatically_derived]
2609 #[doc(hidden)]
2610 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleCall {
2611 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2612 Self {
2613 role: tuple.0,
2614 account: tuple.1,
2615 }
2616 }
2617 }
2618 }
2619 {
2620 #[doc(hidden)]
2621 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2622 #[doc(hidden)]
2623 type UnderlyingRustTuple<'a> = (bool,);
2624 #[cfg(test)]
2625 #[allow(dead_code, unreachable_patterns)]
2626 fn _type_assertion(
2627 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2628 ) {
2629 match _t {
2630 alloy_sol_types::private::AssertTypeEq::<
2631 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2632 >(_) => {}
2633 }
2634 }
2635 #[automatically_derived]
2636 #[doc(hidden)]
2637 impl ::core::convert::From<hasRoleReturn> for UnderlyingRustTuple<'_> {
2638 fn from(value: hasRoleReturn) -> Self {
2639 (value._0,)
2640 }
2641 }
2642 #[automatically_derived]
2643 #[doc(hidden)]
2644 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleReturn {
2645 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2646 Self { _0: tuple.0 }
2647 }
2648 }
2649 }
2650 #[automatically_derived]
2651 impl alloy_sol_types::SolCall for hasRoleCall {
2652 type Parameters<'a> = (
2653 alloy::sol_types::sol_data::FixedBytes<32>,
2654 alloy::sol_types::sol_data::Address,
2655 );
2656 type Token<'a> = <Self::Parameters<
2657 'a,
2658 > as alloy_sol_types::SolType>::Token<'a>;
2659 type Return = bool;
2660 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2661 type ReturnToken<'a> = <Self::ReturnTuple<
2662 'a,
2663 > as alloy_sol_types::SolType>::Token<'a>;
2664 const SIGNATURE: &'static str = "hasRole(bytes32,address)";
2665 const SELECTOR: [u8; 4] = [145u8, 209u8, 72u8, 84u8];
2666 #[inline]
2667 fn new<'a>(
2668 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2669 ) -> Self {
2670 tuple.into()
2671 }
2672 #[inline]
2673 fn tokenize(&self) -> Self::Token<'_> {
2674 (
2675 <alloy::sol_types::sol_data::FixedBytes<
2676 32,
2677 > as alloy_sol_types::SolType>::tokenize(&self.role),
2678 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2679 &self.account,
2680 ),
2681 )
2682 }
2683 #[inline]
2684 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2685 (
2686 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
2687 ret,
2688 ),
2689 )
2690 }
2691 #[inline]
2692 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2693 <Self::ReturnTuple<
2694 '_,
2695 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2696 .map(|r| {
2697 let r: hasRoleReturn = r.into();
2698 r._0
2699 })
2700 }
2701 #[inline]
2702 fn abi_decode_returns_validate(
2703 data: &[u8],
2704 ) -> alloy_sol_types::Result<Self::Return> {
2705 <Self::ReturnTuple<
2706 '_,
2707 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2708 .map(|r| {
2709 let r: hasRoleReturn = r.into();
2710 r._0
2711 })
2712 }
2713 }
2714 };
2715 #[derive(serde::Serialize, serde::Deserialize)]
2716 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2717 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2722 #[derive(Clone)]
2723 pub struct maxAllowedRegistrationsCall {
2724 #[allow(missing_docs)]
2725 pub safeAddress: alloy::sol_types::private::Address,
2726 }
2727 #[derive(serde::Serialize, serde::Deserialize)]
2728 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2729 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2731 #[derive(Clone)]
2732 pub struct maxAllowedRegistrationsReturn {
2733 #[allow(missing_docs)]
2734 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2735 }
2736 #[allow(
2737 non_camel_case_types,
2738 non_snake_case,
2739 clippy::pub_underscore_fields,
2740 clippy::style
2741 )]
2742 const _: () = {
2743 use alloy::sol_types as alloy_sol_types;
2744 {
2745 #[doc(hidden)]
2746 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2747 #[doc(hidden)]
2748 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2749 #[cfg(test)]
2750 #[allow(dead_code, unreachable_patterns)]
2751 fn _type_assertion(
2752 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2753 ) {
2754 match _t {
2755 alloy_sol_types::private::AssertTypeEq::<
2756 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2757 >(_) => {}
2758 }
2759 }
2760 #[automatically_derived]
2761 #[doc(hidden)]
2762 impl ::core::convert::From<maxAllowedRegistrationsCall>
2763 for UnderlyingRustTuple<'_> {
2764 fn from(value: maxAllowedRegistrationsCall) -> Self {
2765 (value.safeAddress,)
2766 }
2767 }
2768 #[automatically_derived]
2769 #[doc(hidden)]
2770 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2771 for maxAllowedRegistrationsCall {
2772 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2773 Self { safeAddress: tuple.0 }
2774 }
2775 }
2776 }
2777 {
2778 #[doc(hidden)]
2779 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2780 #[doc(hidden)]
2781 type UnderlyingRustTuple<'a> = (
2782 alloy::sol_types::private::primitives::aliases::U256,
2783 );
2784 #[cfg(test)]
2785 #[allow(dead_code, unreachable_patterns)]
2786 fn _type_assertion(
2787 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2788 ) {
2789 match _t {
2790 alloy_sol_types::private::AssertTypeEq::<
2791 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2792 >(_) => {}
2793 }
2794 }
2795 #[automatically_derived]
2796 #[doc(hidden)]
2797 impl ::core::convert::From<maxAllowedRegistrationsReturn>
2798 for UnderlyingRustTuple<'_> {
2799 fn from(value: maxAllowedRegistrationsReturn) -> Self {
2800 (value._0,)
2801 }
2802 }
2803 #[automatically_derived]
2804 #[doc(hidden)]
2805 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2806 for maxAllowedRegistrationsReturn {
2807 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2808 Self { _0: tuple.0 }
2809 }
2810 }
2811 }
2812 #[automatically_derived]
2813 impl alloy_sol_types::SolCall for maxAllowedRegistrationsCall {
2814 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2815 type Token<'a> = <Self::Parameters<
2816 'a,
2817 > as alloy_sol_types::SolType>::Token<'a>;
2818 type Return = alloy::sol_types::private::primitives::aliases::U256;
2819 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2820 type ReturnToken<'a> = <Self::ReturnTuple<
2821 'a,
2822 > as alloy_sol_types::SolType>::Token<'a>;
2823 const SIGNATURE: &'static str = "maxAllowedRegistrations(address)";
2824 const SELECTOR: [u8; 4] = [179u8, 84u8, 78u8, 130u8];
2825 #[inline]
2826 fn new<'a>(
2827 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2828 ) -> Self {
2829 tuple.into()
2830 }
2831 #[inline]
2832 fn tokenize(&self) -> Self::Token<'_> {
2833 (
2834 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2835 &self.safeAddress,
2836 ),
2837 )
2838 }
2839 #[inline]
2840 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2841 (
2842 <alloy::sol_types::sol_data::Uint<
2843 256,
2844 > as alloy_sol_types::SolType>::tokenize(ret),
2845 )
2846 }
2847 #[inline]
2848 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2849 <Self::ReturnTuple<
2850 '_,
2851 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2852 .map(|r| {
2853 let r: maxAllowedRegistrationsReturn = r.into();
2854 r._0
2855 })
2856 }
2857 #[inline]
2858 fn abi_decode_returns_validate(
2859 data: &[u8],
2860 ) -> alloy_sol_types::Result<Self::Return> {
2861 <Self::ReturnTuple<
2862 '_,
2863 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2864 .map(|r| {
2865 let r: maxAllowedRegistrationsReturn = r.into();
2866 r._0
2867 })
2868 }
2869 }
2870 };
2871 #[derive(serde::Serialize, serde::Deserialize)]
2872 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2873 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2878 #[derive(Clone)]
2879 pub struct nodeSafeRegistryCall;
2880 #[derive(serde::Serialize, serde::Deserialize)]
2881 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2882 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2884 #[derive(Clone)]
2885 pub struct nodeSafeRegistryReturn {
2886 #[allow(missing_docs)]
2887 pub _0: alloy::sol_types::private::Address,
2888 }
2889 #[allow(
2890 non_camel_case_types,
2891 non_snake_case,
2892 clippy::pub_underscore_fields,
2893 clippy::style
2894 )]
2895 const _: () = {
2896 use alloy::sol_types as alloy_sol_types;
2897 {
2898 #[doc(hidden)]
2899 type UnderlyingSolTuple<'a> = ();
2900 #[doc(hidden)]
2901 type UnderlyingRustTuple<'a> = ();
2902 #[cfg(test)]
2903 #[allow(dead_code, unreachable_patterns)]
2904 fn _type_assertion(
2905 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2906 ) {
2907 match _t {
2908 alloy_sol_types::private::AssertTypeEq::<
2909 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2910 >(_) => {}
2911 }
2912 }
2913 #[automatically_derived]
2914 #[doc(hidden)]
2915 impl ::core::convert::From<nodeSafeRegistryCall>
2916 for UnderlyingRustTuple<'_> {
2917 fn from(value: nodeSafeRegistryCall) -> Self {
2918 ()
2919 }
2920 }
2921 #[automatically_derived]
2922 #[doc(hidden)]
2923 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2924 for nodeSafeRegistryCall {
2925 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2926 Self
2927 }
2928 }
2929 }
2930 {
2931 #[doc(hidden)]
2932 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2933 #[doc(hidden)]
2934 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2935 #[cfg(test)]
2936 #[allow(dead_code, unreachable_patterns)]
2937 fn _type_assertion(
2938 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2939 ) {
2940 match _t {
2941 alloy_sol_types::private::AssertTypeEq::<
2942 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2943 >(_) => {}
2944 }
2945 }
2946 #[automatically_derived]
2947 #[doc(hidden)]
2948 impl ::core::convert::From<nodeSafeRegistryReturn>
2949 for UnderlyingRustTuple<'_> {
2950 fn from(value: nodeSafeRegistryReturn) -> Self {
2951 (value._0,)
2952 }
2953 }
2954 #[automatically_derived]
2955 #[doc(hidden)]
2956 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2957 for nodeSafeRegistryReturn {
2958 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2959 Self { _0: tuple.0 }
2960 }
2961 }
2962 }
2963 #[automatically_derived]
2964 impl alloy_sol_types::SolCall for nodeSafeRegistryCall {
2965 type Parameters<'a> = ();
2966 type Token<'a> = <Self::Parameters<
2967 'a,
2968 > as alloy_sol_types::SolType>::Token<'a>;
2969 type Return = alloy::sol_types::private::Address;
2970 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2971 type ReturnToken<'a> = <Self::ReturnTuple<
2972 'a,
2973 > as alloy_sol_types::SolType>::Token<'a>;
2974 const SIGNATURE: &'static str = "nodeSafeRegistry()";
2975 const SELECTOR: [u8; 4] = [106u8, 74u8, 64u8, 65u8];
2976 #[inline]
2977 fn new<'a>(
2978 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2979 ) -> Self {
2980 tuple.into()
2981 }
2982 #[inline]
2983 fn tokenize(&self) -> Self::Token<'_> {
2984 ()
2985 }
2986 #[inline]
2987 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2988 (
2989 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2990 ret,
2991 ),
2992 )
2993 }
2994 #[inline]
2995 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2996 <Self::ReturnTuple<
2997 '_,
2998 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2999 .map(|r| {
3000 let r: nodeSafeRegistryReturn = r.into();
3001 r._0
3002 })
3003 }
3004 #[inline]
3005 fn abi_decode_returns_validate(
3006 data: &[u8],
3007 ) -> alloy_sol_types::Result<Self::Return> {
3008 <Self::ReturnTuple<
3009 '_,
3010 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3011 .map(|r| {
3012 let r: nodeSafeRegistryReturn = r.into();
3013 r._0
3014 })
3015 }
3016 }
3017 };
3018 #[derive(serde::Serialize, serde::Deserialize)]
3019 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3020 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3025 #[derive(Clone)]
3026 pub struct renounceRoleCall {
3027 #[allow(missing_docs)]
3028 pub role: alloy::sol_types::private::FixedBytes<32>,
3029 #[allow(missing_docs)]
3030 pub account: alloy::sol_types::private::Address,
3031 }
3032 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3034 #[derive(Clone)]
3035 pub struct renounceRoleReturn {}
3036 #[allow(
3037 non_camel_case_types,
3038 non_snake_case,
3039 clippy::pub_underscore_fields,
3040 clippy::style
3041 )]
3042 const _: () = {
3043 use alloy::sol_types as alloy_sol_types;
3044 {
3045 #[doc(hidden)]
3046 type UnderlyingSolTuple<'a> = (
3047 alloy::sol_types::sol_data::FixedBytes<32>,
3048 alloy::sol_types::sol_data::Address,
3049 );
3050 #[doc(hidden)]
3051 type UnderlyingRustTuple<'a> = (
3052 alloy::sol_types::private::FixedBytes<32>,
3053 alloy::sol_types::private::Address,
3054 );
3055 #[cfg(test)]
3056 #[allow(dead_code, unreachable_patterns)]
3057 fn _type_assertion(
3058 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3059 ) {
3060 match _t {
3061 alloy_sol_types::private::AssertTypeEq::<
3062 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3063 >(_) => {}
3064 }
3065 }
3066 #[automatically_derived]
3067 #[doc(hidden)]
3068 impl ::core::convert::From<renounceRoleCall> for UnderlyingRustTuple<'_> {
3069 fn from(value: renounceRoleCall) -> Self {
3070 (value.role, value.account)
3071 }
3072 }
3073 #[automatically_derived]
3074 #[doc(hidden)]
3075 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleCall {
3076 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3077 Self {
3078 role: tuple.0,
3079 account: tuple.1,
3080 }
3081 }
3082 }
3083 }
3084 {
3085 #[doc(hidden)]
3086 type UnderlyingSolTuple<'a> = ();
3087 #[doc(hidden)]
3088 type UnderlyingRustTuple<'a> = ();
3089 #[cfg(test)]
3090 #[allow(dead_code, unreachable_patterns)]
3091 fn _type_assertion(
3092 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3093 ) {
3094 match _t {
3095 alloy_sol_types::private::AssertTypeEq::<
3096 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3097 >(_) => {}
3098 }
3099 }
3100 #[automatically_derived]
3101 #[doc(hidden)]
3102 impl ::core::convert::From<renounceRoleReturn> for UnderlyingRustTuple<'_> {
3103 fn from(value: renounceRoleReturn) -> Self {
3104 ()
3105 }
3106 }
3107 #[automatically_derived]
3108 #[doc(hidden)]
3109 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleReturn {
3110 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3111 Self {}
3112 }
3113 }
3114 }
3115 impl renounceRoleReturn {
3116 fn _tokenize(
3117 &self,
3118 ) -> <renounceRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3119 ()
3120 }
3121 }
3122 #[automatically_derived]
3123 impl alloy_sol_types::SolCall for renounceRoleCall {
3124 type Parameters<'a> = (
3125 alloy::sol_types::sol_data::FixedBytes<32>,
3126 alloy::sol_types::sol_data::Address,
3127 );
3128 type Token<'a> = <Self::Parameters<
3129 'a,
3130 > as alloy_sol_types::SolType>::Token<'a>;
3131 type Return = renounceRoleReturn;
3132 type ReturnTuple<'a> = ();
3133 type ReturnToken<'a> = <Self::ReturnTuple<
3134 'a,
3135 > as alloy_sol_types::SolType>::Token<'a>;
3136 const SIGNATURE: &'static str = "renounceRole(bytes32,address)";
3137 const SELECTOR: [u8; 4] = [54u8, 86u8, 138u8, 190u8];
3138 #[inline]
3139 fn new<'a>(
3140 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3141 ) -> Self {
3142 tuple.into()
3143 }
3144 #[inline]
3145 fn tokenize(&self) -> Self::Token<'_> {
3146 (
3147 <alloy::sol_types::sol_data::FixedBytes<
3148 32,
3149 > as alloy_sol_types::SolType>::tokenize(&self.role),
3150 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3151 &self.account,
3152 ),
3153 )
3154 }
3155 #[inline]
3156 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3157 renounceRoleReturn::_tokenize(ret)
3158 }
3159 #[inline]
3160 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3161 <Self::ReturnTuple<
3162 '_,
3163 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3164 .map(Into::into)
3165 }
3166 #[inline]
3167 fn abi_decode_returns_validate(
3168 data: &[u8],
3169 ) -> alloy_sol_types::Result<Self::Return> {
3170 <Self::ReturnTuple<
3171 '_,
3172 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3173 .map(Into::into)
3174 }
3175 }
3176 };
3177 #[derive(serde::Serialize, serde::Deserialize)]
3178 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3179 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3184 #[derive(Clone)]
3185 pub struct revokeRoleCall {
3186 #[allow(missing_docs)]
3187 pub role: alloy::sol_types::private::FixedBytes<32>,
3188 #[allow(missing_docs)]
3189 pub account: alloy::sol_types::private::Address,
3190 }
3191 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3193 #[derive(Clone)]
3194 pub struct revokeRoleReturn {}
3195 #[allow(
3196 non_camel_case_types,
3197 non_snake_case,
3198 clippy::pub_underscore_fields,
3199 clippy::style
3200 )]
3201 const _: () = {
3202 use alloy::sol_types as alloy_sol_types;
3203 {
3204 #[doc(hidden)]
3205 type UnderlyingSolTuple<'a> = (
3206 alloy::sol_types::sol_data::FixedBytes<32>,
3207 alloy::sol_types::sol_data::Address,
3208 );
3209 #[doc(hidden)]
3210 type UnderlyingRustTuple<'a> = (
3211 alloy::sol_types::private::FixedBytes<32>,
3212 alloy::sol_types::private::Address,
3213 );
3214 #[cfg(test)]
3215 #[allow(dead_code, unreachable_patterns)]
3216 fn _type_assertion(
3217 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3218 ) {
3219 match _t {
3220 alloy_sol_types::private::AssertTypeEq::<
3221 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3222 >(_) => {}
3223 }
3224 }
3225 #[automatically_derived]
3226 #[doc(hidden)]
3227 impl ::core::convert::From<revokeRoleCall> for UnderlyingRustTuple<'_> {
3228 fn from(value: revokeRoleCall) -> Self {
3229 (value.role, value.account)
3230 }
3231 }
3232 #[automatically_derived]
3233 #[doc(hidden)]
3234 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleCall {
3235 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3236 Self {
3237 role: tuple.0,
3238 account: tuple.1,
3239 }
3240 }
3241 }
3242 }
3243 {
3244 #[doc(hidden)]
3245 type UnderlyingSolTuple<'a> = ();
3246 #[doc(hidden)]
3247 type UnderlyingRustTuple<'a> = ();
3248 #[cfg(test)]
3249 #[allow(dead_code, unreachable_patterns)]
3250 fn _type_assertion(
3251 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3252 ) {
3253 match _t {
3254 alloy_sol_types::private::AssertTypeEq::<
3255 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3256 >(_) => {}
3257 }
3258 }
3259 #[automatically_derived]
3260 #[doc(hidden)]
3261 impl ::core::convert::From<revokeRoleReturn> for UnderlyingRustTuple<'_> {
3262 fn from(value: revokeRoleReturn) -> Self {
3263 ()
3264 }
3265 }
3266 #[automatically_derived]
3267 #[doc(hidden)]
3268 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleReturn {
3269 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3270 Self {}
3271 }
3272 }
3273 }
3274 impl revokeRoleReturn {
3275 fn _tokenize(
3276 &self,
3277 ) -> <revokeRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3278 ()
3279 }
3280 }
3281 #[automatically_derived]
3282 impl alloy_sol_types::SolCall for revokeRoleCall {
3283 type Parameters<'a> = (
3284 alloy::sol_types::sol_data::FixedBytes<32>,
3285 alloy::sol_types::sol_data::Address,
3286 );
3287 type Token<'a> = <Self::Parameters<
3288 'a,
3289 > as alloy_sol_types::SolType>::Token<'a>;
3290 type Return = revokeRoleReturn;
3291 type ReturnTuple<'a> = ();
3292 type ReturnToken<'a> = <Self::ReturnTuple<
3293 'a,
3294 > as alloy_sol_types::SolType>::Token<'a>;
3295 const SIGNATURE: &'static str = "revokeRole(bytes32,address)";
3296 const SELECTOR: [u8; 4] = [213u8, 71u8, 116u8, 31u8];
3297 #[inline]
3298 fn new<'a>(
3299 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3300 ) -> Self {
3301 tuple.into()
3302 }
3303 #[inline]
3304 fn tokenize(&self) -> Self::Token<'_> {
3305 (
3306 <alloy::sol_types::sol_data::FixedBytes<
3307 32,
3308 > as alloy_sol_types::SolType>::tokenize(&self.role),
3309 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3310 &self.account,
3311 ),
3312 )
3313 }
3314 #[inline]
3315 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3316 revokeRoleReturn::_tokenize(ret)
3317 }
3318 #[inline]
3319 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3320 <Self::ReturnTuple<
3321 '_,
3322 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3323 .map(Into::into)
3324 }
3325 #[inline]
3326 fn abi_decode_returns_validate(
3327 data: &[u8],
3328 ) -> alloy_sol_types::Result<Self::Return> {
3329 <Self::ReturnTuple<
3330 '_,
3331 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3332 .map(Into::into)
3333 }
3334 }
3335 };
3336 #[derive(serde::Serialize, serde::Deserialize)]
3337 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3338 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3343 #[derive(Clone)]
3344 pub struct snapshotBlockNumberCall;
3345 #[derive(serde::Serialize, serde::Deserialize)]
3346 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3347 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3349 #[derive(Clone)]
3350 pub struct snapshotBlockNumberReturn {
3351 #[allow(missing_docs)]
3352 pub _0: u128,
3353 }
3354 #[allow(
3355 non_camel_case_types,
3356 non_snake_case,
3357 clippy::pub_underscore_fields,
3358 clippy::style
3359 )]
3360 const _: () = {
3361 use alloy::sol_types as alloy_sol_types;
3362 {
3363 #[doc(hidden)]
3364 type UnderlyingSolTuple<'a> = ();
3365 #[doc(hidden)]
3366 type UnderlyingRustTuple<'a> = ();
3367 #[cfg(test)]
3368 #[allow(dead_code, unreachable_patterns)]
3369 fn _type_assertion(
3370 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3371 ) {
3372 match _t {
3373 alloy_sol_types::private::AssertTypeEq::<
3374 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3375 >(_) => {}
3376 }
3377 }
3378 #[automatically_derived]
3379 #[doc(hidden)]
3380 impl ::core::convert::From<snapshotBlockNumberCall>
3381 for UnderlyingRustTuple<'_> {
3382 fn from(value: snapshotBlockNumberCall) -> Self {
3383 ()
3384 }
3385 }
3386 #[automatically_derived]
3387 #[doc(hidden)]
3388 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3389 for snapshotBlockNumberCall {
3390 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3391 Self
3392 }
3393 }
3394 }
3395 {
3396 #[doc(hidden)]
3397 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<128>,);
3398 #[doc(hidden)]
3399 type UnderlyingRustTuple<'a> = (u128,);
3400 #[cfg(test)]
3401 #[allow(dead_code, unreachable_patterns)]
3402 fn _type_assertion(
3403 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3404 ) {
3405 match _t {
3406 alloy_sol_types::private::AssertTypeEq::<
3407 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3408 >(_) => {}
3409 }
3410 }
3411 #[automatically_derived]
3412 #[doc(hidden)]
3413 impl ::core::convert::From<snapshotBlockNumberReturn>
3414 for UnderlyingRustTuple<'_> {
3415 fn from(value: snapshotBlockNumberReturn) -> Self {
3416 (value._0,)
3417 }
3418 }
3419 #[automatically_derived]
3420 #[doc(hidden)]
3421 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3422 for snapshotBlockNumberReturn {
3423 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3424 Self { _0: tuple.0 }
3425 }
3426 }
3427 }
3428 #[automatically_derived]
3429 impl alloy_sol_types::SolCall for snapshotBlockNumberCall {
3430 type Parameters<'a> = ();
3431 type Token<'a> = <Self::Parameters<
3432 'a,
3433 > as alloy_sol_types::SolType>::Token<'a>;
3434 type Return = u128;
3435 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<128>,);
3436 type ReturnToken<'a> = <Self::ReturnTuple<
3437 'a,
3438 > as alloy_sol_types::SolType>::Token<'a>;
3439 const SIGNATURE: &'static str = "snapshotBlockNumber()";
3440 const SELECTOR: [u8; 4] = [242u8, 94u8, 113u8, 8u8];
3441 #[inline]
3442 fn new<'a>(
3443 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3444 ) -> Self {
3445 tuple.into()
3446 }
3447 #[inline]
3448 fn tokenize(&self) -> Self::Token<'_> {
3449 ()
3450 }
3451 #[inline]
3452 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3453 (
3454 <alloy::sol_types::sol_data::Uint<
3455 128,
3456 > as alloy_sol_types::SolType>::tokenize(ret),
3457 )
3458 }
3459 #[inline]
3460 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3461 <Self::ReturnTuple<
3462 '_,
3463 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3464 .map(|r| {
3465 let r: snapshotBlockNumberReturn = r.into();
3466 r._0
3467 })
3468 }
3469 #[inline]
3470 fn abi_decode_returns_validate(
3471 data: &[u8],
3472 ) -> alloy_sol_types::Result<Self::Return> {
3473 <Self::ReturnTuple<
3474 '_,
3475 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3476 .map(|r| {
3477 let r: snapshotBlockNumberReturn = r.into();
3478 r._0
3479 })
3480 }
3481 }
3482 };
3483 #[derive(serde::Serialize, serde::Deserialize)]
3484 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3485 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3490 #[derive(Clone)]
3491 pub struct stakeThresholdCall;
3492 #[derive(serde::Serialize, serde::Deserialize)]
3493 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3494 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3496 #[derive(Clone)]
3497 pub struct stakeThresholdReturn {
3498 #[allow(missing_docs)]
3499 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3500 }
3501 #[allow(
3502 non_camel_case_types,
3503 non_snake_case,
3504 clippy::pub_underscore_fields,
3505 clippy::style
3506 )]
3507 const _: () = {
3508 use alloy::sol_types as alloy_sol_types;
3509 {
3510 #[doc(hidden)]
3511 type UnderlyingSolTuple<'a> = ();
3512 #[doc(hidden)]
3513 type UnderlyingRustTuple<'a> = ();
3514 #[cfg(test)]
3515 #[allow(dead_code, unreachable_patterns)]
3516 fn _type_assertion(
3517 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3518 ) {
3519 match _t {
3520 alloy_sol_types::private::AssertTypeEq::<
3521 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3522 >(_) => {}
3523 }
3524 }
3525 #[automatically_derived]
3526 #[doc(hidden)]
3527 impl ::core::convert::From<stakeThresholdCall> for UnderlyingRustTuple<'_> {
3528 fn from(value: stakeThresholdCall) -> Self {
3529 ()
3530 }
3531 }
3532 #[automatically_derived]
3533 #[doc(hidden)]
3534 impl ::core::convert::From<UnderlyingRustTuple<'_>> for stakeThresholdCall {
3535 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3536 Self
3537 }
3538 }
3539 }
3540 {
3541 #[doc(hidden)]
3542 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3543 #[doc(hidden)]
3544 type UnderlyingRustTuple<'a> = (
3545 alloy::sol_types::private::primitives::aliases::U256,
3546 );
3547 #[cfg(test)]
3548 #[allow(dead_code, unreachable_patterns)]
3549 fn _type_assertion(
3550 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3551 ) {
3552 match _t {
3553 alloy_sol_types::private::AssertTypeEq::<
3554 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3555 >(_) => {}
3556 }
3557 }
3558 #[automatically_derived]
3559 #[doc(hidden)]
3560 impl ::core::convert::From<stakeThresholdReturn>
3561 for UnderlyingRustTuple<'_> {
3562 fn from(value: stakeThresholdReturn) -> Self {
3563 (value._0,)
3564 }
3565 }
3566 #[automatically_derived]
3567 #[doc(hidden)]
3568 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3569 for stakeThresholdReturn {
3570 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3571 Self { _0: tuple.0 }
3572 }
3573 }
3574 }
3575 #[automatically_derived]
3576 impl alloy_sol_types::SolCall for stakeThresholdCall {
3577 type Parameters<'a> = ();
3578 type Token<'a> = <Self::Parameters<
3579 'a,
3580 > as alloy_sol_types::SolType>::Token<'a>;
3581 type Return = alloy::sol_types::private::primitives::aliases::U256;
3582 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3583 type ReturnToken<'a> = <Self::ReturnTuple<
3584 'a,
3585 > as alloy_sol_types::SolType>::Token<'a>;
3586 const SIGNATURE: &'static str = "stakeThreshold()";
3587 const SELECTOR: [u8; 4] = [241u8, 31u8, 119u8, 249u8];
3588 #[inline]
3589 fn new<'a>(
3590 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3591 ) -> Self {
3592 tuple.into()
3593 }
3594 #[inline]
3595 fn tokenize(&self) -> Self::Token<'_> {
3596 ()
3597 }
3598 #[inline]
3599 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3600 (
3601 <alloy::sol_types::sol_data::Uint<
3602 256,
3603 > as alloy_sol_types::SolType>::tokenize(ret),
3604 )
3605 }
3606 #[inline]
3607 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3608 <Self::ReturnTuple<
3609 '_,
3610 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3611 .map(|r| {
3612 let r: stakeThresholdReturn = r.into();
3613 r._0
3614 })
3615 }
3616 #[inline]
3617 fn abi_decode_returns_validate(
3618 data: &[u8],
3619 ) -> alloy_sol_types::Result<Self::Return> {
3620 <Self::ReturnTuple<
3621 '_,
3622 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3623 .map(|r| {
3624 let r: stakeThresholdReturn = r.into();
3625 r._0
3626 })
3627 }
3628 }
3629 };
3630 #[derive(serde::Serialize, serde::Deserialize)]
3631 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3632 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3637 #[derive(Clone)]
3638 pub struct supportsInterfaceCall {
3639 #[allow(missing_docs)]
3640 pub interfaceId: alloy::sol_types::private::FixedBytes<4>,
3641 }
3642 #[derive(serde::Serialize, serde::Deserialize)]
3643 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3644 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3646 #[derive(Clone)]
3647 pub struct supportsInterfaceReturn {
3648 #[allow(missing_docs)]
3649 pub _0: bool,
3650 }
3651 #[allow(
3652 non_camel_case_types,
3653 non_snake_case,
3654 clippy::pub_underscore_fields,
3655 clippy::style
3656 )]
3657 const _: () = {
3658 use alloy::sol_types as alloy_sol_types;
3659 {
3660 #[doc(hidden)]
3661 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3662 #[doc(hidden)]
3663 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3664 #[cfg(test)]
3665 #[allow(dead_code, unreachable_patterns)]
3666 fn _type_assertion(
3667 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3668 ) {
3669 match _t {
3670 alloy_sol_types::private::AssertTypeEq::<
3671 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3672 >(_) => {}
3673 }
3674 }
3675 #[automatically_derived]
3676 #[doc(hidden)]
3677 impl ::core::convert::From<supportsInterfaceCall>
3678 for UnderlyingRustTuple<'_> {
3679 fn from(value: supportsInterfaceCall) -> Self {
3680 (value.interfaceId,)
3681 }
3682 }
3683 #[automatically_derived]
3684 #[doc(hidden)]
3685 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3686 for supportsInterfaceCall {
3687 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3688 Self { interfaceId: tuple.0 }
3689 }
3690 }
3691 }
3692 {
3693 #[doc(hidden)]
3694 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3695 #[doc(hidden)]
3696 type UnderlyingRustTuple<'a> = (bool,);
3697 #[cfg(test)]
3698 #[allow(dead_code, unreachable_patterns)]
3699 fn _type_assertion(
3700 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3701 ) {
3702 match _t {
3703 alloy_sol_types::private::AssertTypeEq::<
3704 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3705 >(_) => {}
3706 }
3707 }
3708 #[automatically_derived]
3709 #[doc(hidden)]
3710 impl ::core::convert::From<supportsInterfaceReturn>
3711 for UnderlyingRustTuple<'_> {
3712 fn from(value: supportsInterfaceReturn) -> Self {
3713 (value._0,)
3714 }
3715 }
3716 #[automatically_derived]
3717 #[doc(hidden)]
3718 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3719 for supportsInterfaceReturn {
3720 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3721 Self { _0: tuple.0 }
3722 }
3723 }
3724 }
3725 #[automatically_derived]
3726 impl alloy_sol_types::SolCall for supportsInterfaceCall {
3727 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3728 type Token<'a> = <Self::Parameters<
3729 'a,
3730 > as alloy_sol_types::SolType>::Token<'a>;
3731 type Return = bool;
3732 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3733 type ReturnToken<'a> = <Self::ReturnTuple<
3734 'a,
3735 > as alloy_sol_types::SolType>::Token<'a>;
3736 const SIGNATURE: &'static str = "supportsInterface(bytes4)";
3737 const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
3738 #[inline]
3739 fn new<'a>(
3740 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3741 ) -> Self {
3742 tuple.into()
3743 }
3744 #[inline]
3745 fn tokenize(&self) -> Self::Token<'_> {
3746 (
3747 <alloy::sol_types::sol_data::FixedBytes<
3748 4,
3749 > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
3750 )
3751 }
3752 #[inline]
3753 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3754 (
3755 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
3756 ret,
3757 ),
3758 )
3759 }
3760 #[inline]
3761 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3762 <Self::ReturnTuple<
3763 '_,
3764 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3765 .map(|r| {
3766 let r: supportsInterfaceReturn = r.into();
3767 r._0
3768 })
3769 }
3770 #[inline]
3771 fn abi_decode_returns_validate(
3772 data: &[u8],
3773 ) -> alloy_sol_types::Result<Self::Return> {
3774 <Self::ReturnTuple<
3775 '_,
3776 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3777 .map(|r| {
3778 let r: supportsInterfaceReturn = r.into();
3779 r._0
3780 })
3781 }
3782 }
3783 };
3784 #[derive(serde::Serialize, serde::Deserialize)]
3785 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3786 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3791 #[derive(Clone)]
3792 pub struct tokenCall;
3793 #[derive(serde::Serialize, serde::Deserialize)]
3794 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3795 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3797 #[derive(Clone)]
3798 pub struct tokenReturn {
3799 #[allow(missing_docs)]
3800 pub _0: alloy::sol_types::private::Address,
3801 }
3802 #[allow(
3803 non_camel_case_types,
3804 non_snake_case,
3805 clippy::pub_underscore_fields,
3806 clippy::style
3807 )]
3808 const _: () = {
3809 use alloy::sol_types as alloy_sol_types;
3810 {
3811 #[doc(hidden)]
3812 type UnderlyingSolTuple<'a> = ();
3813 #[doc(hidden)]
3814 type UnderlyingRustTuple<'a> = ();
3815 #[cfg(test)]
3816 #[allow(dead_code, unreachable_patterns)]
3817 fn _type_assertion(
3818 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3819 ) {
3820 match _t {
3821 alloy_sol_types::private::AssertTypeEq::<
3822 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3823 >(_) => {}
3824 }
3825 }
3826 #[automatically_derived]
3827 #[doc(hidden)]
3828 impl ::core::convert::From<tokenCall> for UnderlyingRustTuple<'_> {
3829 fn from(value: tokenCall) -> Self {
3830 ()
3831 }
3832 }
3833 #[automatically_derived]
3834 #[doc(hidden)]
3835 impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenCall {
3836 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3837 Self
3838 }
3839 }
3840 }
3841 {
3842 #[doc(hidden)]
3843 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3844 #[doc(hidden)]
3845 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3846 #[cfg(test)]
3847 #[allow(dead_code, unreachable_patterns)]
3848 fn _type_assertion(
3849 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3850 ) {
3851 match _t {
3852 alloy_sol_types::private::AssertTypeEq::<
3853 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3854 >(_) => {}
3855 }
3856 }
3857 #[automatically_derived]
3858 #[doc(hidden)]
3859 impl ::core::convert::From<tokenReturn> for UnderlyingRustTuple<'_> {
3860 fn from(value: tokenReturn) -> Self {
3861 (value._0,)
3862 }
3863 }
3864 #[automatically_derived]
3865 #[doc(hidden)]
3866 impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenReturn {
3867 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3868 Self { _0: tuple.0 }
3869 }
3870 }
3871 }
3872 #[automatically_derived]
3873 impl alloy_sol_types::SolCall for tokenCall {
3874 type Parameters<'a> = ();
3875 type Token<'a> = <Self::Parameters<
3876 'a,
3877 > as alloy_sol_types::SolType>::Token<'a>;
3878 type Return = alloy::sol_types::private::Address;
3879 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3880 type ReturnToken<'a> = <Self::ReturnTuple<
3881 'a,
3882 > as alloy_sol_types::SolType>::Token<'a>;
3883 const SIGNATURE: &'static str = "token()";
3884 const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8];
3885 #[inline]
3886 fn new<'a>(
3887 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3888 ) -> Self {
3889 tuple.into()
3890 }
3891 #[inline]
3892 fn tokenize(&self) -> Self::Token<'_> {
3893 ()
3894 }
3895 #[inline]
3896 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3897 (
3898 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3899 ret,
3900 ),
3901 )
3902 }
3903 #[inline]
3904 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3905 <Self::ReturnTuple<
3906 '_,
3907 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3908 .map(|r| {
3909 let r: tokenReturn = r.into();
3910 r._0
3911 })
3912 }
3913 #[inline]
3914 fn abi_decode_returns_validate(
3915 data: &[u8],
3916 ) -> alloy_sol_types::Result<Self::Return> {
3917 <Self::ReturnTuple<
3918 '_,
3919 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3920 .map(|r| {
3921 let r: tokenReturn = r.into();
3922 r._0
3923 })
3924 }
3925 }
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)]
3934 #[derive(Clone)]
3935 pub struct updateSnapshotBlockNumberCall {
3936 #[allow(missing_docs)]
3937 pub newSnapshotBlock: u128,
3938 }
3939 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3941 #[derive(Clone)]
3942 pub struct updateSnapshotBlockNumberReturn {}
3943 #[allow(
3944 non_camel_case_types,
3945 non_snake_case,
3946 clippy::pub_underscore_fields,
3947 clippy::style
3948 )]
3949 const _: () = {
3950 use alloy::sol_types as alloy_sol_types;
3951 {
3952 #[doc(hidden)]
3953 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<128>,);
3954 #[doc(hidden)]
3955 type UnderlyingRustTuple<'a> = (u128,);
3956 #[cfg(test)]
3957 #[allow(dead_code, unreachable_patterns)]
3958 fn _type_assertion(
3959 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3960 ) {
3961 match _t {
3962 alloy_sol_types::private::AssertTypeEq::<
3963 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3964 >(_) => {}
3965 }
3966 }
3967 #[automatically_derived]
3968 #[doc(hidden)]
3969 impl ::core::convert::From<updateSnapshotBlockNumberCall>
3970 for UnderlyingRustTuple<'_> {
3971 fn from(value: updateSnapshotBlockNumberCall) -> Self {
3972 (value.newSnapshotBlock,)
3973 }
3974 }
3975 #[automatically_derived]
3976 #[doc(hidden)]
3977 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3978 for updateSnapshotBlockNumberCall {
3979 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3980 Self { newSnapshotBlock: tuple.0 }
3981 }
3982 }
3983 }
3984 {
3985 #[doc(hidden)]
3986 type UnderlyingSolTuple<'a> = ();
3987 #[doc(hidden)]
3988 type UnderlyingRustTuple<'a> = ();
3989 #[cfg(test)]
3990 #[allow(dead_code, unreachable_patterns)]
3991 fn _type_assertion(
3992 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3993 ) {
3994 match _t {
3995 alloy_sol_types::private::AssertTypeEq::<
3996 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3997 >(_) => {}
3998 }
3999 }
4000 #[automatically_derived]
4001 #[doc(hidden)]
4002 impl ::core::convert::From<updateSnapshotBlockNumberReturn>
4003 for UnderlyingRustTuple<'_> {
4004 fn from(value: updateSnapshotBlockNumberReturn) -> Self {
4005 ()
4006 }
4007 }
4008 #[automatically_derived]
4009 #[doc(hidden)]
4010 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4011 for updateSnapshotBlockNumberReturn {
4012 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4013 Self {}
4014 }
4015 }
4016 }
4017 impl updateSnapshotBlockNumberReturn {
4018 fn _tokenize(
4019 &self,
4020 ) -> <updateSnapshotBlockNumberCall as alloy_sol_types::SolCall>::ReturnToken<
4021 '_,
4022 > {
4023 ()
4024 }
4025 }
4026 #[automatically_derived]
4027 impl alloy_sol_types::SolCall for updateSnapshotBlockNumberCall {
4028 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<128>,);
4029 type Token<'a> = <Self::Parameters<
4030 'a,
4031 > as alloy_sol_types::SolType>::Token<'a>;
4032 type Return = updateSnapshotBlockNumberReturn;
4033 type ReturnTuple<'a> = ();
4034 type ReturnToken<'a> = <Self::ReturnTuple<
4035 'a,
4036 > as alloy_sol_types::SolType>::Token<'a>;
4037 const SIGNATURE: &'static str = "updateSnapshotBlockNumber(uint128)";
4038 const SELECTOR: [u8; 4] = [90u8, 190u8, 83u8, 8u8];
4039 #[inline]
4040 fn new<'a>(
4041 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4042 ) -> Self {
4043 tuple.into()
4044 }
4045 #[inline]
4046 fn tokenize(&self) -> Self::Token<'_> {
4047 (
4048 <alloy::sol_types::sol_data::Uint<
4049 128,
4050 > as alloy_sol_types::SolType>::tokenize(&self.newSnapshotBlock),
4051 )
4052 }
4053 #[inline]
4054 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4055 updateSnapshotBlockNumberReturn::_tokenize(ret)
4056 }
4057 #[inline]
4058 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4059 <Self::ReturnTuple<
4060 '_,
4061 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4062 .map(Into::into)
4063 }
4064 #[inline]
4065 fn abi_decode_returns_validate(
4066 data: &[u8],
4067 ) -> alloy_sol_types::Result<Self::Return> {
4068 <Self::ReturnTuple<
4069 '_,
4070 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4071 .map(Into::into)
4072 }
4073 }
4074 };
4075 #[derive(serde::Serialize, serde::Deserialize)]
4076 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4077 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4082 #[derive(Clone)]
4083 pub struct updateStakeThresholdCall {
4084 #[allow(missing_docs)]
4085 pub newThreshold: alloy::sol_types::private::primitives::aliases::U256,
4086 }
4087 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4089 #[derive(Clone)]
4090 pub struct updateStakeThresholdReturn {}
4091 #[allow(
4092 non_camel_case_types,
4093 non_snake_case,
4094 clippy::pub_underscore_fields,
4095 clippy::style
4096 )]
4097 const _: () = {
4098 use alloy::sol_types as alloy_sol_types;
4099 {
4100 #[doc(hidden)]
4101 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4102 #[doc(hidden)]
4103 type UnderlyingRustTuple<'a> = (
4104 alloy::sol_types::private::primitives::aliases::U256,
4105 );
4106 #[cfg(test)]
4107 #[allow(dead_code, unreachable_patterns)]
4108 fn _type_assertion(
4109 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4110 ) {
4111 match _t {
4112 alloy_sol_types::private::AssertTypeEq::<
4113 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4114 >(_) => {}
4115 }
4116 }
4117 #[automatically_derived]
4118 #[doc(hidden)]
4119 impl ::core::convert::From<updateStakeThresholdCall>
4120 for UnderlyingRustTuple<'_> {
4121 fn from(value: updateStakeThresholdCall) -> Self {
4122 (value.newThreshold,)
4123 }
4124 }
4125 #[automatically_derived]
4126 #[doc(hidden)]
4127 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4128 for updateStakeThresholdCall {
4129 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4130 Self { newThreshold: tuple.0 }
4131 }
4132 }
4133 }
4134 {
4135 #[doc(hidden)]
4136 type UnderlyingSolTuple<'a> = ();
4137 #[doc(hidden)]
4138 type UnderlyingRustTuple<'a> = ();
4139 #[cfg(test)]
4140 #[allow(dead_code, unreachable_patterns)]
4141 fn _type_assertion(
4142 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4143 ) {
4144 match _t {
4145 alloy_sol_types::private::AssertTypeEq::<
4146 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4147 >(_) => {}
4148 }
4149 }
4150 #[automatically_derived]
4151 #[doc(hidden)]
4152 impl ::core::convert::From<updateStakeThresholdReturn>
4153 for UnderlyingRustTuple<'_> {
4154 fn from(value: updateStakeThresholdReturn) -> Self {
4155 ()
4156 }
4157 }
4158 #[automatically_derived]
4159 #[doc(hidden)]
4160 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4161 for updateStakeThresholdReturn {
4162 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4163 Self {}
4164 }
4165 }
4166 }
4167 impl updateStakeThresholdReturn {
4168 fn _tokenize(
4169 &self,
4170 ) -> <updateStakeThresholdCall as alloy_sol_types::SolCall>::ReturnToken<
4171 '_,
4172 > {
4173 ()
4174 }
4175 }
4176 #[automatically_derived]
4177 impl alloy_sol_types::SolCall for updateStakeThresholdCall {
4178 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4179 type Token<'a> = <Self::Parameters<
4180 'a,
4181 > as alloy_sol_types::SolType>::Token<'a>;
4182 type Return = updateStakeThresholdReturn;
4183 type ReturnTuple<'a> = ();
4184 type ReturnToken<'a> = <Self::ReturnTuple<
4185 'a,
4186 > as alloy_sol_types::SolType>::Token<'a>;
4187 const SIGNATURE: &'static str = "updateStakeThreshold(uint256)";
4188 const SELECTOR: [u8; 4] = [94u8, 245u8, 51u8, 41u8];
4189 #[inline]
4190 fn new<'a>(
4191 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4192 ) -> Self {
4193 tuple.into()
4194 }
4195 #[inline]
4196 fn tokenize(&self) -> Self::Token<'_> {
4197 (
4198 <alloy::sol_types::sol_data::Uint<
4199 256,
4200 > as alloy_sol_types::SolType>::tokenize(&self.newThreshold),
4201 )
4202 }
4203 #[inline]
4204 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4205 updateStakeThresholdReturn::_tokenize(ret)
4206 }
4207 #[inline]
4208 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4209 <Self::ReturnTuple<
4210 '_,
4211 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4212 .map(Into::into)
4213 }
4214 #[inline]
4215 fn abi_decode_returns_validate(
4216 data: &[u8],
4217 ) -> alloy_sol_types::Result<Self::Return> {
4218 <Self::ReturnTuple<
4219 '_,
4220 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4221 .map(Into::into)
4222 }
4223 }
4224 };
4225 #[derive(serde::Serialize, serde::Deserialize)]
4227 #[derive()]
4228 pub enum HoprSafeProxyForNetworkRegistryCalls {
4229 #[allow(missing_docs)]
4230 DEFAULT_ADMIN_ROLE(DEFAULT_ADMIN_ROLECall),
4231 #[allow(missing_docs)]
4232 MANAGER_ROLE(MANAGER_ROLECall),
4233 #[allow(missing_docs)]
4234 canOperateFor(canOperateForCall),
4235 #[allow(missing_docs)]
4236 getRoleAdmin(getRoleAdminCall),
4237 #[allow(missing_docs)]
4238 getRoleMember(getRoleMemberCall),
4239 #[allow(missing_docs)]
4240 getRoleMemberCount(getRoleMemberCountCall),
4241 #[allow(missing_docs)]
4242 grantRole(grantRoleCall),
4243 #[allow(missing_docs)]
4244 hasRole(hasRoleCall),
4245 #[allow(missing_docs)]
4246 maxAllowedRegistrations(maxAllowedRegistrationsCall),
4247 #[allow(missing_docs)]
4248 nodeSafeRegistry(nodeSafeRegistryCall),
4249 #[allow(missing_docs)]
4250 renounceRole(renounceRoleCall),
4251 #[allow(missing_docs)]
4252 revokeRole(revokeRoleCall),
4253 #[allow(missing_docs)]
4254 snapshotBlockNumber(snapshotBlockNumberCall),
4255 #[allow(missing_docs)]
4256 stakeThreshold(stakeThresholdCall),
4257 #[allow(missing_docs)]
4258 supportsInterface(supportsInterfaceCall),
4259 #[allow(missing_docs)]
4260 token(tokenCall),
4261 #[allow(missing_docs)]
4262 updateSnapshotBlockNumber(updateSnapshotBlockNumberCall),
4263 #[allow(missing_docs)]
4264 updateStakeThreshold(updateStakeThresholdCall),
4265 }
4266 #[automatically_derived]
4267 impl HoprSafeProxyForNetworkRegistryCalls {
4268 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4275 [1u8, 255u8, 201u8, 167u8],
4276 [36u8, 138u8, 156u8, 163u8],
4277 [47u8, 47u8, 241u8, 93u8],
4278 [54u8, 86u8, 138u8, 190u8],
4279 [90u8, 190u8, 83u8, 8u8],
4280 [94u8, 245u8, 51u8, 41u8],
4281 [106u8, 74u8, 64u8, 65u8],
4282 [144u8, 16u8, 208u8, 124u8],
4283 [145u8, 209u8, 72u8, 84u8],
4284 [162u8, 23u8, 253u8, 223u8],
4285 [179u8, 84u8, 78u8, 130u8],
4286 [202u8, 21u8, 200u8, 115u8],
4287 [213u8, 71u8, 116u8, 31u8],
4288 [216u8, 90u8, 208u8, 68u8],
4289 [236u8, 135u8, 98u8, 28u8],
4290 [241u8, 31u8, 119u8, 249u8],
4291 [242u8, 94u8, 113u8, 8u8],
4292 [252u8, 12u8, 84u8, 106u8],
4293 ];
4294 }
4295 #[automatically_derived]
4296 impl alloy_sol_types::SolInterface for HoprSafeProxyForNetworkRegistryCalls {
4297 const NAME: &'static str = "HoprSafeProxyForNetworkRegistryCalls";
4298 const MIN_DATA_LENGTH: usize = 0usize;
4299 const COUNT: usize = 18usize;
4300 #[inline]
4301 fn selector(&self) -> [u8; 4] {
4302 match self {
4303 Self::DEFAULT_ADMIN_ROLE(_) => {
4304 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SELECTOR
4305 }
4306 Self::MANAGER_ROLE(_) => {
4307 <MANAGER_ROLECall as alloy_sol_types::SolCall>::SELECTOR
4308 }
4309 Self::canOperateFor(_) => {
4310 <canOperateForCall as alloy_sol_types::SolCall>::SELECTOR
4311 }
4312 Self::getRoleAdmin(_) => {
4313 <getRoleAdminCall as alloy_sol_types::SolCall>::SELECTOR
4314 }
4315 Self::getRoleMember(_) => {
4316 <getRoleMemberCall as alloy_sol_types::SolCall>::SELECTOR
4317 }
4318 Self::getRoleMemberCount(_) => {
4319 <getRoleMemberCountCall as alloy_sol_types::SolCall>::SELECTOR
4320 }
4321 Self::grantRole(_) => {
4322 <grantRoleCall as alloy_sol_types::SolCall>::SELECTOR
4323 }
4324 Self::hasRole(_) => <hasRoleCall as alloy_sol_types::SolCall>::SELECTOR,
4325 Self::maxAllowedRegistrations(_) => {
4326 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::SELECTOR
4327 }
4328 Self::nodeSafeRegistry(_) => {
4329 <nodeSafeRegistryCall as alloy_sol_types::SolCall>::SELECTOR
4330 }
4331 Self::renounceRole(_) => {
4332 <renounceRoleCall as alloy_sol_types::SolCall>::SELECTOR
4333 }
4334 Self::revokeRole(_) => {
4335 <revokeRoleCall as alloy_sol_types::SolCall>::SELECTOR
4336 }
4337 Self::snapshotBlockNumber(_) => {
4338 <snapshotBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
4339 }
4340 Self::stakeThreshold(_) => {
4341 <stakeThresholdCall as alloy_sol_types::SolCall>::SELECTOR
4342 }
4343 Self::supportsInterface(_) => {
4344 <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
4345 }
4346 Self::token(_) => <tokenCall as alloy_sol_types::SolCall>::SELECTOR,
4347 Self::updateSnapshotBlockNumber(_) => {
4348 <updateSnapshotBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
4349 }
4350 Self::updateStakeThreshold(_) => {
4351 <updateStakeThresholdCall as alloy_sol_types::SolCall>::SELECTOR
4352 }
4353 }
4354 }
4355 #[inline]
4356 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4357 Self::SELECTORS.get(i).copied()
4358 }
4359 #[inline]
4360 fn valid_selector(selector: [u8; 4]) -> bool {
4361 Self::SELECTORS.binary_search(&selector).is_ok()
4362 }
4363 #[inline]
4364 #[allow(non_snake_case)]
4365 fn abi_decode_raw(
4366 selector: [u8; 4],
4367 data: &[u8],
4368 ) -> alloy_sol_types::Result<Self> {
4369 static DECODE_SHIMS: &[fn(
4370 &[u8],
4371 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls>] = &[
4372 {
4373 fn supportsInterface(
4374 data: &[u8],
4375 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4376 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(
4377 data,
4378 )
4379 .map(HoprSafeProxyForNetworkRegistryCalls::supportsInterface)
4380 }
4381 supportsInterface
4382 },
4383 {
4384 fn getRoleAdmin(
4385 data: &[u8],
4386 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4387 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4388 data,
4389 )
4390 .map(HoprSafeProxyForNetworkRegistryCalls::getRoleAdmin)
4391 }
4392 getRoleAdmin
4393 },
4394 {
4395 fn grantRole(
4396 data: &[u8],
4397 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4398 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4399 .map(HoprSafeProxyForNetworkRegistryCalls::grantRole)
4400 }
4401 grantRole
4402 },
4403 {
4404 fn renounceRole(
4405 data: &[u8],
4406 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4407 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
4408 data,
4409 )
4410 .map(HoprSafeProxyForNetworkRegistryCalls::renounceRole)
4411 }
4412 renounceRole
4413 },
4414 {
4415 fn updateSnapshotBlockNumber(
4416 data: &[u8],
4417 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4418 <updateSnapshotBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
4419 data,
4420 )
4421 .map(
4422 HoprSafeProxyForNetworkRegistryCalls::updateSnapshotBlockNumber,
4423 )
4424 }
4425 updateSnapshotBlockNumber
4426 },
4427 {
4428 fn updateStakeThreshold(
4429 data: &[u8],
4430 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4431 <updateStakeThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw(
4432 data,
4433 )
4434 .map(
4435 HoprSafeProxyForNetworkRegistryCalls::updateStakeThreshold,
4436 )
4437 }
4438 updateStakeThreshold
4439 },
4440 {
4441 fn nodeSafeRegistry(
4442 data: &[u8],
4443 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4444 <nodeSafeRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
4445 data,
4446 )
4447 .map(HoprSafeProxyForNetworkRegistryCalls::nodeSafeRegistry)
4448 }
4449 nodeSafeRegistry
4450 },
4451 {
4452 fn getRoleMember(
4453 data: &[u8],
4454 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4455 <getRoleMemberCall as alloy_sol_types::SolCall>::abi_decode_raw(
4456 data,
4457 )
4458 .map(HoprSafeProxyForNetworkRegistryCalls::getRoleMember)
4459 }
4460 getRoleMember
4461 },
4462 {
4463 fn hasRole(
4464 data: &[u8],
4465 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4466 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4467 .map(HoprSafeProxyForNetworkRegistryCalls::hasRole)
4468 }
4469 hasRole
4470 },
4471 {
4472 fn DEFAULT_ADMIN_ROLE(
4473 data: &[u8],
4474 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4475 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
4476 data,
4477 )
4478 .map(
4479 HoprSafeProxyForNetworkRegistryCalls::DEFAULT_ADMIN_ROLE,
4480 )
4481 }
4482 DEFAULT_ADMIN_ROLE
4483 },
4484 {
4485 fn maxAllowedRegistrations(
4486 data: &[u8],
4487 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4488 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
4489 data,
4490 )
4491 .map(
4492 HoprSafeProxyForNetworkRegistryCalls::maxAllowedRegistrations,
4493 )
4494 }
4495 maxAllowedRegistrations
4496 },
4497 {
4498 fn getRoleMemberCount(
4499 data: &[u8],
4500 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4501 <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw(
4502 data,
4503 )
4504 .map(
4505 HoprSafeProxyForNetworkRegistryCalls::getRoleMemberCount,
4506 )
4507 }
4508 getRoleMemberCount
4509 },
4510 {
4511 fn revokeRole(
4512 data: &[u8],
4513 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4514 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
4515 data,
4516 )
4517 .map(HoprSafeProxyForNetworkRegistryCalls::revokeRole)
4518 }
4519 revokeRole
4520 },
4521 {
4522 fn canOperateFor(
4523 data: &[u8],
4524 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4525 <canOperateForCall as alloy_sol_types::SolCall>::abi_decode_raw(
4526 data,
4527 )
4528 .map(HoprSafeProxyForNetworkRegistryCalls::canOperateFor)
4529 }
4530 canOperateFor
4531 },
4532 {
4533 fn MANAGER_ROLE(
4534 data: &[u8],
4535 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4536 <MANAGER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
4537 data,
4538 )
4539 .map(HoprSafeProxyForNetworkRegistryCalls::MANAGER_ROLE)
4540 }
4541 MANAGER_ROLE
4542 },
4543 {
4544 fn stakeThreshold(
4545 data: &[u8],
4546 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4547 <stakeThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw(
4548 data,
4549 )
4550 .map(HoprSafeProxyForNetworkRegistryCalls::stakeThreshold)
4551 }
4552 stakeThreshold
4553 },
4554 {
4555 fn snapshotBlockNumber(
4556 data: &[u8],
4557 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4558 <snapshotBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
4559 data,
4560 )
4561 .map(
4562 HoprSafeProxyForNetworkRegistryCalls::snapshotBlockNumber,
4563 )
4564 }
4565 snapshotBlockNumber
4566 },
4567 {
4568 fn token(
4569 data: &[u8],
4570 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4571 <tokenCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4572 .map(HoprSafeProxyForNetworkRegistryCalls::token)
4573 }
4574 token
4575 },
4576 ];
4577 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4578 return Err(
4579 alloy_sol_types::Error::unknown_selector(
4580 <Self as alloy_sol_types::SolInterface>::NAME,
4581 selector,
4582 ),
4583 );
4584 };
4585 DECODE_SHIMS[idx](data)
4586 }
4587 #[inline]
4588 #[allow(non_snake_case)]
4589 fn abi_decode_raw_validate(
4590 selector: [u8; 4],
4591 data: &[u8],
4592 ) -> alloy_sol_types::Result<Self> {
4593 static DECODE_VALIDATE_SHIMS: &[fn(
4594 &[u8],
4595 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls>] = &[
4596 {
4597 fn supportsInterface(
4598 data: &[u8],
4599 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4600 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4601 data,
4602 )
4603 .map(HoprSafeProxyForNetworkRegistryCalls::supportsInterface)
4604 }
4605 supportsInterface
4606 },
4607 {
4608 fn getRoleAdmin(
4609 data: &[u8],
4610 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4611 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4612 data,
4613 )
4614 .map(HoprSafeProxyForNetworkRegistryCalls::getRoleAdmin)
4615 }
4616 getRoleAdmin
4617 },
4618 {
4619 fn grantRole(
4620 data: &[u8],
4621 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4622 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4623 data,
4624 )
4625 .map(HoprSafeProxyForNetworkRegistryCalls::grantRole)
4626 }
4627 grantRole
4628 },
4629 {
4630 fn renounceRole(
4631 data: &[u8],
4632 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4633 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4634 data,
4635 )
4636 .map(HoprSafeProxyForNetworkRegistryCalls::renounceRole)
4637 }
4638 renounceRole
4639 },
4640 {
4641 fn updateSnapshotBlockNumber(
4642 data: &[u8],
4643 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4644 <updateSnapshotBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4645 data,
4646 )
4647 .map(
4648 HoprSafeProxyForNetworkRegistryCalls::updateSnapshotBlockNumber,
4649 )
4650 }
4651 updateSnapshotBlockNumber
4652 },
4653 {
4654 fn updateStakeThreshold(
4655 data: &[u8],
4656 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4657 <updateStakeThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4658 data,
4659 )
4660 .map(
4661 HoprSafeProxyForNetworkRegistryCalls::updateStakeThreshold,
4662 )
4663 }
4664 updateStakeThreshold
4665 },
4666 {
4667 fn nodeSafeRegistry(
4668 data: &[u8],
4669 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4670 <nodeSafeRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4671 data,
4672 )
4673 .map(HoprSafeProxyForNetworkRegistryCalls::nodeSafeRegistry)
4674 }
4675 nodeSafeRegistry
4676 },
4677 {
4678 fn getRoleMember(
4679 data: &[u8],
4680 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4681 <getRoleMemberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4682 data,
4683 )
4684 .map(HoprSafeProxyForNetworkRegistryCalls::getRoleMember)
4685 }
4686 getRoleMember
4687 },
4688 {
4689 fn hasRole(
4690 data: &[u8],
4691 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4692 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4693 data,
4694 )
4695 .map(HoprSafeProxyForNetworkRegistryCalls::hasRole)
4696 }
4697 hasRole
4698 },
4699 {
4700 fn DEFAULT_ADMIN_ROLE(
4701 data: &[u8],
4702 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4703 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4704 data,
4705 )
4706 .map(
4707 HoprSafeProxyForNetworkRegistryCalls::DEFAULT_ADMIN_ROLE,
4708 )
4709 }
4710 DEFAULT_ADMIN_ROLE
4711 },
4712 {
4713 fn maxAllowedRegistrations(
4714 data: &[u8],
4715 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4716 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4717 data,
4718 )
4719 .map(
4720 HoprSafeProxyForNetworkRegistryCalls::maxAllowedRegistrations,
4721 )
4722 }
4723 maxAllowedRegistrations
4724 },
4725 {
4726 fn getRoleMemberCount(
4727 data: &[u8],
4728 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4729 <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4730 data,
4731 )
4732 .map(
4733 HoprSafeProxyForNetworkRegistryCalls::getRoleMemberCount,
4734 )
4735 }
4736 getRoleMemberCount
4737 },
4738 {
4739 fn revokeRole(
4740 data: &[u8],
4741 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4742 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4743 data,
4744 )
4745 .map(HoprSafeProxyForNetworkRegistryCalls::revokeRole)
4746 }
4747 revokeRole
4748 },
4749 {
4750 fn canOperateFor(
4751 data: &[u8],
4752 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4753 <canOperateForCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4754 data,
4755 )
4756 .map(HoprSafeProxyForNetworkRegistryCalls::canOperateFor)
4757 }
4758 canOperateFor
4759 },
4760 {
4761 fn MANAGER_ROLE(
4762 data: &[u8],
4763 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4764 <MANAGER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4765 data,
4766 )
4767 .map(HoprSafeProxyForNetworkRegistryCalls::MANAGER_ROLE)
4768 }
4769 MANAGER_ROLE
4770 },
4771 {
4772 fn stakeThreshold(
4773 data: &[u8],
4774 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4775 <stakeThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4776 data,
4777 )
4778 .map(HoprSafeProxyForNetworkRegistryCalls::stakeThreshold)
4779 }
4780 stakeThreshold
4781 },
4782 {
4783 fn snapshotBlockNumber(
4784 data: &[u8],
4785 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4786 <snapshotBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4787 data,
4788 )
4789 .map(
4790 HoprSafeProxyForNetworkRegistryCalls::snapshotBlockNumber,
4791 )
4792 }
4793 snapshotBlockNumber
4794 },
4795 {
4796 fn token(
4797 data: &[u8],
4798 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryCalls> {
4799 <tokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4800 data,
4801 )
4802 .map(HoprSafeProxyForNetworkRegistryCalls::token)
4803 }
4804 token
4805 },
4806 ];
4807 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4808 return Err(
4809 alloy_sol_types::Error::unknown_selector(
4810 <Self as alloy_sol_types::SolInterface>::NAME,
4811 selector,
4812 ),
4813 );
4814 };
4815 DECODE_VALIDATE_SHIMS[idx](data)
4816 }
4817 #[inline]
4818 fn abi_encoded_size(&self) -> usize {
4819 match self {
4820 Self::DEFAULT_ADMIN_ROLE(inner) => {
4821 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
4822 inner,
4823 )
4824 }
4825 Self::MANAGER_ROLE(inner) => {
4826 <MANAGER_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
4827 inner,
4828 )
4829 }
4830 Self::canOperateFor(inner) => {
4831 <canOperateForCall as alloy_sol_types::SolCall>::abi_encoded_size(
4832 inner,
4833 )
4834 }
4835 Self::getRoleAdmin(inner) => {
4836 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
4837 inner,
4838 )
4839 }
4840 Self::getRoleMember(inner) => {
4841 <getRoleMemberCall as alloy_sol_types::SolCall>::abi_encoded_size(
4842 inner,
4843 )
4844 }
4845 Self::getRoleMemberCount(inner) => {
4846 <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
4847 inner,
4848 )
4849 }
4850 Self::grantRole(inner) => {
4851 <grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4852 }
4853 Self::hasRole(inner) => {
4854 <hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4855 }
4856 Self::maxAllowedRegistrations(inner) => {
4857 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
4858 inner,
4859 )
4860 }
4861 Self::nodeSafeRegistry(inner) => {
4862 <nodeSafeRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
4863 inner,
4864 )
4865 }
4866 Self::renounceRole(inner) => {
4867 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(
4868 inner,
4869 )
4870 }
4871 Self::revokeRole(inner) => {
4872 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4873 }
4874 Self::snapshotBlockNumber(inner) => {
4875 <snapshotBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
4876 inner,
4877 )
4878 }
4879 Self::stakeThreshold(inner) => {
4880 <stakeThresholdCall as alloy_sol_types::SolCall>::abi_encoded_size(
4881 inner,
4882 )
4883 }
4884 Self::supportsInterface(inner) => {
4885 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
4886 inner,
4887 )
4888 }
4889 Self::token(inner) => {
4890 <tokenCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4891 }
4892 Self::updateSnapshotBlockNumber(inner) => {
4893 <updateSnapshotBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
4894 inner,
4895 )
4896 }
4897 Self::updateStakeThreshold(inner) => {
4898 <updateStakeThresholdCall as alloy_sol_types::SolCall>::abi_encoded_size(
4899 inner,
4900 )
4901 }
4902 }
4903 }
4904 #[inline]
4905 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4906 match self {
4907 Self::DEFAULT_ADMIN_ROLE(inner) => {
4908 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
4909 inner,
4910 out,
4911 )
4912 }
4913 Self::MANAGER_ROLE(inner) => {
4914 <MANAGER_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
4915 inner,
4916 out,
4917 )
4918 }
4919 Self::canOperateFor(inner) => {
4920 <canOperateForCall as alloy_sol_types::SolCall>::abi_encode_raw(
4921 inner,
4922 out,
4923 )
4924 }
4925 Self::getRoleAdmin(inner) => {
4926 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
4927 inner,
4928 out,
4929 )
4930 }
4931 Self::getRoleMember(inner) => {
4932 <getRoleMemberCall as alloy_sol_types::SolCall>::abi_encode_raw(
4933 inner,
4934 out,
4935 )
4936 }
4937 Self::getRoleMemberCount(inner) => {
4938 <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
4939 inner,
4940 out,
4941 )
4942 }
4943 Self::grantRole(inner) => {
4944 <grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
4945 inner,
4946 out,
4947 )
4948 }
4949 Self::hasRole(inner) => {
4950 <hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4951 }
4952 Self::maxAllowedRegistrations(inner) => {
4953 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
4954 inner,
4955 out,
4956 )
4957 }
4958 Self::nodeSafeRegistry(inner) => {
4959 <nodeSafeRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
4960 inner,
4961 out,
4962 )
4963 }
4964 Self::renounceRole(inner) => {
4965 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
4966 inner,
4967 out,
4968 )
4969 }
4970 Self::revokeRole(inner) => {
4971 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
4972 inner,
4973 out,
4974 )
4975 }
4976 Self::snapshotBlockNumber(inner) => {
4977 <snapshotBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
4978 inner,
4979 out,
4980 )
4981 }
4982 Self::stakeThreshold(inner) => {
4983 <stakeThresholdCall as alloy_sol_types::SolCall>::abi_encode_raw(
4984 inner,
4985 out,
4986 )
4987 }
4988 Self::supportsInterface(inner) => {
4989 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
4990 inner,
4991 out,
4992 )
4993 }
4994 Self::token(inner) => {
4995 <tokenCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4996 }
4997 Self::updateSnapshotBlockNumber(inner) => {
4998 <updateSnapshotBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
4999 inner,
5000 out,
5001 )
5002 }
5003 Self::updateStakeThreshold(inner) => {
5004 <updateStakeThresholdCall as alloy_sol_types::SolCall>::abi_encode_raw(
5005 inner,
5006 out,
5007 )
5008 }
5009 }
5010 }
5011 }
5012 #[derive(serde::Serialize, serde::Deserialize)]
5014 #[derive(Debug, PartialEq, Eq, Hash)]
5015 pub enum HoprSafeProxyForNetworkRegistryErrors {
5016 #[allow(missing_docs)]
5017 SameValue(SameValue),
5018 }
5019 #[automatically_derived]
5020 impl HoprSafeProxyForNetworkRegistryErrors {
5021 pub const SELECTORS: &'static [[u8; 4usize]] = &[[194u8, 63u8, 108u8, 203u8]];
5028 }
5029 #[automatically_derived]
5030 impl alloy_sol_types::SolInterface for HoprSafeProxyForNetworkRegistryErrors {
5031 const NAME: &'static str = "HoprSafeProxyForNetworkRegistryErrors";
5032 const MIN_DATA_LENGTH: usize = 0usize;
5033 const COUNT: usize = 1usize;
5034 #[inline]
5035 fn selector(&self) -> [u8; 4] {
5036 match self {
5037 Self::SameValue(_) => <SameValue as alloy_sol_types::SolError>::SELECTOR,
5038 }
5039 }
5040 #[inline]
5041 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5042 Self::SELECTORS.get(i).copied()
5043 }
5044 #[inline]
5045 fn valid_selector(selector: [u8; 4]) -> bool {
5046 Self::SELECTORS.binary_search(&selector).is_ok()
5047 }
5048 #[inline]
5049 #[allow(non_snake_case)]
5050 fn abi_decode_raw(
5051 selector: [u8; 4],
5052 data: &[u8],
5053 ) -> alloy_sol_types::Result<Self> {
5054 static DECODE_SHIMS: &[fn(
5055 &[u8],
5056 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryErrors>] = &[
5057 {
5058 fn SameValue(
5059 data: &[u8],
5060 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryErrors> {
5061 <SameValue as alloy_sol_types::SolError>::abi_decode_raw(data)
5062 .map(HoprSafeProxyForNetworkRegistryErrors::SameValue)
5063 }
5064 SameValue
5065 },
5066 ];
5067 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5068 return Err(
5069 alloy_sol_types::Error::unknown_selector(
5070 <Self as alloy_sol_types::SolInterface>::NAME,
5071 selector,
5072 ),
5073 );
5074 };
5075 DECODE_SHIMS[idx](data)
5076 }
5077 #[inline]
5078 #[allow(non_snake_case)]
5079 fn abi_decode_raw_validate(
5080 selector: [u8; 4],
5081 data: &[u8],
5082 ) -> alloy_sol_types::Result<Self> {
5083 static DECODE_VALIDATE_SHIMS: &[fn(
5084 &[u8],
5085 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryErrors>] = &[
5086 {
5087 fn SameValue(
5088 data: &[u8],
5089 ) -> alloy_sol_types::Result<HoprSafeProxyForNetworkRegistryErrors> {
5090 <SameValue as alloy_sol_types::SolError>::abi_decode_raw_validate(
5091 data,
5092 )
5093 .map(HoprSafeProxyForNetworkRegistryErrors::SameValue)
5094 }
5095 SameValue
5096 },
5097 ];
5098 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5099 return Err(
5100 alloy_sol_types::Error::unknown_selector(
5101 <Self as alloy_sol_types::SolInterface>::NAME,
5102 selector,
5103 ),
5104 );
5105 };
5106 DECODE_VALIDATE_SHIMS[idx](data)
5107 }
5108 #[inline]
5109 fn abi_encoded_size(&self) -> usize {
5110 match self {
5111 Self::SameValue(inner) => {
5112 <SameValue as alloy_sol_types::SolError>::abi_encoded_size(inner)
5113 }
5114 }
5115 }
5116 #[inline]
5117 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5118 match self {
5119 Self::SameValue(inner) => {
5120 <SameValue as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5121 }
5122 }
5123 }
5124 }
5125 #[derive(serde::Serialize, serde::Deserialize)]
5127 #[derive(Debug, PartialEq, Eq, Hash)]
5128 pub enum HoprSafeProxyForNetworkRegistryEvents {
5129 #[allow(missing_docs)]
5130 RoleAdminChanged(RoleAdminChanged),
5131 #[allow(missing_docs)]
5132 RoleGranted(RoleGranted),
5133 #[allow(missing_docs)]
5134 RoleRevoked(RoleRevoked),
5135 #[allow(missing_docs)]
5136 SnapshotUpdated(SnapshotUpdated),
5137 #[allow(missing_docs)]
5138 ThresholdUpdated(ThresholdUpdated),
5139 #[allow(missing_docs)]
5140 TokenAndRegistryUpdated(TokenAndRegistryUpdated),
5141 }
5142 #[automatically_derived]
5143 impl HoprSafeProxyForNetworkRegistryEvents {
5144 pub const SELECTORS: &'static [[u8; 32usize]] = &[
5151 [
5152 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
5153 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
5154 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
5155 ],
5156 [
5157 119u8, 185u8, 203u8, 79u8, 135u8, 254u8, 171u8, 30u8, 189u8, 129u8, 75u8,
5158 182u8, 148u8, 183u8, 213u8, 20u8, 238u8, 45u8, 193u8, 240u8, 171u8,
5159 212u8, 195u8, 149u8, 127u8, 70u8, 130u8, 156u8, 46u8, 36u8, 157u8, 255u8,
5160 ],
5161 [
5162 173u8, 250u8, 142u8, 203u8, 33u8, 182u8, 150u8, 46u8, 188u8, 208u8,
5163 173u8, 189u8, 154u8, 185u8, 133u8, 183u8, 180u8, 197u8, 181u8, 235u8,
5164 59u8, 13u8, 234u8, 214u8, 131u8, 23u8, 21u8, 101u8, 199u8, 191u8, 225u8,
5165 113u8,
5166 ],
5167 [
5168 175u8, 29u8, 21u8, 153u8, 181u8, 199u8, 218u8, 154u8, 32u8, 4u8, 181u8,
5169 122u8, 193u8, 71u8, 132u8, 25u8, 151u8, 24u8, 169u8, 3u8, 100u8, 174u8,
5170 71u8, 242u8, 122u8, 200u8, 148u8, 146u8, 111u8, 6u8, 85u8, 252u8,
5171 ],
5172 [
5173 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
5174 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
5175 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
5176 ],
5177 [
5178 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
5179 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
5180 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
5181 ],
5182 ];
5183 }
5184 #[automatically_derived]
5185 impl alloy_sol_types::SolEventInterface for HoprSafeProxyForNetworkRegistryEvents {
5186 const NAME: &'static str = "HoprSafeProxyForNetworkRegistryEvents";
5187 const COUNT: usize = 6usize;
5188 fn decode_raw_log(
5189 topics: &[alloy_sol_types::Word],
5190 data: &[u8],
5191 ) -> alloy_sol_types::Result<Self> {
5192 match topics.first().copied() {
5193 Some(<RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5194 <RoleAdminChanged as alloy_sol_types::SolEvent>::decode_raw_log(
5195 topics,
5196 data,
5197 )
5198 .map(Self::RoleAdminChanged)
5199 }
5200 Some(<RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5201 <RoleGranted as alloy_sol_types::SolEvent>::decode_raw_log(
5202 topics,
5203 data,
5204 )
5205 .map(Self::RoleGranted)
5206 }
5207 Some(<RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5208 <RoleRevoked as alloy_sol_types::SolEvent>::decode_raw_log(
5209 topics,
5210 data,
5211 )
5212 .map(Self::RoleRevoked)
5213 }
5214 Some(<SnapshotUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5215 <SnapshotUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
5216 topics,
5217 data,
5218 )
5219 .map(Self::SnapshotUpdated)
5220 }
5221 Some(<ThresholdUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5222 <ThresholdUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
5223 topics,
5224 data,
5225 )
5226 .map(Self::ThresholdUpdated)
5227 }
5228 Some(
5229 <TokenAndRegistryUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5230 ) => {
5231 <TokenAndRegistryUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
5232 topics,
5233 data,
5234 )
5235 .map(Self::TokenAndRegistryUpdated)
5236 }
5237 _ => {
5238 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
5239 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
5240 log: alloy_sol_types::private::Box::new(
5241 alloy_sol_types::private::LogData::new_unchecked(
5242 topics.to_vec(),
5243 data.to_vec().into(),
5244 ),
5245 ),
5246 })
5247 }
5248 }
5249 }
5250 }
5251 #[automatically_derived]
5252 impl alloy_sol_types::private::IntoLogData
5253 for HoprSafeProxyForNetworkRegistryEvents {
5254 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5255 match self {
5256 Self::RoleAdminChanged(inner) => {
5257 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5258 }
5259 Self::RoleGranted(inner) => {
5260 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5261 }
5262 Self::RoleRevoked(inner) => {
5263 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5264 }
5265 Self::SnapshotUpdated(inner) => {
5266 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5267 }
5268 Self::ThresholdUpdated(inner) => {
5269 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5270 }
5271 Self::TokenAndRegistryUpdated(inner) => {
5272 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5273 }
5274 }
5275 }
5276 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5277 match self {
5278 Self::RoleAdminChanged(inner) => {
5279 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5280 }
5281 Self::RoleGranted(inner) => {
5282 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5283 }
5284 Self::RoleRevoked(inner) => {
5285 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5286 }
5287 Self::SnapshotUpdated(inner) => {
5288 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5289 }
5290 Self::ThresholdUpdated(inner) => {
5291 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5292 }
5293 Self::TokenAndRegistryUpdated(inner) => {
5294 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5295 }
5296 }
5297 }
5298 }
5299 use alloy::contract as alloy_contract;
5300 #[inline]
5304 pub const fn new<
5305 P: alloy_contract::private::Provider<N>,
5306 N: alloy_contract::private::Network,
5307 >(
5308 address: alloy_sol_types::private::Address,
5309 provider: P,
5310 ) -> HoprSafeProxyForNetworkRegistryInstance<P, N> {
5311 HoprSafeProxyForNetworkRegistryInstance::<P, N>::new(address, provider)
5312 }
5313 #[inline]
5319 pub fn deploy<
5320 P: alloy_contract::private::Provider<N>,
5321 N: alloy_contract::private::Network,
5322 >(
5323 provider: P,
5324 _owner: alloy::sol_types::private::Address,
5325 _manager: alloy::sol_types::private::Address,
5326 _stakeThreshold: alloy::sol_types::private::primitives::aliases::U256,
5327 _snapshotBlockNumber: u128,
5328 _token: alloy::sol_types::private::Address,
5329 _nodeSafeRegistry: alloy::sol_types::private::Address,
5330 ) -> impl ::core::future::Future<
5331 Output = alloy_contract::Result<HoprSafeProxyForNetworkRegistryInstance<P, N>>,
5332 > {
5333 HoprSafeProxyForNetworkRegistryInstance::<
5334 P,
5335 N,
5336 >::deploy(
5337 provider,
5338 _owner,
5339 _manager,
5340 _stakeThreshold,
5341 _snapshotBlockNumber,
5342 _token,
5343 _nodeSafeRegistry,
5344 )
5345 }
5346 #[inline]
5352 pub fn deploy_builder<
5353 P: alloy_contract::private::Provider<N>,
5354 N: alloy_contract::private::Network,
5355 >(
5356 provider: P,
5357 _owner: alloy::sol_types::private::Address,
5358 _manager: alloy::sol_types::private::Address,
5359 _stakeThreshold: alloy::sol_types::private::primitives::aliases::U256,
5360 _snapshotBlockNumber: u128,
5361 _token: alloy::sol_types::private::Address,
5362 _nodeSafeRegistry: alloy::sol_types::private::Address,
5363 ) -> alloy_contract::RawCallBuilder<P, N> {
5364 HoprSafeProxyForNetworkRegistryInstance::<
5365 P,
5366 N,
5367 >::deploy_builder(
5368 provider,
5369 _owner,
5370 _manager,
5371 _stakeThreshold,
5372 _snapshotBlockNumber,
5373 _token,
5374 _nodeSafeRegistry,
5375 )
5376 }
5377 #[derive(Clone)]
5389 pub struct HoprSafeProxyForNetworkRegistryInstance<
5390 P,
5391 N = alloy_contract::private::Ethereum,
5392 > {
5393 address: alloy_sol_types::private::Address,
5394 provider: P,
5395 _network: ::core::marker::PhantomData<N>,
5396 }
5397 #[automatically_derived]
5398 impl<P, N> ::core::fmt::Debug for HoprSafeProxyForNetworkRegistryInstance<P, N> {
5399 #[inline]
5400 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5401 f.debug_tuple("HoprSafeProxyForNetworkRegistryInstance")
5402 .field(&self.address)
5403 .finish()
5404 }
5405 }
5406 #[automatically_derived]
5408 impl<
5409 P: alloy_contract::private::Provider<N>,
5410 N: alloy_contract::private::Network,
5411 > HoprSafeProxyForNetworkRegistryInstance<P, N> {
5412 #[inline]
5416 pub const fn new(
5417 address: alloy_sol_types::private::Address,
5418 provider: P,
5419 ) -> Self {
5420 Self {
5421 address,
5422 provider,
5423 _network: ::core::marker::PhantomData,
5424 }
5425 }
5426 #[inline]
5432 pub async fn deploy(
5433 provider: P,
5434 _owner: alloy::sol_types::private::Address,
5435 _manager: alloy::sol_types::private::Address,
5436 _stakeThreshold: alloy::sol_types::private::primitives::aliases::U256,
5437 _snapshotBlockNumber: u128,
5438 _token: alloy::sol_types::private::Address,
5439 _nodeSafeRegistry: alloy::sol_types::private::Address,
5440 ) -> alloy_contract::Result<HoprSafeProxyForNetworkRegistryInstance<P, N>> {
5441 let call_builder = Self::deploy_builder(
5442 provider,
5443 _owner,
5444 _manager,
5445 _stakeThreshold,
5446 _snapshotBlockNumber,
5447 _token,
5448 _nodeSafeRegistry,
5449 );
5450 let contract_address = call_builder.deploy().await?;
5451 Ok(Self::new(contract_address, call_builder.provider))
5452 }
5453 #[inline]
5459 pub fn deploy_builder(
5460 provider: P,
5461 _owner: alloy::sol_types::private::Address,
5462 _manager: alloy::sol_types::private::Address,
5463 _stakeThreshold: alloy::sol_types::private::primitives::aliases::U256,
5464 _snapshotBlockNumber: u128,
5465 _token: alloy::sol_types::private::Address,
5466 _nodeSafeRegistry: alloy::sol_types::private::Address,
5467 ) -> alloy_contract::RawCallBuilder<P, N> {
5468 alloy_contract::RawCallBuilder::new_raw_deploy(
5469 provider,
5470 [
5471 &BYTECODE[..],
5472 &alloy_sol_types::SolConstructor::abi_encode(
5473 &constructorCall {
5474 _owner,
5475 _manager,
5476 _stakeThreshold,
5477 _snapshotBlockNumber,
5478 _token,
5479 _nodeSafeRegistry,
5480 },
5481 )[..],
5482 ]
5483 .concat()
5484 .into(),
5485 )
5486 }
5487 #[inline]
5489 pub const fn address(&self) -> &alloy_sol_types::private::Address {
5490 &self.address
5491 }
5492 #[inline]
5494 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
5495 self.address = address;
5496 }
5497 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
5499 self.set_address(address);
5500 self
5501 }
5502 #[inline]
5504 pub const fn provider(&self) -> &P {
5505 &self.provider
5506 }
5507 }
5508 impl<P: ::core::clone::Clone, N> HoprSafeProxyForNetworkRegistryInstance<&P, N> {
5509 #[inline]
5511 pub fn with_cloned_provider(
5512 self,
5513 ) -> HoprSafeProxyForNetworkRegistryInstance<P, N> {
5514 HoprSafeProxyForNetworkRegistryInstance {
5515 address: self.address,
5516 provider: ::core::clone::Clone::clone(&self.provider),
5517 _network: ::core::marker::PhantomData,
5518 }
5519 }
5520 }
5521 #[automatically_derived]
5523 impl<
5524 P: alloy_contract::private::Provider<N>,
5525 N: alloy_contract::private::Network,
5526 > HoprSafeProxyForNetworkRegistryInstance<P, N> {
5527 pub fn call_builder<C: alloy_sol_types::SolCall>(
5532 &self,
5533 call: &C,
5534 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
5535 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
5536 }
5537 pub fn DEFAULT_ADMIN_ROLE(
5539 &self,
5540 ) -> alloy_contract::SolCallBuilder<&P, DEFAULT_ADMIN_ROLECall, N> {
5541 self.call_builder(&DEFAULT_ADMIN_ROLECall)
5542 }
5543 pub fn MANAGER_ROLE(
5545 &self,
5546 ) -> alloy_contract::SolCallBuilder<&P, MANAGER_ROLECall, N> {
5547 self.call_builder(&MANAGER_ROLECall)
5548 }
5549 pub fn canOperateFor(
5551 &self,
5552 stakingAccount: alloy::sol_types::private::Address,
5553 nodeAddress: alloy::sol_types::private::Address,
5554 ) -> alloy_contract::SolCallBuilder<&P, canOperateForCall, N> {
5555 self.call_builder(
5556 &canOperateForCall {
5557 stakingAccount,
5558 nodeAddress,
5559 },
5560 )
5561 }
5562 pub fn getRoleAdmin(
5564 &self,
5565 role: alloy::sol_types::private::FixedBytes<32>,
5566 ) -> alloy_contract::SolCallBuilder<&P, getRoleAdminCall, N> {
5567 self.call_builder(&getRoleAdminCall { role })
5568 }
5569 pub fn getRoleMember(
5571 &self,
5572 role: alloy::sol_types::private::FixedBytes<32>,
5573 index: alloy::sol_types::private::primitives::aliases::U256,
5574 ) -> alloy_contract::SolCallBuilder<&P, getRoleMemberCall, N> {
5575 self.call_builder(&getRoleMemberCall { role, index })
5576 }
5577 pub fn getRoleMemberCount(
5579 &self,
5580 role: alloy::sol_types::private::FixedBytes<32>,
5581 ) -> alloy_contract::SolCallBuilder<&P, getRoleMemberCountCall, N> {
5582 self.call_builder(&getRoleMemberCountCall { role })
5583 }
5584 pub fn grantRole(
5586 &self,
5587 role: alloy::sol_types::private::FixedBytes<32>,
5588 account: alloy::sol_types::private::Address,
5589 ) -> alloy_contract::SolCallBuilder<&P, grantRoleCall, N> {
5590 self.call_builder(&grantRoleCall { role, account })
5591 }
5592 pub fn hasRole(
5594 &self,
5595 role: alloy::sol_types::private::FixedBytes<32>,
5596 account: alloy::sol_types::private::Address,
5597 ) -> alloy_contract::SolCallBuilder<&P, hasRoleCall, N> {
5598 self.call_builder(&hasRoleCall { role, account })
5599 }
5600 pub fn maxAllowedRegistrations(
5602 &self,
5603 safeAddress: alloy::sol_types::private::Address,
5604 ) -> alloy_contract::SolCallBuilder<&P, maxAllowedRegistrationsCall, N> {
5605 self.call_builder(
5606 &maxAllowedRegistrationsCall {
5607 safeAddress,
5608 },
5609 )
5610 }
5611 pub fn nodeSafeRegistry(
5613 &self,
5614 ) -> alloy_contract::SolCallBuilder<&P, nodeSafeRegistryCall, N> {
5615 self.call_builder(&nodeSafeRegistryCall)
5616 }
5617 pub fn renounceRole(
5619 &self,
5620 role: alloy::sol_types::private::FixedBytes<32>,
5621 account: alloy::sol_types::private::Address,
5622 ) -> alloy_contract::SolCallBuilder<&P, renounceRoleCall, N> {
5623 self.call_builder(&renounceRoleCall { role, account })
5624 }
5625 pub fn revokeRole(
5627 &self,
5628 role: alloy::sol_types::private::FixedBytes<32>,
5629 account: alloy::sol_types::private::Address,
5630 ) -> alloy_contract::SolCallBuilder<&P, revokeRoleCall, N> {
5631 self.call_builder(&revokeRoleCall { role, account })
5632 }
5633 pub fn snapshotBlockNumber(
5635 &self,
5636 ) -> alloy_contract::SolCallBuilder<&P, snapshotBlockNumberCall, N> {
5637 self.call_builder(&snapshotBlockNumberCall)
5638 }
5639 pub fn stakeThreshold(
5641 &self,
5642 ) -> alloy_contract::SolCallBuilder<&P, stakeThresholdCall, N> {
5643 self.call_builder(&stakeThresholdCall)
5644 }
5645 pub fn supportsInterface(
5647 &self,
5648 interfaceId: alloy::sol_types::private::FixedBytes<4>,
5649 ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
5650 self.call_builder(
5651 &supportsInterfaceCall {
5652 interfaceId,
5653 },
5654 )
5655 }
5656 pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> {
5658 self.call_builder(&tokenCall)
5659 }
5660 pub fn updateSnapshotBlockNumber(
5662 &self,
5663 newSnapshotBlock: u128,
5664 ) -> alloy_contract::SolCallBuilder<&P, updateSnapshotBlockNumberCall, N> {
5665 self.call_builder(
5666 &updateSnapshotBlockNumberCall {
5667 newSnapshotBlock,
5668 },
5669 )
5670 }
5671 pub fn updateStakeThreshold(
5673 &self,
5674 newThreshold: alloy::sol_types::private::primitives::aliases::U256,
5675 ) -> alloy_contract::SolCallBuilder<&P, updateStakeThresholdCall, N> {
5676 self.call_builder(
5677 &updateStakeThresholdCall {
5678 newThreshold,
5679 },
5680 )
5681 }
5682 }
5683 #[automatically_derived]
5685 impl<
5686 P: alloy_contract::private::Provider<N>,
5687 N: alloy_contract::private::Network,
5688 > HoprSafeProxyForNetworkRegistryInstance<P, N> {
5689 pub fn event_filter<E: alloy_sol_types::SolEvent>(
5694 &self,
5695 ) -> alloy_contract::Event<&P, E, N> {
5696 alloy_contract::Event::new_sol(&self.provider, &self.address)
5697 }
5698 pub fn RoleAdminChanged_filter(
5700 &self,
5701 ) -> alloy_contract::Event<&P, RoleAdminChanged, N> {
5702 self.event_filter::<RoleAdminChanged>()
5703 }
5704 pub fn RoleGranted_filter(&self) -> alloy_contract::Event<&P, RoleGranted, N> {
5706 self.event_filter::<RoleGranted>()
5707 }
5708 pub fn RoleRevoked_filter(&self) -> alloy_contract::Event<&P, RoleRevoked, N> {
5710 self.event_filter::<RoleRevoked>()
5711 }
5712 pub fn SnapshotUpdated_filter(
5714 &self,
5715 ) -> alloy_contract::Event<&P, SnapshotUpdated, N> {
5716 self.event_filter::<SnapshotUpdated>()
5717 }
5718 pub fn ThresholdUpdated_filter(
5720 &self,
5721 ) -> alloy_contract::Event<&P, ThresholdUpdated, N> {
5722 self.event_filter::<ThresholdUpdated>()
5723 }
5724 pub fn TokenAndRegistryUpdated_filter(
5726 &self,
5727 ) -> alloy_contract::Event<&P, TokenAndRegistryUpdated, N> {
5728 self.event_filter::<TokenAndRegistryUpdated>()
5729 }
5730 }
5731}