1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use PermissionController::*;
3
4#[allow(
585 non_camel_case_types,
586 non_snake_case,
587 clippy::pub_underscore_fields,
588 clippy::style,
589 clippy::empty_structs_with_brackets
590)]
591pub mod PermissionController {
592 use super::*;
593 use alloy::sol_types as alloy_sol_types;
594 #[rustfmt::skip]
600 #[allow(clippy::all)]
601 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
602 b"`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x12\xD58\x03\x80a\x12\xD5\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01~V[\x80a\08\x81a\0JV[`\x80RPa\0Da\0\x90V[Pa\x02\x83V[__\x82\x90P`\x1F\x81Q\x11\x15a\0}W\x82`@Qc0Z'\xA9`\xE0\x1B\x81R`\x04\x01a\0t\x91\x90a\x02+V[`@Q\x80\x91\x03\x90\xFD[\x80Qa\0\x88\x82a\x02]V[\x17\x93\x92PPPV[_Ta\x01\0\x90\x04`\xFF\x16\x15a\0\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FInitializable: contract is initi`D\x82\x01Rfalizing`\xC8\x1B`d\x82\x01R`\x84\x01a\0tV[_T`\xFF\x90\x81\x16\x14a\x01FW_\x80T`\xFF\x19\x16`\xFF\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x90` \x01`@Q\x80\x91\x03\x90\xA1[V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_[\x83\x81\x10\x15a\x01vW\x81\x81\x01Q\x83\x82\x01R` \x01a\x01^V[PP_\x91\x01RV[_` \x82\x84\x03\x12\x15a\x01\x8EW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xA3W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x01\xB3W__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xCCWa\x01\xCCa\x01HV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01\xFAWa\x01\xFAa\x01HV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x02\x11W__\xFD[a\x02\"\x82` \x83\x01` \x86\x01a\x01\\V[\x95\x94PPPPPV[` \x81R_\x82Q\x80` \x84\x01Ra\x02I\x81`@\x85\x01` \x87\x01a\x01\\V[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[\x80Q` \x80\x83\x01Q\x91\x90\x81\x10\x15a\x02}W_\x19\x81` \x03`\x03\x1B\x1B\x82\x16\x91P[P\x91\x90PV[`\x80Qa\x10:a\x02\x9B_9_a\x04\xAF\x01Ra\x10:_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xC7W_5`\xE0\x1C\x80c\x91\0gE\x11a\0yW\x80c\x91\0gE\x14a\x01xW\x80c\x95\r\x80n\x14a\x01\x9BW\x80c\xAD_\"\x10\x14a\x01\xAEW\x80c\xAD\x8A\xCAw\x14a\x01\xC1W\x80c\xDFY\\\xB8\x14a\x01\xD4W\x80c\xEBZN\x87\x14a\x01\xE7W\x80c\xFD\xDB\xDE\xFD\x14a\x01\xFAW__\xFD[\x80c\x06d\x12\x01\x14a\0\xCBW\x80c&\x89Y\xE5\x14a\0\xE0W\x80cO\x90l\xF9\x14a\0\xF3W\x80cT\xFDMP\x14a\x01\x06W\x80cb\x88\x06\xEF\x14a\x01$W\x80ck\xDD\xFA\x1F\x14a\x017W\x80c\x88*;8\x14a\x01WW[__\xFD[a\0\xDEa\0\xD96`\x04a\r\x95V[a\x02\rV[\0[a\0\xDEa\0\xEE6`\x04a\r\xE6V[a\x03.V[a\0\xDEa\x01\x016`\x04a\r\xE6V[a\x04\tV[a\x01\x0Ea\x04\xA8V[`@Qa\x01\x1B\x91\x90a\x0E\x17V[`@Q\x80\x91\x03\x90\xF3[a\0\xDEa\x0126`\x04a\x0EbV[a\x04\xD8V[a\x01Ja\x01E6`\x04a\x0EbV[a\x05iV[`@Qa\x01\x1B\x91\x90a\x0E\xBEV[a\x01ja\x01e6`\x04a\r\xE6V[a\x05\x92V[`@Qa\x01\x1B\x92\x91\x90a\x0E\xD0V[a\x01\x8Ba\x01\x866`\x04a\r\xE6V[a\x06\xF3V[`@Q\x90\x15\x15\x81R` \x01a\x01\x1BV[a\0\xDEa\x01\xA96`\x04a\r\x95V[a\x07cV[a\x01Ja\x01\xBC6`\x04a\x0EbV[a\x08tV[a\x01\x8Ba\x01\xCF6`\x04a\r\xE6V[a\t\x1AV[a\x01\x8Ba\x01\xE26`\x04a\r\x95V[a\t;V[a\0\xDEa\x01\xF56`\x04a\r\xE6V[a\t\x90V[a\x01Ja\x02\x086`\x04a\x0F2V[a\nZV[\x83a\x02\x18\x813a\x06\xF3V[a\x025W`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x01` R`@\x81 \x90a\x02W\x85\x85a\n\x98V[`\x01`\x01`\xA0\x1B\x03\x87\x16_\x90\x81R`\x04\x84\x01` R`@\x90 \x90\x91Pa\x02}\x90\x82a\n\xC0V[a\x02\x9AW`@Qc&!\x18\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x04\x83\x01` R`@\x90 a\x02\xBD\x90\x82a\n\xD7V[P_\x81\x81R`\x05\x83\x01` R`@\x90 a\x02\xD7\x90\x87a\n\xE2V[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x7F\x18$#&\xB6\xB8b\x12ipg\x97Y\x16\x9F\x01\xF6F\xBDU\xEC[\xFC\xAB\x85\xBA\x9F3zt\xE0\xC6\x87\x87`@Qa\x03\x1D\x92\x91\x90a\x0FrV[`@Q\x80\x91\x03\x90\xA3PPPPPPPV[\x81a\x039\x813a\x06\xF3V[a\x03VW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` \x81\x90R`@\x90\x91 `\x02\x01\x90a\x03}\x82a\n\xF6V[\x11a\x03\x9BW`@Qc\x10\xCE\x89+`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xA5\x81\x84a\n\xE2V[a\x03\xC2W`@Qc\x07\x16\xD8\x1B`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83`\x01`\x01`\xA0\x1B\x03\x16\x7F\xDB\x9D]12\r\xAF[\xC7\x18\x1DV[m\xA4\xD1.0\xF0\xF4\xD5\xAA2J\x99$&\xC1J\x1D\x19\xCE\x84`@Qa\x03\xFB\x91\x90a\x0F\x95V[`@Q\x80\x91\x03\x90\xA2PPPPV[\x81a\x04\x14\x813a\x06\xF3V[a\x041W`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\x04R\x81\x84a\n\xE2V[a\x04oW`@Qc\xBE\xD8)_`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83`\x01`\x01`\xA0\x1B\x03\x16\x7F\xD7\x06\xEDz\xE0D\xD7\x95\xB4\x9ET\xC9\xF5\x19\xF6c\x059Q\x01\x19\x85\xF6c\xA8b\xCD\x9E\xE7*\x9A\xC7\x84`@Qa\x03\xFB\x91\x90a\x0F\x95V[``a\x04\xD3\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\n\xFFV[\x90P\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 a\x04\xF9\x813a\n\xE2V[a\x05\x16W`@Qc\xBE\xD8)_`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05#`\x02\x82\x013a\x0B<V[P\x81`\x01`\x01`\xA0\x1B\x03\x16\x7F\xBF&^\x83&(Z'G\xE3>T\xD5\x94_q\x11\xF2\xB5\xED\xB8&\xEB\x8C\x08\xD4gwy\xB3\xFF\x973`@Qa\x05]\x91\x90a\x0F\x95V[`@Q\x80\x91\x03\x90\xA2PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 ``\x90a\x05\x8C\x90a\x0BPV[\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x80\x83\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R`\x04\x90\x93\x01\x90R\x90\x81 ``\x91\x82\x91\x90a\x05\xCB\x82a\n\xF6V[\x90P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05\xE7Wa\x05\xE7a\x0F\xA9V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06\x10W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06-Wa\x06-a\x0F\xA9V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06VW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x06\xE5Wa\x06\x89a\x06p\x86\x83a\x0B\\V[``\x81\x90\x1C\x91`\xA0\x91\x90\x91\x1B`\x01`\x01`\xE0\x1B\x03\x19\x16\x90V[\x84\x83\x81Q\x81\x10a\x06\x9BWa\x06\x9Ba\x0F\xBDV[` \x02` \x01\x01\x84\x84\x81Q\x81\x10a\x06\xB4Wa\x06\xB4a\x0F\xBDV[`\x01`\x01`\xE0\x1B\x03\x19\x90\x93\x16` \x93\x84\x02\x91\x90\x91\x01\x90\x92\x01\x91\x90\x91R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90R`\x01\x01a\x06[V[P\x90\x97\x90\x96P\x94PPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x81 a\x07\x16\x90`\x02\x01a\n\xF6V[_\x03a\x078W\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x90Pa\x05\x8CV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\x07\\\x90`\x02\x01\x83a\x0BgV[\x93\x92PPPV[\x83a\x07n\x813a\x06\xF3V[a\x07\x8BW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x01` R`@\x81 \x90a\x07\xAD\x85\x85a\n\x98V[`\x01`\x01`\xA0\x1B\x03\x87\x16_\x90\x81R`\x04\x84\x01` R`@\x90 \x90\x91Pa\x07\xD3\x90\x82a\n\xC0V[\x15a\x07\xF1W`@Qc\xAD\x8E\xFE\xB7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x04\x83\x01` R`@\x90 a\x08\x14\x90\x82a\x0B\x88V[P_\x81\x81R`\x05\x83\x01` R`@\x90 a\x08.\x90\x87a\x0B<V[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x7F\x03\x7F\x03\xA2\xADk\x96}\xF4\xA0\x17y\xB6\xD2\xB4\xC8YP\xDF\x83\x92]\x9E16+Q\x94\"\xFC\x01i\x87\x87`@Qa\x03\x1D\x92\x91\x90a\x0FrV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 ``\x90a\x08\x9A\x90`\x02\x01a\n\xF6V[_\x03a\x08\xF2W`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x82\x81_\x81Q\x81\x10a\x08\xD4Wa\x08\xD4a\x0F\xBDV[`\x01`\x01`\xA0\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x90 a\x05\x8C\x90`\x02\x01a\x0BPV[\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x81 a\x07\\\x90\x83a\x0BgV[_a\tF\x85\x85a\x06\xF3V[\x80a\t\x87WPa\t\x87a\tY\x84\x84a\n\x98V[`\x01`\x01`\xA0\x1B\x03\x80\x88\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x8A\x16\x83R`\x04\x90\x93\x01\x90R \x90a\n\xC0V[\x95\x94PPPPPV[\x81a\t\x9B\x813a\x06\xF3V[a\t\xB8W`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\t\xDC`\x02\x82\x01\x84a\x0BgV[\x15a\t\xFAW`@Qc\x13\x01`\xE5`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\n\x04\x81\x84a\x0B<V[a\n!W`@Qc\x19\xAB\xED\xE3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83`\x01`\x01`\xA0\x1B\x03\x16\x7F\xB1K\x9A=D\x8C[\x04\xF0\xE5\xB0\x87\xB6\xF5\x193\x90\xDByUH*o\xFB\x84\x1E{;\xA6\x1AF\x0C\x84`@Qa\x03\xFB\x91\x90a\x0F\x95V[``_a\ng\x84\x84a\n\x98V[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x84\x84R`\x05\x01\x90\x91R\x90 \x90\x91Pa\t\x87\x90a\x0BPV[``\x91\x90\x91\x1Bk\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\xA0\x91\x90\x91\x1Cc\xFF\xFF\xFF\xFF`@\x1B\x16\x17\x90V[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07\\V[_a\x07\\\x83\x83a\x0B\x93V[_a\x07\\\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0B\x93V[_a\x05\x8C\x82T\x90V[``_a\x0B\x0B\x83a\x0CvV[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x82\x01\x81\x806\x837PPP\x91\x82RP` \x81\x01\x92\x90\x92RP\x90V[_a\x07\\\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0C\x9DV[``_a\x07\\\x83a\x0C\xE9V[_a\x07\\\x83\x83a\rBV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07\\V[_a\x07\\\x83\x83a\x0C\x9DV[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a\x0CmW_a\x0B\xB5`\x01\x83a\x0F\xD1V[\x85T\x90\x91P_\x90a\x0B\xC8\x90`\x01\x90a\x0F\xD1V[\x90P\x81\x81\x14a\x0C'W_\x86_\x01\x82\x81T\x81\x10a\x0B\xE6Wa\x0B\xE6a\x0F\xBDV[\x90_R` _ \x01T\x90P\x80\x87_\x01\x84\x81T\x81\x10a\x0C\x06Wa\x0C\x06a\x0F\xBDV[_\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80a\x0C8Wa\x0C8a\x0F\xF0V[`\x01\x90\x03\x81\x81\x90_R` _ \x01_\x90U\x90U\x85`\x01\x01_\x86\x81R` \x01\x90\x81R` \x01_ _\x90U`\x01\x93PPPPa\x05\x8CV[_\x91PPa\x05\x8CV[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x05\x8CW`@Qc,\xD4J\xC3`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81\x81R`\x01\x83\x01` R`@\x81 Ta\x0C\xE2WP\x81T`\x01\x81\x81\x01\x84U_\x84\x81R` \x80\x82 \x90\x93\x01\x84\x90U\x84T\x84\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x05\x8CV[P_a\x05\x8CV[``\x81_\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\r6W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T\x81R` \x01\x90`\x01\x01\x90\x80\x83\x11a\r\"W[PPPPP\x90P\x91\x90PV[_\x82_\x01\x82\x81T\x81\x10a\rWWa\rWa\x0F\xBDV[\x90_R` _ \x01T\x90P\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\t\x15W__\xFD[\x805`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\t\x15W__\xFD[____`\x80\x85\x87\x03\x12\x15a\r\xA8W__\xFD[a\r\xB1\x85a\rhV[\x93Pa\r\xBF` \x86\x01a\rhV[\x92Pa\r\xCD`@\x86\x01a\rhV[\x91Pa\r\xDB``\x86\x01a\r~V[\x90P\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15a\r\xF7W__\xFD[a\x0E\0\x83a\rhV[\x91Pa\x0E\x0E` \x84\x01a\rhV[\x90P\x92P\x92\x90PV[` \x81R_\x82Q\x80` \x84\x01R_[\x81\x81\x10\x15a\x0ECW` \x81\x86\x01\x81\x01Q`@\x86\x84\x01\x01R\x01a\x0E&V[P_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x0ErW__\xFD[a\x07\\\x82a\rhV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x0E\xB4W\x81Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x0E\x8DV[P\x93\x94\x93PPPPV[` \x81R_a\x07\\` \x83\x01\x84a\x0E{V[`@\x81R_a\x0E\xE2`@\x83\x01\x85a\x0E{V[\x82\x81\x03` \x84\x01R\x80\x84Q\x80\x83R` \x83\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0F&W\x83Q`\x01`\x01`\xE0\x1B\x03\x19\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0E\xFEV[P\x90\x96\x95PPPPPPV[___``\x84\x86\x03\x12\x15a\x0FDW__\xFD[a\x0FM\x84a\rhV[\x92Pa\x0F[` \x85\x01a\rhV[\x91Pa\x0Fi`@\x85\x01a\r~V[\x90P\x92P\x92P\x92V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R`\x01`\x01`\xE0\x1B\x03\x19\x16` \x82\x01R`@\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x05\x8CWcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`1`\x04R`$_\xFD\xFE\xA2dipfsX\"\x12 \n`\xFB\xCDJ\xB9\xE8\xC9\xB7\xEE\xD8\x0Fl\x19\xD7\x13\x87\xB7\xCF\x1D\xEE\xA1\xB9p'DG\xC6\xB5\x1D\xECadsolcC\0\x08\x1B\x003",
603 );
604 #[rustfmt::skip]
610 #[allow(clippy::all)]
611 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
612 b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xC7W_5`\xE0\x1C\x80c\x91\0gE\x11a\0yW\x80c\x91\0gE\x14a\x01xW\x80c\x95\r\x80n\x14a\x01\x9BW\x80c\xAD_\"\x10\x14a\x01\xAEW\x80c\xAD\x8A\xCAw\x14a\x01\xC1W\x80c\xDFY\\\xB8\x14a\x01\xD4W\x80c\xEBZN\x87\x14a\x01\xE7W\x80c\xFD\xDB\xDE\xFD\x14a\x01\xFAW__\xFD[\x80c\x06d\x12\x01\x14a\0\xCBW\x80c&\x89Y\xE5\x14a\0\xE0W\x80cO\x90l\xF9\x14a\0\xF3W\x80cT\xFDMP\x14a\x01\x06W\x80cb\x88\x06\xEF\x14a\x01$W\x80ck\xDD\xFA\x1F\x14a\x017W\x80c\x88*;8\x14a\x01WW[__\xFD[a\0\xDEa\0\xD96`\x04a\r\x95V[a\x02\rV[\0[a\0\xDEa\0\xEE6`\x04a\r\xE6V[a\x03.V[a\0\xDEa\x01\x016`\x04a\r\xE6V[a\x04\tV[a\x01\x0Ea\x04\xA8V[`@Qa\x01\x1B\x91\x90a\x0E\x17V[`@Q\x80\x91\x03\x90\xF3[a\0\xDEa\x0126`\x04a\x0EbV[a\x04\xD8V[a\x01Ja\x01E6`\x04a\x0EbV[a\x05iV[`@Qa\x01\x1B\x91\x90a\x0E\xBEV[a\x01ja\x01e6`\x04a\r\xE6V[a\x05\x92V[`@Qa\x01\x1B\x92\x91\x90a\x0E\xD0V[a\x01\x8Ba\x01\x866`\x04a\r\xE6V[a\x06\xF3V[`@Q\x90\x15\x15\x81R` \x01a\x01\x1BV[a\0\xDEa\x01\xA96`\x04a\r\x95V[a\x07cV[a\x01Ja\x01\xBC6`\x04a\x0EbV[a\x08tV[a\x01\x8Ba\x01\xCF6`\x04a\r\xE6V[a\t\x1AV[a\x01\x8Ba\x01\xE26`\x04a\r\x95V[a\t;V[a\0\xDEa\x01\xF56`\x04a\r\xE6V[a\t\x90V[a\x01Ja\x02\x086`\x04a\x0F2V[a\nZV[\x83a\x02\x18\x813a\x06\xF3V[a\x025W`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x01` R`@\x81 \x90a\x02W\x85\x85a\n\x98V[`\x01`\x01`\xA0\x1B\x03\x87\x16_\x90\x81R`\x04\x84\x01` R`@\x90 \x90\x91Pa\x02}\x90\x82a\n\xC0V[a\x02\x9AW`@Qc&!\x18\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x04\x83\x01` R`@\x90 a\x02\xBD\x90\x82a\n\xD7V[P_\x81\x81R`\x05\x83\x01` R`@\x90 a\x02\xD7\x90\x87a\n\xE2V[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x7F\x18$#&\xB6\xB8b\x12ipg\x97Y\x16\x9F\x01\xF6F\xBDU\xEC[\xFC\xAB\x85\xBA\x9F3zt\xE0\xC6\x87\x87`@Qa\x03\x1D\x92\x91\x90a\x0FrV[`@Q\x80\x91\x03\x90\xA3PPPPPPPV[\x81a\x039\x813a\x06\xF3V[a\x03VW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` \x81\x90R`@\x90\x91 `\x02\x01\x90a\x03}\x82a\n\xF6V[\x11a\x03\x9BW`@Qc\x10\xCE\x89+`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xA5\x81\x84a\n\xE2V[a\x03\xC2W`@Qc\x07\x16\xD8\x1B`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83`\x01`\x01`\xA0\x1B\x03\x16\x7F\xDB\x9D]12\r\xAF[\xC7\x18\x1DV[m\xA4\xD1.0\xF0\xF4\xD5\xAA2J\x99$&\xC1J\x1D\x19\xCE\x84`@Qa\x03\xFB\x91\x90a\x0F\x95V[`@Q\x80\x91\x03\x90\xA2PPPPV[\x81a\x04\x14\x813a\x06\xF3V[a\x041W`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\x04R\x81\x84a\n\xE2V[a\x04oW`@Qc\xBE\xD8)_`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83`\x01`\x01`\xA0\x1B\x03\x16\x7F\xD7\x06\xEDz\xE0D\xD7\x95\xB4\x9ET\xC9\xF5\x19\xF6c\x059Q\x01\x19\x85\xF6c\xA8b\xCD\x9E\xE7*\x9A\xC7\x84`@Qa\x03\xFB\x91\x90a\x0F\x95V[``a\x04\xD3\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\n\xFFV[\x90P\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 a\x04\xF9\x813a\n\xE2V[a\x05\x16W`@Qc\xBE\xD8)_`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05#`\x02\x82\x013a\x0B<V[P\x81`\x01`\x01`\xA0\x1B\x03\x16\x7F\xBF&^\x83&(Z'G\xE3>T\xD5\x94_q\x11\xF2\xB5\xED\xB8&\xEB\x8C\x08\xD4gwy\xB3\xFF\x973`@Qa\x05]\x91\x90a\x0F\x95V[`@Q\x80\x91\x03\x90\xA2PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 ``\x90a\x05\x8C\x90a\x0BPV[\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x80\x83\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R`\x04\x90\x93\x01\x90R\x90\x81 ``\x91\x82\x91\x90a\x05\xCB\x82a\n\xF6V[\x90P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05\xE7Wa\x05\xE7a\x0F\xA9V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06\x10W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06-Wa\x06-a\x0F\xA9V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06VW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x06\xE5Wa\x06\x89a\x06p\x86\x83a\x0B\\V[``\x81\x90\x1C\x91`\xA0\x91\x90\x91\x1B`\x01`\x01`\xE0\x1B\x03\x19\x16\x90V[\x84\x83\x81Q\x81\x10a\x06\x9BWa\x06\x9Ba\x0F\xBDV[` \x02` \x01\x01\x84\x84\x81Q\x81\x10a\x06\xB4Wa\x06\xB4a\x0F\xBDV[`\x01`\x01`\xE0\x1B\x03\x19\x90\x93\x16` \x93\x84\x02\x91\x90\x91\x01\x90\x92\x01\x91\x90\x91R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90R`\x01\x01a\x06[V[P\x90\x97\x90\x96P\x94PPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x81 a\x07\x16\x90`\x02\x01a\n\xF6V[_\x03a\x078W\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x90Pa\x05\x8CV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\x07\\\x90`\x02\x01\x83a\x0BgV[\x93\x92PPPV[\x83a\x07n\x813a\x06\xF3V[a\x07\x8BW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x01` R`@\x81 \x90a\x07\xAD\x85\x85a\n\x98V[`\x01`\x01`\xA0\x1B\x03\x87\x16_\x90\x81R`\x04\x84\x01` R`@\x90 \x90\x91Pa\x07\xD3\x90\x82a\n\xC0V[\x15a\x07\xF1W`@Qc\xAD\x8E\xFE\xB7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x04\x83\x01` R`@\x90 a\x08\x14\x90\x82a\x0B\x88V[P_\x81\x81R`\x05\x83\x01` R`@\x90 a\x08.\x90\x87a\x0B<V[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x7F\x03\x7F\x03\xA2\xADk\x96}\xF4\xA0\x17y\xB6\xD2\xB4\xC8YP\xDF\x83\x92]\x9E16+Q\x94\"\xFC\x01i\x87\x87`@Qa\x03\x1D\x92\x91\x90a\x0FrV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 ``\x90a\x08\x9A\x90`\x02\x01a\n\xF6V[_\x03a\x08\xF2W`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x82\x81_\x81Q\x81\x10a\x08\xD4Wa\x08\xD4a\x0F\xBDV[`\x01`\x01`\xA0\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x90 a\x05\x8C\x90`\x02\x01a\x0BPV[\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x81 a\x07\\\x90\x83a\x0BgV[_a\tF\x85\x85a\x06\xF3V[\x80a\t\x87WPa\t\x87a\tY\x84\x84a\n\x98V[`\x01`\x01`\xA0\x1B\x03\x80\x88\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x8A\x16\x83R`\x04\x90\x93\x01\x90R \x90a\n\xC0V[\x95\x94PPPPPV[\x81a\t\x9B\x813a\x06\xF3V[a\t\xB8W`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\t\xDC`\x02\x82\x01\x84a\x0BgV[\x15a\t\xFAW`@Qc\x13\x01`\xE5`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\n\x04\x81\x84a\x0B<V[a\n!W`@Qc\x19\xAB\xED\xE3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x83`\x01`\x01`\xA0\x1B\x03\x16\x7F\xB1K\x9A=D\x8C[\x04\xF0\xE5\xB0\x87\xB6\xF5\x193\x90\xDByUH*o\xFB\x84\x1E{;\xA6\x1AF\x0C\x84`@Qa\x03\xFB\x91\x90a\x0F\x95V[``_a\ng\x84\x84a\n\x98V[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x84\x84R`\x05\x01\x90\x91R\x90 \x90\x91Pa\t\x87\x90a\x0BPV[``\x91\x90\x91\x1Bk\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\xA0\x91\x90\x91\x1Cc\xFF\xFF\xFF\xFF`@\x1B\x16\x17\x90V[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07\\V[_a\x07\\\x83\x83a\x0B\x93V[_a\x07\\\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0B\x93V[_a\x05\x8C\x82T\x90V[``_a\x0B\x0B\x83a\x0CvV[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x82\x01\x81\x806\x837PPP\x91\x82RP` \x81\x01\x92\x90\x92RP\x90V[_a\x07\\\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0C\x9DV[``_a\x07\\\x83a\x0C\xE9V[_a\x07\\\x83\x83a\rBV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07\\V[_a\x07\\\x83\x83a\x0C\x9DV[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a\x0CmW_a\x0B\xB5`\x01\x83a\x0F\xD1V[\x85T\x90\x91P_\x90a\x0B\xC8\x90`\x01\x90a\x0F\xD1V[\x90P\x81\x81\x14a\x0C'W_\x86_\x01\x82\x81T\x81\x10a\x0B\xE6Wa\x0B\xE6a\x0F\xBDV[\x90_R` _ \x01T\x90P\x80\x87_\x01\x84\x81T\x81\x10a\x0C\x06Wa\x0C\x06a\x0F\xBDV[_\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80a\x0C8Wa\x0C8a\x0F\xF0V[`\x01\x90\x03\x81\x81\x90_R` _ \x01_\x90U\x90U\x85`\x01\x01_\x86\x81R` \x01\x90\x81R` \x01_ _\x90U`\x01\x93PPPPa\x05\x8CV[_\x91PPa\x05\x8CV[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x05\x8CW`@Qc,\xD4J\xC3`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81\x81R`\x01\x83\x01` R`@\x81 Ta\x0C\xE2WP\x81T`\x01\x81\x81\x01\x84U_\x84\x81R` \x80\x82 \x90\x93\x01\x84\x90U\x84T\x84\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x05\x8CV[P_a\x05\x8CV[``\x81_\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\r6W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T\x81R` \x01\x90`\x01\x01\x90\x80\x83\x11a\r\"W[PPPPP\x90P\x91\x90PV[_\x82_\x01\x82\x81T\x81\x10a\rWWa\rWa\x0F\xBDV[\x90_R` _ \x01T\x90P\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\t\x15W__\xFD[\x805`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\t\x15W__\xFD[____`\x80\x85\x87\x03\x12\x15a\r\xA8W__\xFD[a\r\xB1\x85a\rhV[\x93Pa\r\xBF` \x86\x01a\rhV[\x92Pa\r\xCD`@\x86\x01a\rhV[\x91Pa\r\xDB``\x86\x01a\r~V[\x90P\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15a\r\xF7W__\xFD[a\x0E\0\x83a\rhV[\x91Pa\x0E\x0E` \x84\x01a\rhV[\x90P\x92P\x92\x90PV[` \x81R_\x82Q\x80` \x84\x01R_[\x81\x81\x10\x15a\x0ECW` \x81\x86\x01\x81\x01Q`@\x86\x84\x01\x01R\x01a\x0E&V[P_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x0ErW__\xFD[a\x07\\\x82a\rhV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x0E\xB4W\x81Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x0E\x8DV[P\x93\x94\x93PPPPV[` \x81R_a\x07\\` \x83\x01\x84a\x0E{V[`@\x81R_a\x0E\xE2`@\x83\x01\x85a\x0E{V[\x82\x81\x03` \x84\x01R\x80\x84Q\x80\x83R` \x83\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0F&W\x83Q`\x01`\x01`\xE0\x1B\x03\x19\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0E\xFEV[P\x90\x96\x95PPPPPPV[___``\x84\x86\x03\x12\x15a\x0FDW__\xFD[a\x0FM\x84a\rhV[\x92Pa\x0F[` \x85\x01a\rhV[\x91Pa\x0Fi`@\x85\x01a\r~V[\x90P\x92P\x92P\x92V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R`\x01`\x01`\xE0\x1B\x03\x19\x16` \x82\x01R`@\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x05\x8CWcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`1`\x04R`$_\xFD\xFE\xA2dipfsX\"\x12 \n`\xFB\xCDJ\xB9\xE8\xC9\xB7\xEE\xD8\x0Fl\x19\xD7\x13\x87\xB7\xCF\x1D\xEE\xA1\xB9p'DG\xC6\xB5\x1D\xECadsolcC\0\x08\x1B\x003",
613 );
614 #[derive(Default, Debug, PartialEq, Eq, Hash)]
615 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
620 #[derive(Clone)]
621 pub struct AdminAlreadyPending {}
622 #[allow(
623 non_camel_case_types,
624 non_snake_case,
625 clippy::pub_underscore_fields,
626 clippy::style
627 )]
628 const _: () = {
629 use alloy::sol_types as alloy_sol_types;
630 #[doc(hidden)]
631 type UnderlyingSolTuple<'a> = ();
632 #[doc(hidden)]
633 type UnderlyingRustTuple<'a> = ();
634 #[cfg(test)]
635 #[allow(dead_code, unreachable_patterns)]
636 fn _type_assertion(
637 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
638 ) {
639 match _t {
640 alloy_sol_types::private::AssertTypeEq::<
641 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
642 >(_) => {}
643 }
644 }
645 #[automatically_derived]
646 #[doc(hidden)]
647 impl ::core::convert::From<AdminAlreadyPending> for UnderlyingRustTuple<'_> {
648 fn from(value: AdminAlreadyPending) -> Self {
649 ()
650 }
651 }
652 #[automatically_derived]
653 #[doc(hidden)]
654 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AdminAlreadyPending {
655 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
656 Self {}
657 }
658 }
659 #[automatically_derived]
660 impl alloy_sol_types::SolError for AdminAlreadyPending {
661 type Parameters<'a> = UnderlyingSolTuple<'a>;
662 type Token<'a> = <Self::Parameters<
663 'a,
664 > as alloy_sol_types::SolType>::Token<'a>;
665 const SIGNATURE: &'static str = "AdminAlreadyPending()";
666 const SELECTOR: [u8; 4] = [51u8, 87u8, 219u8, 198u8];
667 #[inline]
668 fn new<'a>(
669 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
670 ) -> Self {
671 tuple.into()
672 }
673 #[inline]
674 fn tokenize(&self) -> Self::Token<'_> {
675 ()
676 }
677 }
678 };
679 #[derive(Default, Debug, PartialEq, Eq, Hash)]
680 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
685 #[derive(Clone)]
686 pub struct AdminAlreadySet {}
687 #[allow(
688 non_camel_case_types,
689 non_snake_case,
690 clippy::pub_underscore_fields,
691 clippy::style
692 )]
693 const _: () = {
694 use alloy::sol_types as alloy_sol_types;
695 #[doc(hidden)]
696 type UnderlyingSolTuple<'a> = ();
697 #[doc(hidden)]
698 type UnderlyingRustTuple<'a> = ();
699 #[cfg(test)]
700 #[allow(dead_code, unreachable_patterns)]
701 fn _type_assertion(
702 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
703 ) {
704 match _t {
705 alloy_sol_types::private::AssertTypeEq::<
706 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
707 >(_) => {}
708 }
709 }
710 #[automatically_derived]
711 #[doc(hidden)]
712 impl ::core::convert::From<AdminAlreadySet> for UnderlyingRustTuple<'_> {
713 fn from(value: AdminAlreadySet) -> Self {
714 ()
715 }
716 }
717 #[automatically_derived]
718 #[doc(hidden)]
719 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AdminAlreadySet {
720 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
721 Self {}
722 }
723 }
724 #[automatically_derived]
725 impl alloy_sol_types::SolError for AdminAlreadySet {
726 type Parameters<'a> = UnderlyingSolTuple<'a>;
727 type Token<'a> = <Self::Parameters<
728 'a,
729 > as alloy_sol_types::SolType>::Token<'a>;
730 const SIGNATURE: &'static str = "AdminAlreadySet()";
731 const SELECTOR: [u8; 4] = [152u8, 11u8, 7u8, 40u8];
732 #[inline]
733 fn new<'a>(
734 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
735 ) -> Self {
736 tuple.into()
737 }
738 #[inline]
739 fn tokenize(&self) -> Self::Token<'_> {
740 ()
741 }
742 }
743 };
744 #[derive(Default, Debug, PartialEq, Eq, Hash)]
745 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
750 #[derive(Clone)]
751 pub struct AdminNotPending {}
752 #[allow(
753 non_camel_case_types,
754 non_snake_case,
755 clippy::pub_underscore_fields,
756 clippy::style
757 )]
758 const _: () = {
759 use alloy::sol_types as alloy_sol_types;
760 #[doc(hidden)]
761 type UnderlyingSolTuple<'a> = ();
762 #[doc(hidden)]
763 type UnderlyingRustTuple<'a> = ();
764 #[cfg(test)]
765 #[allow(dead_code, unreachable_patterns)]
766 fn _type_assertion(
767 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
768 ) {
769 match _t {
770 alloy_sol_types::private::AssertTypeEq::<
771 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
772 >(_) => {}
773 }
774 }
775 #[automatically_derived]
776 #[doc(hidden)]
777 impl ::core::convert::From<AdminNotPending> for UnderlyingRustTuple<'_> {
778 fn from(value: AdminNotPending) -> Self {
779 ()
780 }
781 }
782 #[automatically_derived]
783 #[doc(hidden)]
784 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AdminNotPending {
785 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
786 Self {}
787 }
788 }
789 #[automatically_derived]
790 impl alloy_sol_types::SolError for AdminNotPending {
791 type Parameters<'a> = UnderlyingSolTuple<'a>;
792 type Token<'a> = <Self::Parameters<
793 'a,
794 > as alloy_sol_types::SolType>::Token<'a>;
795 const SIGNATURE: &'static str = "AdminNotPending()";
796 const SELECTOR: [u8; 4] = [190u8, 216u8, 41u8, 95u8];
797 #[inline]
798 fn new<'a>(
799 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
800 ) -> Self {
801 tuple.into()
802 }
803 #[inline]
804 fn tokenize(&self) -> Self::Token<'_> {
805 ()
806 }
807 }
808 };
809 #[derive(Default, Debug, PartialEq, Eq, Hash)]
810 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
815 #[derive(Clone)]
816 pub struct AdminNotSet {}
817 #[allow(
818 non_camel_case_types,
819 non_snake_case,
820 clippy::pub_underscore_fields,
821 clippy::style
822 )]
823 const _: () = {
824 use alloy::sol_types as alloy_sol_types;
825 #[doc(hidden)]
826 type UnderlyingSolTuple<'a> = ();
827 #[doc(hidden)]
828 type UnderlyingRustTuple<'a> = ();
829 #[cfg(test)]
830 #[allow(dead_code, unreachable_patterns)]
831 fn _type_assertion(
832 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
833 ) {
834 match _t {
835 alloy_sol_types::private::AssertTypeEq::<
836 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
837 >(_) => {}
838 }
839 }
840 #[automatically_derived]
841 #[doc(hidden)]
842 impl ::core::convert::From<AdminNotSet> for UnderlyingRustTuple<'_> {
843 fn from(value: AdminNotSet) -> Self {
844 ()
845 }
846 }
847 #[automatically_derived]
848 #[doc(hidden)]
849 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AdminNotSet {
850 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
851 Self {}
852 }
853 }
854 #[automatically_derived]
855 impl alloy_sol_types::SolError for AdminNotSet {
856 type Parameters<'a> = UnderlyingSolTuple<'a>;
857 type Token<'a> = <Self::Parameters<
858 'a,
859 > as alloy_sol_types::SolType>::Token<'a>;
860 const SIGNATURE: &'static str = "AdminNotSet()";
861 const SELECTOR: [u8; 4] = [226u8, 219u8, 3u8, 96u8];
862 #[inline]
863 fn new<'a>(
864 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
865 ) -> Self {
866 tuple.into()
867 }
868 #[inline]
869 fn tokenize(&self) -> Self::Token<'_> {
870 ()
871 }
872 }
873 };
874 #[derive(Default, Debug, PartialEq, Eq, Hash)]
875 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
880 #[derive(Clone)]
881 pub struct AppointeeAlreadySet {}
882 #[allow(
883 non_camel_case_types,
884 non_snake_case,
885 clippy::pub_underscore_fields,
886 clippy::style
887 )]
888 const _: () = {
889 use alloy::sol_types as alloy_sol_types;
890 #[doc(hidden)]
891 type UnderlyingSolTuple<'a> = ();
892 #[doc(hidden)]
893 type UnderlyingRustTuple<'a> = ();
894 #[cfg(test)]
895 #[allow(dead_code, unreachable_patterns)]
896 fn _type_assertion(
897 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
898 ) {
899 match _t {
900 alloy_sol_types::private::AssertTypeEq::<
901 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
902 >(_) => {}
903 }
904 }
905 #[automatically_derived]
906 #[doc(hidden)]
907 impl ::core::convert::From<AppointeeAlreadySet> for UnderlyingRustTuple<'_> {
908 fn from(value: AppointeeAlreadySet) -> Self {
909 ()
910 }
911 }
912 #[automatically_derived]
913 #[doc(hidden)]
914 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AppointeeAlreadySet {
915 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
916 Self {}
917 }
918 }
919 #[automatically_derived]
920 impl alloy_sol_types::SolError for AppointeeAlreadySet {
921 type Parameters<'a> = UnderlyingSolTuple<'a>;
922 type Token<'a> = <Self::Parameters<
923 'a,
924 > as alloy_sol_types::SolType>::Token<'a>;
925 const SIGNATURE: &'static str = "AppointeeAlreadySet()";
926 const SELECTOR: [u8; 4] = [173u8, 142u8, 254u8, 183u8];
927 #[inline]
928 fn new<'a>(
929 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
930 ) -> Self {
931 tuple.into()
932 }
933 #[inline]
934 fn tokenize(&self) -> Self::Token<'_> {
935 ()
936 }
937 }
938 };
939 #[derive(Default, Debug, PartialEq, Eq, Hash)]
940 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
945 #[derive(Clone)]
946 pub struct AppointeeNotSet {}
947 #[allow(
948 non_camel_case_types,
949 non_snake_case,
950 clippy::pub_underscore_fields,
951 clippy::style
952 )]
953 const _: () = {
954 use alloy::sol_types as alloy_sol_types;
955 #[doc(hidden)]
956 type UnderlyingSolTuple<'a> = ();
957 #[doc(hidden)]
958 type UnderlyingRustTuple<'a> = ();
959 #[cfg(test)]
960 #[allow(dead_code, unreachable_patterns)]
961 fn _type_assertion(
962 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
963 ) {
964 match _t {
965 alloy_sol_types::private::AssertTypeEq::<
966 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
967 >(_) => {}
968 }
969 }
970 #[automatically_derived]
971 #[doc(hidden)]
972 impl ::core::convert::From<AppointeeNotSet> for UnderlyingRustTuple<'_> {
973 fn from(value: AppointeeNotSet) -> Self {
974 ()
975 }
976 }
977 #[automatically_derived]
978 #[doc(hidden)]
979 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AppointeeNotSet {
980 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
981 Self {}
982 }
983 }
984 #[automatically_derived]
985 impl alloy_sol_types::SolError for AppointeeNotSet {
986 type Parameters<'a> = UnderlyingSolTuple<'a>;
987 type Token<'a> = <Self::Parameters<
988 'a,
989 > as alloy_sol_types::SolType>::Token<'a>;
990 const SIGNATURE: &'static str = "AppointeeNotSet()";
991 const SELECTOR: [u8; 4] = [38u8, 33u8, 24u8, 205u8];
992 #[inline]
993 fn new<'a>(
994 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
995 ) -> Self {
996 tuple.into()
997 }
998 #[inline]
999 fn tokenize(&self) -> Self::Token<'_> {
1000 ()
1001 }
1002 }
1003 };
1004 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1005 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1010 #[derive(Clone)]
1011 pub struct CannotHaveZeroAdmins {}
1012 #[allow(
1013 non_camel_case_types,
1014 non_snake_case,
1015 clippy::pub_underscore_fields,
1016 clippy::style
1017 )]
1018 const _: () = {
1019 use alloy::sol_types as alloy_sol_types;
1020 #[doc(hidden)]
1021 type UnderlyingSolTuple<'a> = ();
1022 #[doc(hidden)]
1023 type UnderlyingRustTuple<'a> = ();
1024 #[cfg(test)]
1025 #[allow(dead_code, unreachable_patterns)]
1026 fn _type_assertion(
1027 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1028 ) {
1029 match _t {
1030 alloy_sol_types::private::AssertTypeEq::<
1031 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1032 >(_) => {}
1033 }
1034 }
1035 #[automatically_derived]
1036 #[doc(hidden)]
1037 impl ::core::convert::From<CannotHaveZeroAdmins> for UnderlyingRustTuple<'_> {
1038 fn from(value: CannotHaveZeroAdmins) -> Self {
1039 ()
1040 }
1041 }
1042 #[automatically_derived]
1043 #[doc(hidden)]
1044 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CannotHaveZeroAdmins {
1045 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1046 Self {}
1047 }
1048 }
1049 #[automatically_derived]
1050 impl alloy_sol_types::SolError for CannotHaveZeroAdmins {
1051 type Parameters<'a> = UnderlyingSolTuple<'a>;
1052 type Token<'a> = <Self::Parameters<
1053 'a,
1054 > as alloy_sol_types::SolType>::Token<'a>;
1055 const SIGNATURE: &'static str = "CannotHaveZeroAdmins()";
1056 const SELECTOR: [u8; 4] = [134u8, 116u8, 73u8, 88u8];
1057 #[inline]
1058 fn new<'a>(
1059 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1060 ) -> Self {
1061 tuple.into()
1062 }
1063 #[inline]
1064 fn tokenize(&self) -> Self::Token<'_> {
1065 ()
1066 }
1067 }
1068 };
1069 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1070 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1075 #[derive(Clone)]
1076 pub struct InvalidShortString {}
1077 #[allow(
1078 non_camel_case_types,
1079 non_snake_case,
1080 clippy::pub_underscore_fields,
1081 clippy::style
1082 )]
1083 const _: () = {
1084 use alloy::sol_types as alloy_sol_types;
1085 #[doc(hidden)]
1086 type UnderlyingSolTuple<'a> = ();
1087 #[doc(hidden)]
1088 type UnderlyingRustTuple<'a> = ();
1089 #[cfg(test)]
1090 #[allow(dead_code, unreachable_patterns)]
1091 fn _type_assertion(
1092 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1093 ) {
1094 match _t {
1095 alloy_sol_types::private::AssertTypeEq::<
1096 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1097 >(_) => {}
1098 }
1099 }
1100 #[automatically_derived]
1101 #[doc(hidden)]
1102 impl ::core::convert::From<InvalidShortString> for UnderlyingRustTuple<'_> {
1103 fn from(value: InvalidShortString) -> Self {
1104 ()
1105 }
1106 }
1107 #[automatically_derived]
1108 #[doc(hidden)]
1109 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidShortString {
1110 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1111 Self {}
1112 }
1113 }
1114 #[automatically_derived]
1115 impl alloy_sol_types::SolError for InvalidShortString {
1116 type Parameters<'a> = UnderlyingSolTuple<'a>;
1117 type Token<'a> = <Self::Parameters<
1118 'a,
1119 > as alloy_sol_types::SolType>::Token<'a>;
1120 const SIGNATURE: &'static str = "InvalidShortString()";
1121 const SELECTOR: [u8; 4] = [179u8, 81u8, 43u8, 12u8];
1122 #[inline]
1123 fn new<'a>(
1124 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1125 ) -> Self {
1126 tuple.into()
1127 }
1128 #[inline]
1129 fn tokenize(&self) -> Self::Token<'_> {
1130 ()
1131 }
1132 }
1133 };
1134 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1135 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1140 #[derive(Clone)]
1141 pub struct NotAdmin {}
1142 #[allow(
1143 non_camel_case_types,
1144 non_snake_case,
1145 clippy::pub_underscore_fields,
1146 clippy::style
1147 )]
1148 const _: () = {
1149 use alloy::sol_types as alloy_sol_types;
1150 #[doc(hidden)]
1151 type UnderlyingSolTuple<'a> = ();
1152 #[doc(hidden)]
1153 type UnderlyingRustTuple<'a> = ();
1154 #[cfg(test)]
1155 #[allow(dead_code, unreachable_patterns)]
1156 fn _type_assertion(
1157 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1158 ) {
1159 match _t {
1160 alloy_sol_types::private::AssertTypeEq::<
1161 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1162 >(_) => {}
1163 }
1164 }
1165 #[automatically_derived]
1166 #[doc(hidden)]
1167 impl ::core::convert::From<NotAdmin> for UnderlyingRustTuple<'_> {
1168 fn from(value: NotAdmin) -> Self {
1169 ()
1170 }
1171 }
1172 #[automatically_derived]
1173 #[doc(hidden)]
1174 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotAdmin {
1175 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1176 Self {}
1177 }
1178 }
1179 #[automatically_derived]
1180 impl alloy_sol_types::SolError for NotAdmin {
1181 type Parameters<'a> = UnderlyingSolTuple<'a>;
1182 type Token<'a> = <Self::Parameters<
1183 'a,
1184 > as alloy_sol_types::SolType>::Token<'a>;
1185 const SIGNATURE: &'static str = "NotAdmin()";
1186 const SELECTOR: [u8; 4] = [123u8, 250u8, 75u8, 159u8];
1187 #[inline]
1188 fn new<'a>(
1189 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1190 ) -> Self {
1191 tuple.into()
1192 }
1193 #[inline]
1194 fn tokenize(&self) -> Self::Token<'_> {
1195 ()
1196 }
1197 }
1198 };
1199 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1200 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1205 #[derive(Clone)]
1206 pub struct StringTooLong {
1207 #[allow(missing_docs)]
1208 pub str: alloy::sol_types::private::String,
1209 }
1210 #[allow(
1211 non_camel_case_types,
1212 non_snake_case,
1213 clippy::pub_underscore_fields,
1214 clippy::style
1215 )]
1216 const _: () = {
1217 use alloy::sol_types as alloy_sol_types;
1218 #[doc(hidden)]
1219 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1220 #[doc(hidden)]
1221 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1222 #[cfg(test)]
1223 #[allow(dead_code, unreachable_patterns)]
1224 fn _type_assertion(
1225 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1226 ) {
1227 match _t {
1228 alloy_sol_types::private::AssertTypeEq::<
1229 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1230 >(_) => {}
1231 }
1232 }
1233 #[automatically_derived]
1234 #[doc(hidden)]
1235 impl ::core::convert::From<StringTooLong> for UnderlyingRustTuple<'_> {
1236 fn from(value: StringTooLong) -> Self {
1237 (value.str,)
1238 }
1239 }
1240 #[automatically_derived]
1241 #[doc(hidden)]
1242 impl ::core::convert::From<UnderlyingRustTuple<'_>> for StringTooLong {
1243 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1244 Self { str: tuple.0 }
1245 }
1246 }
1247 #[automatically_derived]
1248 impl alloy_sol_types::SolError for StringTooLong {
1249 type Parameters<'a> = UnderlyingSolTuple<'a>;
1250 type Token<'a> = <Self::Parameters<
1251 'a,
1252 > as alloy_sol_types::SolType>::Token<'a>;
1253 const SIGNATURE: &'static str = "StringTooLong(string)";
1254 const SELECTOR: [u8; 4] = [48u8, 90u8, 39u8, 169u8];
1255 #[inline]
1256 fn new<'a>(
1257 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1258 ) -> Self {
1259 tuple.into()
1260 }
1261 #[inline]
1262 fn tokenize(&self) -> Self::Token<'_> {
1263 (
1264 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1265 &self.str,
1266 ),
1267 )
1268 }
1269 }
1270 };
1271 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1272 #[allow(
1277 non_camel_case_types,
1278 non_snake_case,
1279 clippy::pub_underscore_fields,
1280 clippy::style
1281 )]
1282 #[derive(Clone)]
1283 pub struct AdminRemoved {
1284 #[allow(missing_docs)]
1285 pub account: alloy::sol_types::private::Address,
1286 #[allow(missing_docs)]
1287 pub admin: alloy::sol_types::private::Address,
1288 }
1289 #[allow(
1290 non_camel_case_types,
1291 non_snake_case,
1292 clippy::pub_underscore_fields,
1293 clippy::style
1294 )]
1295 const _: () = {
1296 use alloy::sol_types as alloy_sol_types;
1297 #[automatically_derived]
1298 impl alloy_sol_types::SolEvent for AdminRemoved {
1299 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1300 type DataToken<'a> = <Self::DataTuple<
1301 'a,
1302 > as alloy_sol_types::SolType>::Token<'a>;
1303 type TopicList = (
1304 alloy_sol_types::sol_data::FixedBytes<32>,
1305 alloy::sol_types::sol_data::Address,
1306 );
1307 const SIGNATURE: &'static str = "AdminRemoved(address,address)";
1308 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1309 219u8, 157u8, 93u8, 49u8, 50u8, 13u8, 175u8, 91u8, 199u8, 24u8, 29u8,
1310 86u8, 91u8, 109u8, 164u8, 209u8, 46u8, 48u8, 240u8, 244u8, 213u8, 170u8,
1311 50u8, 74u8, 153u8, 36u8, 38u8, 193u8, 74u8, 29u8, 25u8, 206u8,
1312 ]);
1313 const ANONYMOUS: bool = false;
1314 #[allow(unused_variables)]
1315 #[inline]
1316 fn new(
1317 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1318 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1319 ) -> Self {
1320 Self {
1321 account: topics.1,
1322 admin: data.0,
1323 }
1324 }
1325 #[inline]
1326 fn check_signature(
1327 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1328 ) -> alloy_sol_types::Result<()> {
1329 if topics.0 != Self::SIGNATURE_HASH {
1330 return Err(
1331 alloy_sol_types::Error::invalid_event_signature_hash(
1332 Self::SIGNATURE,
1333 topics.0,
1334 Self::SIGNATURE_HASH,
1335 ),
1336 );
1337 }
1338 Ok(())
1339 }
1340 #[inline]
1341 fn tokenize_body(&self) -> Self::DataToken<'_> {
1342 (
1343 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1344 &self.admin,
1345 ),
1346 )
1347 }
1348 #[inline]
1349 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1350 (Self::SIGNATURE_HASH.into(), self.account.clone())
1351 }
1352 #[inline]
1353 fn encode_topics_raw(
1354 &self,
1355 out: &mut [alloy_sol_types::abi::token::WordToken],
1356 ) -> alloy_sol_types::Result<()> {
1357 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1358 return Err(alloy_sol_types::Error::Overrun);
1359 }
1360 out[0usize] = alloy_sol_types::abi::token::WordToken(
1361 Self::SIGNATURE_HASH,
1362 );
1363 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1364 &self.account,
1365 );
1366 Ok(())
1367 }
1368 }
1369 #[automatically_derived]
1370 impl alloy_sol_types::private::IntoLogData for AdminRemoved {
1371 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1372 From::from(self)
1373 }
1374 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1375 From::from(&self)
1376 }
1377 }
1378 #[automatically_derived]
1379 impl From<&AdminRemoved> for alloy_sol_types::private::LogData {
1380 #[inline]
1381 fn from(this: &AdminRemoved) -> alloy_sol_types::private::LogData {
1382 alloy_sol_types::SolEvent::encode_log_data(this)
1383 }
1384 }
1385 };
1386 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1387 #[allow(
1392 non_camel_case_types,
1393 non_snake_case,
1394 clippy::pub_underscore_fields,
1395 clippy::style
1396 )]
1397 #[derive(Clone)]
1398 pub struct AdminSet {
1399 #[allow(missing_docs)]
1400 pub account: alloy::sol_types::private::Address,
1401 #[allow(missing_docs)]
1402 pub admin: alloy::sol_types::private::Address,
1403 }
1404 #[allow(
1405 non_camel_case_types,
1406 non_snake_case,
1407 clippy::pub_underscore_fields,
1408 clippy::style
1409 )]
1410 const _: () = {
1411 use alloy::sol_types as alloy_sol_types;
1412 #[automatically_derived]
1413 impl alloy_sol_types::SolEvent for AdminSet {
1414 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1415 type DataToken<'a> = <Self::DataTuple<
1416 'a,
1417 > as alloy_sol_types::SolType>::Token<'a>;
1418 type TopicList = (
1419 alloy_sol_types::sol_data::FixedBytes<32>,
1420 alloy::sol_types::sol_data::Address,
1421 );
1422 const SIGNATURE: &'static str = "AdminSet(address,address)";
1423 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1424 191u8, 38u8, 94u8, 131u8, 38u8, 40u8, 90u8, 39u8, 71u8, 227u8, 62u8,
1425 84u8, 213u8, 148u8, 95u8, 113u8, 17u8, 242u8, 181u8, 237u8, 184u8, 38u8,
1426 235u8, 140u8, 8u8, 212u8, 103u8, 119u8, 121u8, 179u8, 255u8, 151u8,
1427 ]);
1428 const ANONYMOUS: bool = false;
1429 #[allow(unused_variables)]
1430 #[inline]
1431 fn new(
1432 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1433 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1434 ) -> Self {
1435 Self {
1436 account: topics.1,
1437 admin: data.0,
1438 }
1439 }
1440 #[inline]
1441 fn check_signature(
1442 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1443 ) -> alloy_sol_types::Result<()> {
1444 if topics.0 != Self::SIGNATURE_HASH {
1445 return Err(
1446 alloy_sol_types::Error::invalid_event_signature_hash(
1447 Self::SIGNATURE,
1448 topics.0,
1449 Self::SIGNATURE_HASH,
1450 ),
1451 );
1452 }
1453 Ok(())
1454 }
1455 #[inline]
1456 fn tokenize_body(&self) -> Self::DataToken<'_> {
1457 (
1458 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1459 &self.admin,
1460 ),
1461 )
1462 }
1463 #[inline]
1464 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1465 (Self::SIGNATURE_HASH.into(), self.account.clone())
1466 }
1467 #[inline]
1468 fn encode_topics_raw(
1469 &self,
1470 out: &mut [alloy_sol_types::abi::token::WordToken],
1471 ) -> alloy_sol_types::Result<()> {
1472 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1473 return Err(alloy_sol_types::Error::Overrun);
1474 }
1475 out[0usize] = alloy_sol_types::abi::token::WordToken(
1476 Self::SIGNATURE_HASH,
1477 );
1478 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1479 &self.account,
1480 );
1481 Ok(())
1482 }
1483 }
1484 #[automatically_derived]
1485 impl alloy_sol_types::private::IntoLogData for AdminSet {
1486 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1487 From::from(self)
1488 }
1489 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1490 From::from(&self)
1491 }
1492 }
1493 #[automatically_derived]
1494 impl From<&AdminSet> for alloy_sol_types::private::LogData {
1495 #[inline]
1496 fn from(this: &AdminSet) -> alloy_sol_types::private::LogData {
1497 alloy_sol_types::SolEvent::encode_log_data(this)
1498 }
1499 }
1500 };
1501 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1502 #[allow(
1507 non_camel_case_types,
1508 non_snake_case,
1509 clippy::pub_underscore_fields,
1510 clippy::style
1511 )]
1512 #[derive(Clone)]
1513 pub struct AppointeeRemoved {
1514 #[allow(missing_docs)]
1515 pub account: alloy::sol_types::private::Address,
1516 #[allow(missing_docs)]
1517 pub appointee: alloy::sol_types::private::Address,
1518 #[allow(missing_docs)]
1519 pub target: alloy::sol_types::private::Address,
1520 #[allow(missing_docs)]
1521 pub selector: alloy::sol_types::private::FixedBytes<4>,
1522 }
1523 #[allow(
1524 non_camel_case_types,
1525 non_snake_case,
1526 clippy::pub_underscore_fields,
1527 clippy::style
1528 )]
1529 const _: () = {
1530 use alloy::sol_types as alloy_sol_types;
1531 #[automatically_derived]
1532 impl alloy_sol_types::SolEvent for AppointeeRemoved {
1533 type DataTuple<'a> = (
1534 alloy::sol_types::sol_data::Address,
1535 alloy::sol_types::sol_data::FixedBytes<4>,
1536 );
1537 type DataToken<'a> = <Self::DataTuple<
1538 'a,
1539 > as alloy_sol_types::SolType>::Token<'a>;
1540 type TopicList = (
1541 alloy_sol_types::sol_data::FixedBytes<32>,
1542 alloy::sol_types::sol_data::Address,
1543 alloy::sol_types::sol_data::Address,
1544 );
1545 const SIGNATURE: &'static str = "AppointeeRemoved(address,address,address,bytes4)";
1546 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1547 24u8, 36u8, 35u8, 38u8, 182u8, 184u8, 98u8, 18u8, 105u8, 112u8, 103u8,
1548 151u8, 89u8, 22u8, 159u8, 1u8, 246u8, 70u8, 189u8, 85u8, 236u8, 91u8,
1549 252u8, 171u8, 133u8, 186u8, 159u8, 51u8, 122u8, 116u8, 224u8, 198u8,
1550 ]);
1551 const ANONYMOUS: bool = false;
1552 #[allow(unused_variables)]
1553 #[inline]
1554 fn new(
1555 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1556 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1557 ) -> Self {
1558 Self {
1559 account: topics.1,
1560 appointee: topics.2,
1561 target: data.0,
1562 selector: data.1,
1563 }
1564 }
1565 #[inline]
1566 fn check_signature(
1567 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1568 ) -> alloy_sol_types::Result<()> {
1569 if topics.0 != Self::SIGNATURE_HASH {
1570 return Err(
1571 alloy_sol_types::Error::invalid_event_signature_hash(
1572 Self::SIGNATURE,
1573 topics.0,
1574 Self::SIGNATURE_HASH,
1575 ),
1576 );
1577 }
1578 Ok(())
1579 }
1580 #[inline]
1581 fn tokenize_body(&self) -> Self::DataToken<'_> {
1582 (
1583 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1584 &self.target,
1585 ),
1586 <alloy::sol_types::sol_data::FixedBytes<
1587 4,
1588 > as alloy_sol_types::SolType>::tokenize(&self.selector),
1589 )
1590 }
1591 #[inline]
1592 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1593 (
1594 Self::SIGNATURE_HASH.into(),
1595 self.account.clone(),
1596 self.appointee.clone(),
1597 )
1598 }
1599 #[inline]
1600 fn encode_topics_raw(
1601 &self,
1602 out: &mut [alloy_sol_types::abi::token::WordToken],
1603 ) -> alloy_sol_types::Result<()> {
1604 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1605 return Err(alloy_sol_types::Error::Overrun);
1606 }
1607 out[0usize] = alloy_sol_types::abi::token::WordToken(
1608 Self::SIGNATURE_HASH,
1609 );
1610 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1611 &self.account,
1612 );
1613 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1614 &self.appointee,
1615 );
1616 Ok(())
1617 }
1618 }
1619 #[automatically_derived]
1620 impl alloy_sol_types::private::IntoLogData for AppointeeRemoved {
1621 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1622 From::from(self)
1623 }
1624 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1625 From::from(&self)
1626 }
1627 }
1628 #[automatically_derived]
1629 impl From<&AppointeeRemoved> for alloy_sol_types::private::LogData {
1630 #[inline]
1631 fn from(this: &AppointeeRemoved) -> alloy_sol_types::private::LogData {
1632 alloy_sol_types::SolEvent::encode_log_data(this)
1633 }
1634 }
1635 };
1636 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1637 #[allow(
1642 non_camel_case_types,
1643 non_snake_case,
1644 clippy::pub_underscore_fields,
1645 clippy::style
1646 )]
1647 #[derive(Clone)]
1648 pub struct AppointeeSet {
1649 #[allow(missing_docs)]
1650 pub account: alloy::sol_types::private::Address,
1651 #[allow(missing_docs)]
1652 pub appointee: alloy::sol_types::private::Address,
1653 #[allow(missing_docs)]
1654 pub target: alloy::sol_types::private::Address,
1655 #[allow(missing_docs)]
1656 pub selector: alloy::sol_types::private::FixedBytes<4>,
1657 }
1658 #[allow(
1659 non_camel_case_types,
1660 non_snake_case,
1661 clippy::pub_underscore_fields,
1662 clippy::style
1663 )]
1664 const _: () = {
1665 use alloy::sol_types as alloy_sol_types;
1666 #[automatically_derived]
1667 impl alloy_sol_types::SolEvent for AppointeeSet {
1668 type DataTuple<'a> = (
1669 alloy::sol_types::sol_data::Address,
1670 alloy::sol_types::sol_data::FixedBytes<4>,
1671 );
1672 type DataToken<'a> = <Self::DataTuple<
1673 'a,
1674 > as alloy_sol_types::SolType>::Token<'a>;
1675 type TopicList = (
1676 alloy_sol_types::sol_data::FixedBytes<32>,
1677 alloy::sol_types::sol_data::Address,
1678 alloy::sol_types::sol_data::Address,
1679 );
1680 const SIGNATURE: &'static str = "AppointeeSet(address,address,address,bytes4)";
1681 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1682 3u8, 127u8, 3u8, 162u8, 173u8, 107u8, 150u8, 125u8, 244u8, 160u8, 23u8,
1683 121u8, 182u8, 210u8, 180u8, 200u8, 89u8, 80u8, 223u8, 131u8, 146u8, 93u8,
1684 158u8, 49u8, 54u8, 43u8, 81u8, 148u8, 34u8, 252u8, 1u8, 105u8,
1685 ]);
1686 const ANONYMOUS: bool = false;
1687 #[allow(unused_variables)]
1688 #[inline]
1689 fn new(
1690 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1691 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1692 ) -> Self {
1693 Self {
1694 account: topics.1,
1695 appointee: topics.2,
1696 target: data.0,
1697 selector: data.1,
1698 }
1699 }
1700 #[inline]
1701 fn check_signature(
1702 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1703 ) -> alloy_sol_types::Result<()> {
1704 if topics.0 != Self::SIGNATURE_HASH {
1705 return Err(
1706 alloy_sol_types::Error::invalid_event_signature_hash(
1707 Self::SIGNATURE,
1708 topics.0,
1709 Self::SIGNATURE_HASH,
1710 ),
1711 );
1712 }
1713 Ok(())
1714 }
1715 #[inline]
1716 fn tokenize_body(&self) -> Self::DataToken<'_> {
1717 (
1718 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1719 &self.target,
1720 ),
1721 <alloy::sol_types::sol_data::FixedBytes<
1722 4,
1723 > as alloy_sol_types::SolType>::tokenize(&self.selector),
1724 )
1725 }
1726 #[inline]
1727 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1728 (
1729 Self::SIGNATURE_HASH.into(),
1730 self.account.clone(),
1731 self.appointee.clone(),
1732 )
1733 }
1734 #[inline]
1735 fn encode_topics_raw(
1736 &self,
1737 out: &mut [alloy_sol_types::abi::token::WordToken],
1738 ) -> alloy_sol_types::Result<()> {
1739 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1740 return Err(alloy_sol_types::Error::Overrun);
1741 }
1742 out[0usize] = alloy_sol_types::abi::token::WordToken(
1743 Self::SIGNATURE_HASH,
1744 );
1745 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1746 &self.account,
1747 );
1748 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1749 &self.appointee,
1750 );
1751 Ok(())
1752 }
1753 }
1754 #[automatically_derived]
1755 impl alloy_sol_types::private::IntoLogData for AppointeeSet {
1756 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1757 From::from(self)
1758 }
1759 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1760 From::from(&self)
1761 }
1762 }
1763 #[automatically_derived]
1764 impl From<&AppointeeSet> for alloy_sol_types::private::LogData {
1765 #[inline]
1766 fn from(this: &AppointeeSet) -> alloy_sol_types::private::LogData {
1767 alloy_sol_types::SolEvent::encode_log_data(this)
1768 }
1769 }
1770 };
1771 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1772 #[allow(
1777 non_camel_case_types,
1778 non_snake_case,
1779 clippy::pub_underscore_fields,
1780 clippy::style
1781 )]
1782 #[derive(Clone)]
1783 pub struct Initialized {
1784 #[allow(missing_docs)]
1785 pub version: u8,
1786 }
1787 #[allow(
1788 non_camel_case_types,
1789 non_snake_case,
1790 clippy::pub_underscore_fields,
1791 clippy::style
1792 )]
1793 const _: () = {
1794 use alloy::sol_types as alloy_sol_types;
1795 #[automatically_derived]
1796 impl alloy_sol_types::SolEvent for Initialized {
1797 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
1798 type DataToken<'a> = <Self::DataTuple<
1799 'a,
1800 > as alloy_sol_types::SolType>::Token<'a>;
1801 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1802 const SIGNATURE: &'static str = "Initialized(uint8)";
1803 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1804 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
1805 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
1806 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
1807 ]);
1808 const ANONYMOUS: bool = false;
1809 #[allow(unused_variables)]
1810 #[inline]
1811 fn new(
1812 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1813 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1814 ) -> Self {
1815 Self { version: data.0 }
1816 }
1817 #[inline]
1818 fn check_signature(
1819 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1820 ) -> alloy_sol_types::Result<()> {
1821 if topics.0 != Self::SIGNATURE_HASH {
1822 return Err(
1823 alloy_sol_types::Error::invalid_event_signature_hash(
1824 Self::SIGNATURE,
1825 topics.0,
1826 Self::SIGNATURE_HASH,
1827 ),
1828 );
1829 }
1830 Ok(())
1831 }
1832 #[inline]
1833 fn tokenize_body(&self) -> Self::DataToken<'_> {
1834 (
1835 <alloy::sol_types::sol_data::Uint<
1836 8,
1837 > as alloy_sol_types::SolType>::tokenize(&self.version),
1838 )
1839 }
1840 #[inline]
1841 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1842 (Self::SIGNATURE_HASH.into(),)
1843 }
1844 #[inline]
1845 fn encode_topics_raw(
1846 &self,
1847 out: &mut [alloy_sol_types::abi::token::WordToken],
1848 ) -> alloy_sol_types::Result<()> {
1849 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1850 return Err(alloy_sol_types::Error::Overrun);
1851 }
1852 out[0usize] = alloy_sol_types::abi::token::WordToken(
1853 Self::SIGNATURE_HASH,
1854 );
1855 Ok(())
1856 }
1857 }
1858 #[automatically_derived]
1859 impl alloy_sol_types::private::IntoLogData for Initialized {
1860 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1861 From::from(self)
1862 }
1863 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1864 From::from(&self)
1865 }
1866 }
1867 #[automatically_derived]
1868 impl From<&Initialized> for alloy_sol_types::private::LogData {
1869 #[inline]
1870 fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
1871 alloy_sol_types::SolEvent::encode_log_data(this)
1872 }
1873 }
1874 };
1875 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1876 #[allow(
1881 non_camel_case_types,
1882 non_snake_case,
1883 clippy::pub_underscore_fields,
1884 clippy::style
1885 )]
1886 #[derive(Clone)]
1887 pub struct PendingAdminAdded {
1888 #[allow(missing_docs)]
1889 pub account: alloy::sol_types::private::Address,
1890 #[allow(missing_docs)]
1891 pub admin: alloy::sol_types::private::Address,
1892 }
1893 #[allow(
1894 non_camel_case_types,
1895 non_snake_case,
1896 clippy::pub_underscore_fields,
1897 clippy::style
1898 )]
1899 const _: () = {
1900 use alloy::sol_types as alloy_sol_types;
1901 #[automatically_derived]
1902 impl alloy_sol_types::SolEvent for PendingAdminAdded {
1903 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1904 type DataToken<'a> = <Self::DataTuple<
1905 'a,
1906 > as alloy_sol_types::SolType>::Token<'a>;
1907 type TopicList = (
1908 alloy_sol_types::sol_data::FixedBytes<32>,
1909 alloy::sol_types::sol_data::Address,
1910 );
1911 const SIGNATURE: &'static str = "PendingAdminAdded(address,address)";
1912 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1913 177u8, 75u8, 154u8, 61u8, 68u8, 140u8, 91u8, 4u8, 240u8, 229u8, 176u8,
1914 135u8, 182u8, 245u8, 25u8, 51u8, 144u8, 219u8, 121u8, 85u8, 72u8, 42u8,
1915 111u8, 251u8, 132u8, 30u8, 123u8, 59u8, 166u8, 26u8, 70u8, 12u8,
1916 ]);
1917 const ANONYMOUS: bool = false;
1918 #[allow(unused_variables)]
1919 #[inline]
1920 fn new(
1921 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1922 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1923 ) -> Self {
1924 Self {
1925 account: topics.1,
1926 admin: data.0,
1927 }
1928 }
1929 #[inline]
1930 fn check_signature(
1931 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1932 ) -> alloy_sol_types::Result<()> {
1933 if topics.0 != Self::SIGNATURE_HASH {
1934 return Err(
1935 alloy_sol_types::Error::invalid_event_signature_hash(
1936 Self::SIGNATURE,
1937 topics.0,
1938 Self::SIGNATURE_HASH,
1939 ),
1940 );
1941 }
1942 Ok(())
1943 }
1944 #[inline]
1945 fn tokenize_body(&self) -> Self::DataToken<'_> {
1946 (
1947 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1948 &self.admin,
1949 ),
1950 )
1951 }
1952 #[inline]
1953 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1954 (Self::SIGNATURE_HASH.into(), self.account.clone())
1955 }
1956 #[inline]
1957 fn encode_topics_raw(
1958 &self,
1959 out: &mut [alloy_sol_types::abi::token::WordToken],
1960 ) -> alloy_sol_types::Result<()> {
1961 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1962 return Err(alloy_sol_types::Error::Overrun);
1963 }
1964 out[0usize] = alloy_sol_types::abi::token::WordToken(
1965 Self::SIGNATURE_HASH,
1966 );
1967 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1968 &self.account,
1969 );
1970 Ok(())
1971 }
1972 }
1973 #[automatically_derived]
1974 impl alloy_sol_types::private::IntoLogData for PendingAdminAdded {
1975 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1976 From::from(self)
1977 }
1978 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1979 From::from(&self)
1980 }
1981 }
1982 #[automatically_derived]
1983 impl From<&PendingAdminAdded> for alloy_sol_types::private::LogData {
1984 #[inline]
1985 fn from(this: &PendingAdminAdded) -> alloy_sol_types::private::LogData {
1986 alloy_sol_types::SolEvent::encode_log_data(this)
1987 }
1988 }
1989 };
1990 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1991 #[allow(
1996 non_camel_case_types,
1997 non_snake_case,
1998 clippy::pub_underscore_fields,
1999 clippy::style
2000 )]
2001 #[derive(Clone)]
2002 pub struct PendingAdminRemoved {
2003 #[allow(missing_docs)]
2004 pub account: alloy::sol_types::private::Address,
2005 #[allow(missing_docs)]
2006 pub admin: alloy::sol_types::private::Address,
2007 }
2008 #[allow(
2009 non_camel_case_types,
2010 non_snake_case,
2011 clippy::pub_underscore_fields,
2012 clippy::style
2013 )]
2014 const _: () = {
2015 use alloy::sol_types as alloy_sol_types;
2016 #[automatically_derived]
2017 impl alloy_sol_types::SolEvent for PendingAdminRemoved {
2018 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
2019 type DataToken<'a> = <Self::DataTuple<
2020 'a,
2021 > as alloy_sol_types::SolType>::Token<'a>;
2022 type TopicList = (
2023 alloy_sol_types::sol_data::FixedBytes<32>,
2024 alloy::sol_types::sol_data::Address,
2025 );
2026 const SIGNATURE: &'static str = "PendingAdminRemoved(address,address)";
2027 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2028 215u8, 6u8, 237u8, 122u8, 224u8, 68u8, 215u8, 149u8, 180u8, 158u8, 84u8,
2029 201u8, 245u8, 25u8, 246u8, 99u8, 5u8, 57u8, 81u8, 1u8, 25u8, 133u8,
2030 246u8, 99u8, 168u8, 98u8, 205u8, 158u8, 231u8, 42u8, 154u8, 199u8,
2031 ]);
2032 const ANONYMOUS: bool = false;
2033 #[allow(unused_variables)]
2034 #[inline]
2035 fn new(
2036 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2037 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2038 ) -> Self {
2039 Self {
2040 account: topics.1,
2041 admin: data.0,
2042 }
2043 }
2044 #[inline]
2045 fn check_signature(
2046 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2047 ) -> alloy_sol_types::Result<()> {
2048 if topics.0 != Self::SIGNATURE_HASH {
2049 return Err(
2050 alloy_sol_types::Error::invalid_event_signature_hash(
2051 Self::SIGNATURE,
2052 topics.0,
2053 Self::SIGNATURE_HASH,
2054 ),
2055 );
2056 }
2057 Ok(())
2058 }
2059 #[inline]
2060 fn tokenize_body(&self) -> Self::DataToken<'_> {
2061 (
2062 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2063 &self.admin,
2064 ),
2065 )
2066 }
2067 #[inline]
2068 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2069 (Self::SIGNATURE_HASH.into(), self.account.clone())
2070 }
2071 #[inline]
2072 fn encode_topics_raw(
2073 &self,
2074 out: &mut [alloy_sol_types::abi::token::WordToken],
2075 ) -> alloy_sol_types::Result<()> {
2076 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2077 return Err(alloy_sol_types::Error::Overrun);
2078 }
2079 out[0usize] = alloy_sol_types::abi::token::WordToken(
2080 Self::SIGNATURE_HASH,
2081 );
2082 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2083 &self.account,
2084 );
2085 Ok(())
2086 }
2087 }
2088 #[automatically_derived]
2089 impl alloy_sol_types::private::IntoLogData for PendingAdminRemoved {
2090 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2091 From::from(self)
2092 }
2093 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2094 From::from(&self)
2095 }
2096 }
2097 #[automatically_derived]
2098 impl From<&PendingAdminRemoved> for alloy_sol_types::private::LogData {
2099 #[inline]
2100 fn from(this: &PendingAdminRemoved) -> alloy_sol_types::private::LogData {
2101 alloy_sol_types::SolEvent::encode_log_data(this)
2102 }
2103 }
2104 };
2105 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2110 #[derive(Clone)]
2111 pub struct constructorCall {
2112 #[allow(missing_docs)]
2113 pub _version: alloy::sol_types::private::String,
2114 }
2115 const _: () = {
2116 use alloy::sol_types as alloy_sol_types;
2117 {
2118 #[doc(hidden)]
2119 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2120 #[doc(hidden)]
2121 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2122 #[cfg(test)]
2123 #[allow(dead_code, unreachable_patterns)]
2124 fn _type_assertion(
2125 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2126 ) {
2127 match _t {
2128 alloy_sol_types::private::AssertTypeEq::<
2129 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2130 >(_) => {}
2131 }
2132 }
2133 #[automatically_derived]
2134 #[doc(hidden)]
2135 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
2136 fn from(value: constructorCall) -> Self {
2137 (value._version,)
2138 }
2139 }
2140 #[automatically_derived]
2141 #[doc(hidden)]
2142 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
2143 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2144 Self { _version: tuple.0 }
2145 }
2146 }
2147 }
2148 #[automatically_derived]
2149 impl alloy_sol_types::SolConstructor for constructorCall {
2150 type Parameters<'a> = (alloy::sol_types::sol_data::String,);
2151 type Token<'a> = <Self::Parameters<
2152 'a,
2153 > as alloy_sol_types::SolType>::Token<'a>;
2154 #[inline]
2155 fn new<'a>(
2156 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2157 ) -> Self {
2158 tuple.into()
2159 }
2160 #[inline]
2161 fn tokenize(&self) -> Self::Token<'_> {
2162 (
2163 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
2164 &self._version,
2165 ),
2166 )
2167 }
2168 }
2169 };
2170 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2171 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2176 #[derive(Clone)]
2177 pub struct acceptAdminCall {
2178 #[allow(missing_docs)]
2179 pub account: alloy::sol_types::private::Address,
2180 }
2181 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2183 #[derive(Clone)]
2184 pub struct acceptAdminReturn {}
2185 #[allow(
2186 non_camel_case_types,
2187 non_snake_case,
2188 clippy::pub_underscore_fields,
2189 clippy::style
2190 )]
2191 const _: () = {
2192 use alloy::sol_types as alloy_sol_types;
2193 {
2194 #[doc(hidden)]
2195 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2196 #[doc(hidden)]
2197 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2198 #[cfg(test)]
2199 #[allow(dead_code, unreachable_patterns)]
2200 fn _type_assertion(
2201 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2202 ) {
2203 match _t {
2204 alloy_sol_types::private::AssertTypeEq::<
2205 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2206 >(_) => {}
2207 }
2208 }
2209 #[automatically_derived]
2210 #[doc(hidden)]
2211 impl ::core::convert::From<acceptAdminCall> for UnderlyingRustTuple<'_> {
2212 fn from(value: acceptAdminCall) -> Self {
2213 (value.account,)
2214 }
2215 }
2216 #[automatically_derived]
2217 #[doc(hidden)]
2218 impl ::core::convert::From<UnderlyingRustTuple<'_>> for acceptAdminCall {
2219 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2220 Self { account: tuple.0 }
2221 }
2222 }
2223 }
2224 {
2225 #[doc(hidden)]
2226 type UnderlyingSolTuple<'a> = ();
2227 #[doc(hidden)]
2228 type UnderlyingRustTuple<'a> = ();
2229 #[cfg(test)]
2230 #[allow(dead_code, unreachable_patterns)]
2231 fn _type_assertion(
2232 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2233 ) {
2234 match _t {
2235 alloy_sol_types::private::AssertTypeEq::<
2236 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2237 >(_) => {}
2238 }
2239 }
2240 #[automatically_derived]
2241 #[doc(hidden)]
2242 impl ::core::convert::From<acceptAdminReturn> for UnderlyingRustTuple<'_> {
2243 fn from(value: acceptAdminReturn) -> Self {
2244 ()
2245 }
2246 }
2247 #[automatically_derived]
2248 #[doc(hidden)]
2249 impl ::core::convert::From<UnderlyingRustTuple<'_>> for acceptAdminReturn {
2250 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2251 Self {}
2252 }
2253 }
2254 }
2255 #[automatically_derived]
2256 impl alloy_sol_types::SolCall for acceptAdminCall {
2257 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2258 type Token<'a> = <Self::Parameters<
2259 'a,
2260 > as alloy_sol_types::SolType>::Token<'a>;
2261 type Return = acceptAdminReturn;
2262 type ReturnTuple<'a> = ();
2263 type ReturnToken<'a> = <Self::ReturnTuple<
2264 'a,
2265 > as alloy_sol_types::SolType>::Token<'a>;
2266 const SIGNATURE: &'static str = "acceptAdmin(address)";
2267 const SELECTOR: [u8; 4] = [98u8, 136u8, 6u8, 239u8];
2268 #[inline]
2269 fn new<'a>(
2270 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2271 ) -> Self {
2272 tuple.into()
2273 }
2274 #[inline]
2275 fn tokenize(&self) -> Self::Token<'_> {
2276 (
2277 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2278 &self.account,
2279 ),
2280 )
2281 }
2282 #[inline]
2283 fn abi_decode_returns(
2284 data: &[u8],
2285 validate: bool,
2286 ) -> alloy_sol_types::Result<Self::Return> {
2287 <Self::ReturnTuple<
2288 '_,
2289 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2290 .map(Into::into)
2291 }
2292 }
2293 };
2294 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2295 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2300 #[derive(Clone)]
2301 pub struct addPendingAdminCall {
2302 #[allow(missing_docs)]
2303 pub account: alloy::sol_types::private::Address,
2304 #[allow(missing_docs)]
2305 pub admin: alloy::sol_types::private::Address,
2306 }
2307 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2309 #[derive(Clone)]
2310 pub struct addPendingAdminReturn {}
2311 #[allow(
2312 non_camel_case_types,
2313 non_snake_case,
2314 clippy::pub_underscore_fields,
2315 clippy::style
2316 )]
2317 const _: () = {
2318 use alloy::sol_types as alloy_sol_types;
2319 {
2320 #[doc(hidden)]
2321 type UnderlyingSolTuple<'a> = (
2322 alloy::sol_types::sol_data::Address,
2323 alloy::sol_types::sol_data::Address,
2324 );
2325 #[doc(hidden)]
2326 type UnderlyingRustTuple<'a> = (
2327 alloy::sol_types::private::Address,
2328 alloy::sol_types::private::Address,
2329 );
2330 #[cfg(test)]
2331 #[allow(dead_code, unreachable_patterns)]
2332 fn _type_assertion(
2333 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2334 ) {
2335 match _t {
2336 alloy_sol_types::private::AssertTypeEq::<
2337 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2338 >(_) => {}
2339 }
2340 }
2341 #[automatically_derived]
2342 #[doc(hidden)]
2343 impl ::core::convert::From<addPendingAdminCall> for UnderlyingRustTuple<'_> {
2344 fn from(value: addPendingAdminCall) -> Self {
2345 (value.account, value.admin)
2346 }
2347 }
2348 #[automatically_derived]
2349 #[doc(hidden)]
2350 impl ::core::convert::From<UnderlyingRustTuple<'_>> for addPendingAdminCall {
2351 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2352 Self {
2353 account: tuple.0,
2354 admin: tuple.1,
2355 }
2356 }
2357 }
2358 }
2359 {
2360 #[doc(hidden)]
2361 type UnderlyingSolTuple<'a> = ();
2362 #[doc(hidden)]
2363 type UnderlyingRustTuple<'a> = ();
2364 #[cfg(test)]
2365 #[allow(dead_code, unreachable_patterns)]
2366 fn _type_assertion(
2367 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2368 ) {
2369 match _t {
2370 alloy_sol_types::private::AssertTypeEq::<
2371 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2372 >(_) => {}
2373 }
2374 }
2375 #[automatically_derived]
2376 #[doc(hidden)]
2377 impl ::core::convert::From<addPendingAdminReturn>
2378 for UnderlyingRustTuple<'_> {
2379 fn from(value: addPendingAdminReturn) -> Self {
2380 ()
2381 }
2382 }
2383 #[automatically_derived]
2384 #[doc(hidden)]
2385 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2386 for addPendingAdminReturn {
2387 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2388 Self {}
2389 }
2390 }
2391 }
2392 #[automatically_derived]
2393 impl alloy_sol_types::SolCall for addPendingAdminCall {
2394 type Parameters<'a> = (
2395 alloy::sol_types::sol_data::Address,
2396 alloy::sol_types::sol_data::Address,
2397 );
2398 type Token<'a> = <Self::Parameters<
2399 'a,
2400 > as alloy_sol_types::SolType>::Token<'a>;
2401 type Return = addPendingAdminReturn;
2402 type ReturnTuple<'a> = ();
2403 type ReturnToken<'a> = <Self::ReturnTuple<
2404 'a,
2405 > as alloy_sol_types::SolType>::Token<'a>;
2406 const SIGNATURE: &'static str = "addPendingAdmin(address,address)";
2407 const SELECTOR: [u8; 4] = [235u8, 90u8, 78u8, 135u8];
2408 #[inline]
2409 fn new<'a>(
2410 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2411 ) -> Self {
2412 tuple.into()
2413 }
2414 #[inline]
2415 fn tokenize(&self) -> Self::Token<'_> {
2416 (
2417 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2418 &self.account,
2419 ),
2420 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2421 &self.admin,
2422 ),
2423 )
2424 }
2425 #[inline]
2426 fn abi_decode_returns(
2427 data: &[u8],
2428 validate: bool,
2429 ) -> alloy_sol_types::Result<Self::Return> {
2430 <Self::ReturnTuple<
2431 '_,
2432 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2433 .map(Into::into)
2434 }
2435 }
2436 };
2437 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2438 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2443 #[derive(Clone)]
2444 pub struct canCallCall {
2445 #[allow(missing_docs)]
2446 pub account: alloy::sol_types::private::Address,
2447 #[allow(missing_docs)]
2448 pub caller: alloy::sol_types::private::Address,
2449 #[allow(missing_docs)]
2450 pub target: alloy::sol_types::private::Address,
2451 #[allow(missing_docs)]
2452 pub selector: alloy::sol_types::private::FixedBytes<4>,
2453 }
2454 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2455 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2457 #[derive(Clone)]
2458 pub struct canCallReturn {
2459 #[allow(missing_docs)]
2460 pub _0: bool,
2461 }
2462 #[allow(
2463 non_camel_case_types,
2464 non_snake_case,
2465 clippy::pub_underscore_fields,
2466 clippy::style
2467 )]
2468 const _: () = {
2469 use alloy::sol_types as alloy_sol_types;
2470 {
2471 #[doc(hidden)]
2472 type UnderlyingSolTuple<'a> = (
2473 alloy::sol_types::sol_data::Address,
2474 alloy::sol_types::sol_data::Address,
2475 alloy::sol_types::sol_data::Address,
2476 alloy::sol_types::sol_data::FixedBytes<4>,
2477 );
2478 #[doc(hidden)]
2479 type UnderlyingRustTuple<'a> = (
2480 alloy::sol_types::private::Address,
2481 alloy::sol_types::private::Address,
2482 alloy::sol_types::private::Address,
2483 alloy::sol_types::private::FixedBytes<4>,
2484 );
2485 #[cfg(test)]
2486 #[allow(dead_code, unreachable_patterns)]
2487 fn _type_assertion(
2488 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2489 ) {
2490 match _t {
2491 alloy_sol_types::private::AssertTypeEq::<
2492 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2493 >(_) => {}
2494 }
2495 }
2496 #[automatically_derived]
2497 #[doc(hidden)]
2498 impl ::core::convert::From<canCallCall> for UnderlyingRustTuple<'_> {
2499 fn from(value: canCallCall) -> Self {
2500 (value.account, value.caller, value.target, value.selector)
2501 }
2502 }
2503 #[automatically_derived]
2504 #[doc(hidden)]
2505 impl ::core::convert::From<UnderlyingRustTuple<'_>> for canCallCall {
2506 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2507 Self {
2508 account: tuple.0,
2509 caller: tuple.1,
2510 target: tuple.2,
2511 selector: tuple.3,
2512 }
2513 }
2514 }
2515 }
2516 {
2517 #[doc(hidden)]
2518 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2519 #[doc(hidden)]
2520 type UnderlyingRustTuple<'a> = (bool,);
2521 #[cfg(test)]
2522 #[allow(dead_code, unreachable_patterns)]
2523 fn _type_assertion(
2524 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2525 ) {
2526 match _t {
2527 alloy_sol_types::private::AssertTypeEq::<
2528 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2529 >(_) => {}
2530 }
2531 }
2532 #[automatically_derived]
2533 #[doc(hidden)]
2534 impl ::core::convert::From<canCallReturn> for UnderlyingRustTuple<'_> {
2535 fn from(value: canCallReturn) -> Self {
2536 (value._0,)
2537 }
2538 }
2539 #[automatically_derived]
2540 #[doc(hidden)]
2541 impl ::core::convert::From<UnderlyingRustTuple<'_>> for canCallReturn {
2542 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2543 Self { _0: tuple.0 }
2544 }
2545 }
2546 }
2547 #[automatically_derived]
2548 impl alloy_sol_types::SolCall for canCallCall {
2549 type Parameters<'a> = (
2550 alloy::sol_types::sol_data::Address,
2551 alloy::sol_types::sol_data::Address,
2552 alloy::sol_types::sol_data::Address,
2553 alloy::sol_types::sol_data::FixedBytes<4>,
2554 );
2555 type Token<'a> = <Self::Parameters<
2556 'a,
2557 > as alloy_sol_types::SolType>::Token<'a>;
2558 type Return = canCallReturn;
2559 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2560 type ReturnToken<'a> = <Self::ReturnTuple<
2561 'a,
2562 > as alloy_sol_types::SolType>::Token<'a>;
2563 const SIGNATURE: &'static str = "canCall(address,address,address,bytes4)";
2564 const SELECTOR: [u8; 4] = [223u8, 89u8, 92u8, 184u8];
2565 #[inline]
2566 fn new<'a>(
2567 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2568 ) -> Self {
2569 tuple.into()
2570 }
2571 #[inline]
2572 fn tokenize(&self) -> Self::Token<'_> {
2573 (
2574 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2575 &self.account,
2576 ),
2577 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2578 &self.caller,
2579 ),
2580 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2581 &self.target,
2582 ),
2583 <alloy::sol_types::sol_data::FixedBytes<
2584 4,
2585 > as alloy_sol_types::SolType>::tokenize(&self.selector),
2586 )
2587 }
2588 #[inline]
2589 fn abi_decode_returns(
2590 data: &[u8],
2591 validate: bool,
2592 ) -> alloy_sol_types::Result<Self::Return> {
2593 <Self::ReturnTuple<
2594 '_,
2595 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2596 .map(Into::into)
2597 }
2598 }
2599 };
2600 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2601 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2606 #[derive(Clone)]
2607 pub struct getAdminsCall {
2608 #[allow(missing_docs)]
2609 pub account: alloy::sol_types::private::Address,
2610 }
2611 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2612 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2614 #[derive(Clone)]
2615 pub struct getAdminsReturn {
2616 #[allow(missing_docs)]
2617 pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2618 }
2619 #[allow(
2620 non_camel_case_types,
2621 non_snake_case,
2622 clippy::pub_underscore_fields,
2623 clippy::style
2624 )]
2625 const _: () = {
2626 use alloy::sol_types as alloy_sol_types;
2627 {
2628 #[doc(hidden)]
2629 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2630 #[doc(hidden)]
2631 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2632 #[cfg(test)]
2633 #[allow(dead_code, unreachable_patterns)]
2634 fn _type_assertion(
2635 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2636 ) {
2637 match _t {
2638 alloy_sol_types::private::AssertTypeEq::<
2639 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2640 >(_) => {}
2641 }
2642 }
2643 #[automatically_derived]
2644 #[doc(hidden)]
2645 impl ::core::convert::From<getAdminsCall> for UnderlyingRustTuple<'_> {
2646 fn from(value: getAdminsCall) -> Self {
2647 (value.account,)
2648 }
2649 }
2650 #[automatically_derived]
2651 #[doc(hidden)]
2652 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAdminsCall {
2653 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2654 Self { account: tuple.0 }
2655 }
2656 }
2657 }
2658 {
2659 #[doc(hidden)]
2660 type UnderlyingSolTuple<'a> = (
2661 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2662 );
2663 #[doc(hidden)]
2664 type UnderlyingRustTuple<'a> = (
2665 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2666 );
2667 #[cfg(test)]
2668 #[allow(dead_code, unreachable_patterns)]
2669 fn _type_assertion(
2670 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2671 ) {
2672 match _t {
2673 alloy_sol_types::private::AssertTypeEq::<
2674 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2675 >(_) => {}
2676 }
2677 }
2678 #[automatically_derived]
2679 #[doc(hidden)]
2680 impl ::core::convert::From<getAdminsReturn> for UnderlyingRustTuple<'_> {
2681 fn from(value: getAdminsReturn) -> Self {
2682 (value._0,)
2683 }
2684 }
2685 #[automatically_derived]
2686 #[doc(hidden)]
2687 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAdminsReturn {
2688 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2689 Self { _0: tuple.0 }
2690 }
2691 }
2692 }
2693 #[automatically_derived]
2694 impl alloy_sol_types::SolCall for getAdminsCall {
2695 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2696 type Token<'a> = <Self::Parameters<
2697 'a,
2698 > as alloy_sol_types::SolType>::Token<'a>;
2699 type Return = getAdminsReturn;
2700 type ReturnTuple<'a> = (
2701 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2702 );
2703 type ReturnToken<'a> = <Self::ReturnTuple<
2704 'a,
2705 > as alloy_sol_types::SolType>::Token<'a>;
2706 const SIGNATURE: &'static str = "getAdmins(address)";
2707 const SELECTOR: [u8; 4] = [173u8, 95u8, 34u8, 16u8];
2708 #[inline]
2709 fn new<'a>(
2710 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2711 ) -> Self {
2712 tuple.into()
2713 }
2714 #[inline]
2715 fn tokenize(&self) -> Self::Token<'_> {
2716 (
2717 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2718 &self.account,
2719 ),
2720 )
2721 }
2722 #[inline]
2723 fn abi_decode_returns(
2724 data: &[u8],
2725 validate: bool,
2726 ) -> alloy_sol_types::Result<Self::Return> {
2727 <Self::ReturnTuple<
2728 '_,
2729 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2730 .map(Into::into)
2731 }
2732 }
2733 };
2734 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2735 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2740 #[derive(Clone)]
2741 pub struct getAppointeePermissionsCall {
2742 #[allow(missing_docs)]
2743 pub account: alloy::sol_types::private::Address,
2744 #[allow(missing_docs)]
2745 pub appointee: alloy::sol_types::private::Address,
2746 }
2747 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2748 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2750 #[derive(Clone)]
2751 pub struct getAppointeePermissionsReturn {
2752 #[allow(missing_docs)]
2753 pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2754 #[allow(missing_docs)]
2755 pub _1: alloy::sol_types::private::Vec<alloy::sol_types::private::FixedBytes<4>>,
2756 }
2757 #[allow(
2758 non_camel_case_types,
2759 non_snake_case,
2760 clippy::pub_underscore_fields,
2761 clippy::style
2762 )]
2763 const _: () = {
2764 use alloy::sol_types as alloy_sol_types;
2765 {
2766 #[doc(hidden)]
2767 type UnderlyingSolTuple<'a> = (
2768 alloy::sol_types::sol_data::Address,
2769 alloy::sol_types::sol_data::Address,
2770 );
2771 #[doc(hidden)]
2772 type UnderlyingRustTuple<'a> = (
2773 alloy::sol_types::private::Address,
2774 alloy::sol_types::private::Address,
2775 );
2776 #[cfg(test)]
2777 #[allow(dead_code, unreachable_patterns)]
2778 fn _type_assertion(
2779 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2780 ) {
2781 match _t {
2782 alloy_sol_types::private::AssertTypeEq::<
2783 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2784 >(_) => {}
2785 }
2786 }
2787 #[automatically_derived]
2788 #[doc(hidden)]
2789 impl ::core::convert::From<getAppointeePermissionsCall>
2790 for UnderlyingRustTuple<'_> {
2791 fn from(value: getAppointeePermissionsCall) -> Self {
2792 (value.account, value.appointee)
2793 }
2794 }
2795 #[automatically_derived]
2796 #[doc(hidden)]
2797 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2798 for getAppointeePermissionsCall {
2799 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2800 Self {
2801 account: tuple.0,
2802 appointee: tuple.1,
2803 }
2804 }
2805 }
2806 }
2807 {
2808 #[doc(hidden)]
2809 type UnderlyingSolTuple<'a> = (
2810 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2811 alloy::sol_types::sol_data::Array<
2812 alloy::sol_types::sol_data::FixedBytes<4>,
2813 >,
2814 );
2815 #[doc(hidden)]
2816 type UnderlyingRustTuple<'a> = (
2817 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2818 alloy::sol_types::private::Vec<alloy::sol_types::private::FixedBytes<4>>,
2819 );
2820 #[cfg(test)]
2821 #[allow(dead_code, unreachable_patterns)]
2822 fn _type_assertion(
2823 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2824 ) {
2825 match _t {
2826 alloy_sol_types::private::AssertTypeEq::<
2827 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2828 >(_) => {}
2829 }
2830 }
2831 #[automatically_derived]
2832 #[doc(hidden)]
2833 impl ::core::convert::From<getAppointeePermissionsReturn>
2834 for UnderlyingRustTuple<'_> {
2835 fn from(value: getAppointeePermissionsReturn) -> Self {
2836 (value._0, value._1)
2837 }
2838 }
2839 #[automatically_derived]
2840 #[doc(hidden)]
2841 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2842 for getAppointeePermissionsReturn {
2843 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2844 Self { _0: tuple.0, _1: tuple.1 }
2845 }
2846 }
2847 }
2848 #[automatically_derived]
2849 impl alloy_sol_types::SolCall for getAppointeePermissionsCall {
2850 type Parameters<'a> = (
2851 alloy::sol_types::sol_data::Address,
2852 alloy::sol_types::sol_data::Address,
2853 );
2854 type Token<'a> = <Self::Parameters<
2855 'a,
2856 > as alloy_sol_types::SolType>::Token<'a>;
2857 type Return = getAppointeePermissionsReturn;
2858 type ReturnTuple<'a> = (
2859 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2860 alloy::sol_types::sol_data::Array<
2861 alloy::sol_types::sol_data::FixedBytes<4>,
2862 >,
2863 );
2864 type ReturnToken<'a> = <Self::ReturnTuple<
2865 'a,
2866 > as alloy_sol_types::SolType>::Token<'a>;
2867 const SIGNATURE: &'static str = "getAppointeePermissions(address,address)";
2868 const SELECTOR: [u8; 4] = [136u8, 42u8, 59u8, 56u8];
2869 #[inline]
2870 fn new<'a>(
2871 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2872 ) -> Self {
2873 tuple.into()
2874 }
2875 #[inline]
2876 fn tokenize(&self) -> Self::Token<'_> {
2877 (
2878 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2879 &self.account,
2880 ),
2881 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2882 &self.appointee,
2883 ),
2884 )
2885 }
2886 #[inline]
2887 fn abi_decode_returns(
2888 data: &[u8],
2889 validate: bool,
2890 ) -> alloy_sol_types::Result<Self::Return> {
2891 <Self::ReturnTuple<
2892 '_,
2893 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2894 .map(Into::into)
2895 }
2896 }
2897 };
2898 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2899 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2904 #[derive(Clone)]
2905 pub struct getAppointeesCall {
2906 #[allow(missing_docs)]
2907 pub account: alloy::sol_types::private::Address,
2908 #[allow(missing_docs)]
2909 pub target: alloy::sol_types::private::Address,
2910 #[allow(missing_docs)]
2911 pub selector: alloy::sol_types::private::FixedBytes<4>,
2912 }
2913 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2914 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2916 #[derive(Clone)]
2917 pub struct getAppointeesReturn {
2918 #[allow(missing_docs)]
2919 pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2920 }
2921 #[allow(
2922 non_camel_case_types,
2923 non_snake_case,
2924 clippy::pub_underscore_fields,
2925 clippy::style
2926 )]
2927 const _: () = {
2928 use alloy::sol_types as alloy_sol_types;
2929 {
2930 #[doc(hidden)]
2931 type UnderlyingSolTuple<'a> = (
2932 alloy::sol_types::sol_data::Address,
2933 alloy::sol_types::sol_data::Address,
2934 alloy::sol_types::sol_data::FixedBytes<4>,
2935 );
2936 #[doc(hidden)]
2937 type UnderlyingRustTuple<'a> = (
2938 alloy::sol_types::private::Address,
2939 alloy::sol_types::private::Address,
2940 alloy::sol_types::private::FixedBytes<4>,
2941 );
2942 #[cfg(test)]
2943 #[allow(dead_code, unreachable_patterns)]
2944 fn _type_assertion(
2945 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2946 ) {
2947 match _t {
2948 alloy_sol_types::private::AssertTypeEq::<
2949 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2950 >(_) => {}
2951 }
2952 }
2953 #[automatically_derived]
2954 #[doc(hidden)]
2955 impl ::core::convert::From<getAppointeesCall> for UnderlyingRustTuple<'_> {
2956 fn from(value: getAppointeesCall) -> Self {
2957 (value.account, value.target, value.selector)
2958 }
2959 }
2960 #[automatically_derived]
2961 #[doc(hidden)]
2962 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAppointeesCall {
2963 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2964 Self {
2965 account: tuple.0,
2966 target: tuple.1,
2967 selector: tuple.2,
2968 }
2969 }
2970 }
2971 }
2972 {
2973 #[doc(hidden)]
2974 type UnderlyingSolTuple<'a> = (
2975 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2976 );
2977 #[doc(hidden)]
2978 type UnderlyingRustTuple<'a> = (
2979 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2980 );
2981 #[cfg(test)]
2982 #[allow(dead_code, unreachable_patterns)]
2983 fn _type_assertion(
2984 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2985 ) {
2986 match _t {
2987 alloy_sol_types::private::AssertTypeEq::<
2988 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2989 >(_) => {}
2990 }
2991 }
2992 #[automatically_derived]
2993 #[doc(hidden)]
2994 impl ::core::convert::From<getAppointeesReturn> for UnderlyingRustTuple<'_> {
2995 fn from(value: getAppointeesReturn) -> Self {
2996 (value._0,)
2997 }
2998 }
2999 #[automatically_derived]
3000 #[doc(hidden)]
3001 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAppointeesReturn {
3002 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3003 Self { _0: tuple.0 }
3004 }
3005 }
3006 }
3007 #[automatically_derived]
3008 impl alloy_sol_types::SolCall for getAppointeesCall {
3009 type Parameters<'a> = (
3010 alloy::sol_types::sol_data::Address,
3011 alloy::sol_types::sol_data::Address,
3012 alloy::sol_types::sol_data::FixedBytes<4>,
3013 );
3014 type Token<'a> = <Self::Parameters<
3015 'a,
3016 > as alloy_sol_types::SolType>::Token<'a>;
3017 type Return = getAppointeesReturn;
3018 type ReturnTuple<'a> = (
3019 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3020 );
3021 type ReturnToken<'a> = <Self::ReturnTuple<
3022 'a,
3023 > as alloy_sol_types::SolType>::Token<'a>;
3024 const SIGNATURE: &'static str = "getAppointees(address,address,bytes4)";
3025 const SELECTOR: [u8; 4] = [253u8, 219u8, 222u8, 253u8];
3026 #[inline]
3027 fn new<'a>(
3028 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3029 ) -> Self {
3030 tuple.into()
3031 }
3032 #[inline]
3033 fn tokenize(&self) -> Self::Token<'_> {
3034 (
3035 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3036 &self.account,
3037 ),
3038 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3039 &self.target,
3040 ),
3041 <alloy::sol_types::sol_data::FixedBytes<
3042 4,
3043 > as alloy_sol_types::SolType>::tokenize(&self.selector),
3044 )
3045 }
3046 #[inline]
3047 fn abi_decode_returns(
3048 data: &[u8],
3049 validate: bool,
3050 ) -> alloy_sol_types::Result<Self::Return> {
3051 <Self::ReturnTuple<
3052 '_,
3053 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3054 .map(Into::into)
3055 }
3056 }
3057 };
3058 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3059 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3064 #[derive(Clone)]
3065 pub struct getPendingAdminsCall {
3066 #[allow(missing_docs)]
3067 pub account: alloy::sol_types::private::Address,
3068 }
3069 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3070 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3072 #[derive(Clone)]
3073 pub struct getPendingAdminsReturn {
3074 #[allow(missing_docs)]
3075 pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3076 }
3077 #[allow(
3078 non_camel_case_types,
3079 non_snake_case,
3080 clippy::pub_underscore_fields,
3081 clippy::style
3082 )]
3083 const _: () = {
3084 use alloy::sol_types as alloy_sol_types;
3085 {
3086 #[doc(hidden)]
3087 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3088 #[doc(hidden)]
3089 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3090 #[cfg(test)]
3091 #[allow(dead_code, unreachable_patterns)]
3092 fn _type_assertion(
3093 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3094 ) {
3095 match _t {
3096 alloy_sol_types::private::AssertTypeEq::<
3097 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3098 >(_) => {}
3099 }
3100 }
3101 #[automatically_derived]
3102 #[doc(hidden)]
3103 impl ::core::convert::From<getPendingAdminsCall>
3104 for UnderlyingRustTuple<'_> {
3105 fn from(value: getPendingAdminsCall) -> Self {
3106 (value.account,)
3107 }
3108 }
3109 #[automatically_derived]
3110 #[doc(hidden)]
3111 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3112 for getPendingAdminsCall {
3113 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3114 Self { account: tuple.0 }
3115 }
3116 }
3117 }
3118 {
3119 #[doc(hidden)]
3120 type UnderlyingSolTuple<'a> = (
3121 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3122 );
3123 #[doc(hidden)]
3124 type UnderlyingRustTuple<'a> = (
3125 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3126 );
3127 #[cfg(test)]
3128 #[allow(dead_code, unreachable_patterns)]
3129 fn _type_assertion(
3130 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3131 ) {
3132 match _t {
3133 alloy_sol_types::private::AssertTypeEq::<
3134 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3135 >(_) => {}
3136 }
3137 }
3138 #[automatically_derived]
3139 #[doc(hidden)]
3140 impl ::core::convert::From<getPendingAdminsReturn>
3141 for UnderlyingRustTuple<'_> {
3142 fn from(value: getPendingAdminsReturn) -> Self {
3143 (value._0,)
3144 }
3145 }
3146 #[automatically_derived]
3147 #[doc(hidden)]
3148 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3149 for getPendingAdminsReturn {
3150 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3151 Self { _0: tuple.0 }
3152 }
3153 }
3154 }
3155 #[automatically_derived]
3156 impl alloy_sol_types::SolCall for getPendingAdminsCall {
3157 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3158 type Token<'a> = <Self::Parameters<
3159 'a,
3160 > as alloy_sol_types::SolType>::Token<'a>;
3161 type Return = getPendingAdminsReturn;
3162 type ReturnTuple<'a> = (
3163 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3164 );
3165 type ReturnToken<'a> = <Self::ReturnTuple<
3166 'a,
3167 > as alloy_sol_types::SolType>::Token<'a>;
3168 const SIGNATURE: &'static str = "getPendingAdmins(address)";
3169 const SELECTOR: [u8; 4] = [107u8, 221u8, 250u8, 31u8];
3170 #[inline]
3171 fn new<'a>(
3172 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3173 ) -> Self {
3174 tuple.into()
3175 }
3176 #[inline]
3177 fn tokenize(&self) -> Self::Token<'_> {
3178 (
3179 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3180 &self.account,
3181 ),
3182 )
3183 }
3184 #[inline]
3185 fn abi_decode_returns(
3186 data: &[u8],
3187 validate: bool,
3188 ) -> alloy_sol_types::Result<Self::Return> {
3189 <Self::ReturnTuple<
3190 '_,
3191 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3192 .map(Into::into)
3193 }
3194 }
3195 };
3196 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3197 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3202 #[derive(Clone)]
3203 pub struct isAdminCall {
3204 #[allow(missing_docs)]
3205 pub account: alloy::sol_types::private::Address,
3206 #[allow(missing_docs)]
3207 pub caller: alloy::sol_types::private::Address,
3208 }
3209 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3210 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3212 #[derive(Clone)]
3213 pub struct isAdminReturn {
3214 #[allow(missing_docs)]
3215 pub _0: bool,
3216 }
3217 #[allow(
3218 non_camel_case_types,
3219 non_snake_case,
3220 clippy::pub_underscore_fields,
3221 clippy::style
3222 )]
3223 const _: () = {
3224 use alloy::sol_types as alloy_sol_types;
3225 {
3226 #[doc(hidden)]
3227 type UnderlyingSolTuple<'a> = (
3228 alloy::sol_types::sol_data::Address,
3229 alloy::sol_types::sol_data::Address,
3230 );
3231 #[doc(hidden)]
3232 type UnderlyingRustTuple<'a> = (
3233 alloy::sol_types::private::Address,
3234 alloy::sol_types::private::Address,
3235 );
3236 #[cfg(test)]
3237 #[allow(dead_code, unreachable_patterns)]
3238 fn _type_assertion(
3239 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3240 ) {
3241 match _t {
3242 alloy_sol_types::private::AssertTypeEq::<
3243 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3244 >(_) => {}
3245 }
3246 }
3247 #[automatically_derived]
3248 #[doc(hidden)]
3249 impl ::core::convert::From<isAdminCall> for UnderlyingRustTuple<'_> {
3250 fn from(value: isAdminCall) -> Self {
3251 (value.account, value.caller)
3252 }
3253 }
3254 #[automatically_derived]
3255 #[doc(hidden)]
3256 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isAdminCall {
3257 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3258 Self {
3259 account: tuple.0,
3260 caller: tuple.1,
3261 }
3262 }
3263 }
3264 }
3265 {
3266 #[doc(hidden)]
3267 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3268 #[doc(hidden)]
3269 type UnderlyingRustTuple<'a> = (bool,);
3270 #[cfg(test)]
3271 #[allow(dead_code, unreachable_patterns)]
3272 fn _type_assertion(
3273 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3274 ) {
3275 match _t {
3276 alloy_sol_types::private::AssertTypeEq::<
3277 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3278 >(_) => {}
3279 }
3280 }
3281 #[automatically_derived]
3282 #[doc(hidden)]
3283 impl ::core::convert::From<isAdminReturn> for UnderlyingRustTuple<'_> {
3284 fn from(value: isAdminReturn) -> Self {
3285 (value._0,)
3286 }
3287 }
3288 #[automatically_derived]
3289 #[doc(hidden)]
3290 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isAdminReturn {
3291 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3292 Self { _0: tuple.0 }
3293 }
3294 }
3295 }
3296 #[automatically_derived]
3297 impl alloy_sol_types::SolCall for isAdminCall {
3298 type Parameters<'a> = (
3299 alloy::sol_types::sol_data::Address,
3300 alloy::sol_types::sol_data::Address,
3301 );
3302 type Token<'a> = <Self::Parameters<
3303 'a,
3304 > as alloy_sol_types::SolType>::Token<'a>;
3305 type Return = isAdminReturn;
3306 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3307 type ReturnToken<'a> = <Self::ReturnTuple<
3308 'a,
3309 > as alloy_sol_types::SolType>::Token<'a>;
3310 const SIGNATURE: &'static str = "isAdmin(address,address)";
3311 const SELECTOR: [u8; 4] = [145u8, 0u8, 103u8, 69u8];
3312 #[inline]
3313 fn new<'a>(
3314 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3315 ) -> Self {
3316 tuple.into()
3317 }
3318 #[inline]
3319 fn tokenize(&self) -> Self::Token<'_> {
3320 (
3321 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3322 &self.account,
3323 ),
3324 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3325 &self.caller,
3326 ),
3327 )
3328 }
3329 #[inline]
3330 fn abi_decode_returns(
3331 data: &[u8],
3332 validate: bool,
3333 ) -> alloy_sol_types::Result<Self::Return> {
3334 <Self::ReturnTuple<
3335 '_,
3336 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3337 .map(Into::into)
3338 }
3339 }
3340 };
3341 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3342 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3347 #[derive(Clone)]
3348 pub struct isPendingAdminCall {
3349 #[allow(missing_docs)]
3350 pub account: alloy::sol_types::private::Address,
3351 #[allow(missing_docs)]
3352 pub pendingAdmin: alloy::sol_types::private::Address,
3353 }
3354 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3355 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3357 #[derive(Clone)]
3358 pub struct isPendingAdminReturn {
3359 #[allow(missing_docs)]
3360 pub _0: bool,
3361 }
3362 #[allow(
3363 non_camel_case_types,
3364 non_snake_case,
3365 clippy::pub_underscore_fields,
3366 clippy::style
3367 )]
3368 const _: () = {
3369 use alloy::sol_types as alloy_sol_types;
3370 {
3371 #[doc(hidden)]
3372 type UnderlyingSolTuple<'a> = (
3373 alloy::sol_types::sol_data::Address,
3374 alloy::sol_types::sol_data::Address,
3375 );
3376 #[doc(hidden)]
3377 type UnderlyingRustTuple<'a> = (
3378 alloy::sol_types::private::Address,
3379 alloy::sol_types::private::Address,
3380 );
3381 #[cfg(test)]
3382 #[allow(dead_code, unreachable_patterns)]
3383 fn _type_assertion(
3384 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3385 ) {
3386 match _t {
3387 alloy_sol_types::private::AssertTypeEq::<
3388 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3389 >(_) => {}
3390 }
3391 }
3392 #[automatically_derived]
3393 #[doc(hidden)]
3394 impl ::core::convert::From<isPendingAdminCall> for UnderlyingRustTuple<'_> {
3395 fn from(value: isPendingAdminCall) -> Self {
3396 (value.account, value.pendingAdmin)
3397 }
3398 }
3399 #[automatically_derived]
3400 #[doc(hidden)]
3401 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPendingAdminCall {
3402 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3403 Self {
3404 account: tuple.0,
3405 pendingAdmin: tuple.1,
3406 }
3407 }
3408 }
3409 }
3410 {
3411 #[doc(hidden)]
3412 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3413 #[doc(hidden)]
3414 type UnderlyingRustTuple<'a> = (bool,);
3415 #[cfg(test)]
3416 #[allow(dead_code, unreachable_patterns)]
3417 fn _type_assertion(
3418 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3419 ) {
3420 match _t {
3421 alloy_sol_types::private::AssertTypeEq::<
3422 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3423 >(_) => {}
3424 }
3425 }
3426 #[automatically_derived]
3427 #[doc(hidden)]
3428 impl ::core::convert::From<isPendingAdminReturn>
3429 for UnderlyingRustTuple<'_> {
3430 fn from(value: isPendingAdminReturn) -> Self {
3431 (value._0,)
3432 }
3433 }
3434 #[automatically_derived]
3435 #[doc(hidden)]
3436 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3437 for isPendingAdminReturn {
3438 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3439 Self { _0: tuple.0 }
3440 }
3441 }
3442 }
3443 #[automatically_derived]
3444 impl alloy_sol_types::SolCall for isPendingAdminCall {
3445 type Parameters<'a> = (
3446 alloy::sol_types::sol_data::Address,
3447 alloy::sol_types::sol_data::Address,
3448 );
3449 type Token<'a> = <Self::Parameters<
3450 'a,
3451 > as alloy_sol_types::SolType>::Token<'a>;
3452 type Return = isPendingAdminReturn;
3453 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3454 type ReturnToken<'a> = <Self::ReturnTuple<
3455 'a,
3456 > as alloy_sol_types::SolType>::Token<'a>;
3457 const SIGNATURE: &'static str = "isPendingAdmin(address,address)";
3458 const SELECTOR: [u8; 4] = [173u8, 138u8, 202u8, 119u8];
3459 #[inline]
3460 fn new<'a>(
3461 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3462 ) -> Self {
3463 tuple.into()
3464 }
3465 #[inline]
3466 fn tokenize(&self) -> Self::Token<'_> {
3467 (
3468 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3469 &self.account,
3470 ),
3471 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3472 &self.pendingAdmin,
3473 ),
3474 )
3475 }
3476 #[inline]
3477 fn abi_decode_returns(
3478 data: &[u8],
3479 validate: bool,
3480 ) -> alloy_sol_types::Result<Self::Return> {
3481 <Self::ReturnTuple<
3482 '_,
3483 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3484 .map(Into::into)
3485 }
3486 }
3487 };
3488 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3489 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3494 #[derive(Clone)]
3495 pub struct removeAdminCall {
3496 #[allow(missing_docs)]
3497 pub account: alloy::sol_types::private::Address,
3498 #[allow(missing_docs)]
3499 pub admin: alloy::sol_types::private::Address,
3500 }
3501 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3503 #[derive(Clone)]
3504 pub struct removeAdminReturn {}
3505 #[allow(
3506 non_camel_case_types,
3507 non_snake_case,
3508 clippy::pub_underscore_fields,
3509 clippy::style
3510 )]
3511 const _: () = {
3512 use alloy::sol_types as alloy_sol_types;
3513 {
3514 #[doc(hidden)]
3515 type UnderlyingSolTuple<'a> = (
3516 alloy::sol_types::sol_data::Address,
3517 alloy::sol_types::sol_data::Address,
3518 );
3519 #[doc(hidden)]
3520 type UnderlyingRustTuple<'a> = (
3521 alloy::sol_types::private::Address,
3522 alloy::sol_types::private::Address,
3523 );
3524 #[cfg(test)]
3525 #[allow(dead_code, unreachable_patterns)]
3526 fn _type_assertion(
3527 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3528 ) {
3529 match _t {
3530 alloy_sol_types::private::AssertTypeEq::<
3531 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3532 >(_) => {}
3533 }
3534 }
3535 #[automatically_derived]
3536 #[doc(hidden)]
3537 impl ::core::convert::From<removeAdminCall> for UnderlyingRustTuple<'_> {
3538 fn from(value: removeAdminCall) -> Self {
3539 (value.account, value.admin)
3540 }
3541 }
3542 #[automatically_derived]
3543 #[doc(hidden)]
3544 impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAdminCall {
3545 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3546 Self {
3547 account: tuple.0,
3548 admin: tuple.1,
3549 }
3550 }
3551 }
3552 }
3553 {
3554 #[doc(hidden)]
3555 type UnderlyingSolTuple<'a> = ();
3556 #[doc(hidden)]
3557 type UnderlyingRustTuple<'a> = ();
3558 #[cfg(test)]
3559 #[allow(dead_code, unreachable_patterns)]
3560 fn _type_assertion(
3561 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3562 ) {
3563 match _t {
3564 alloy_sol_types::private::AssertTypeEq::<
3565 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3566 >(_) => {}
3567 }
3568 }
3569 #[automatically_derived]
3570 #[doc(hidden)]
3571 impl ::core::convert::From<removeAdminReturn> for UnderlyingRustTuple<'_> {
3572 fn from(value: removeAdminReturn) -> Self {
3573 ()
3574 }
3575 }
3576 #[automatically_derived]
3577 #[doc(hidden)]
3578 impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAdminReturn {
3579 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3580 Self {}
3581 }
3582 }
3583 }
3584 #[automatically_derived]
3585 impl alloy_sol_types::SolCall for removeAdminCall {
3586 type Parameters<'a> = (
3587 alloy::sol_types::sol_data::Address,
3588 alloy::sol_types::sol_data::Address,
3589 );
3590 type Token<'a> = <Self::Parameters<
3591 'a,
3592 > as alloy_sol_types::SolType>::Token<'a>;
3593 type Return = removeAdminReturn;
3594 type ReturnTuple<'a> = ();
3595 type ReturnToken<'a> = <Self::ReturnTuple<
3596 'a,
3597 > as alloy_sol_types::SolType>::Token<'a>;
3598 const SIGNATURE: &'static str = "removeAdmin(address,address)";
3599 const SELECTOR: [u8; 4] = [38u8, 137u8, 89u8, 229u8];
3600 #[inline]
3601 fn new<'a>(
3602 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3603 ) -> Self {
3604 tuple.into()
3605 }
3606 #[inline]
3607 fn tokenize(&self) -> Self::Token<'_> {
3608 (
3609 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3610 &self.account,
3611 ),
3612 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3613 &self.admin,
3614 ),
3615 )
3616 }
3617 #[inline]
3618 fn abi_decode_returns(
3619 data: &[u8],
3620 validate: bool,
3621 ) -> alloy_sol_types::Result<Self::Return> {
3622 <Self::ReturnTuple<
3623 '_,
3624 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3625 .map(Into::into)
3626 }
3627 }
3628 };
3629 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3630 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3635 #[derive(Clone)]
3636 pub struct removeAppointeeCall {
3637 #[allow(missing_docs)]
3638 pub account: alloy::sol_types::private::Address,
3639 #[allow(missing_docs)]
3640 pub appointee: alloy::sol_types::private::Address,
3641 #[allow(missing_docs)]
3642 pub target: alloy::sol_types::private::Address,
3643 #[allow(missing_docs)]
3644 pub selector: alloy::sol_types::private::FixedBytes<4>,
3645 }
3646 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3648 #[derive(Clone)]
3649 pub struct removeAppointeeReturn {}
3650 #[allow(
3651 non_camel_case_types,
3652 non_snake_case,
3653 clippy::pub_underscore_fields,
3654 clippy::style
3655 )]
3656 const _: () = {
3657 use alloy::sol_types as alloy_sol_types;
3658 {
3659 #[doc(hidden)]
3660 type UnderlyingSolTuple<'a> = (
3661 alloy::sol_types::sol_data::Address,
3662 alloy::sol_types::sol_data::Address,
3663 alloy::sol_types::sol_data::Address,
3664 alloy::sol_types::sol_data::FixedBytes<4>,
3665 );
3666 #[doc(hidden)]
3667 type UnderlyingRustTuple<'a> = (
3668 alloy::sol_types::private::Address,
3669 alloy::sol_types::private::Address,
3670 alloy::sol_types::private::Address,
3671 alloy::sol_types::private::FixedBytes<4>,
3672 );
3673 #[cfg(test)]
3674 #[allow(dead_code, unreachable_patterns)]
3675 fn _type_assertion(
3676 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3677 ) {
3678 match _t {
3679 alloy_sol_types::private::AssertTypeEq::<
3680 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3681 >(_) => {}
3682 }
3683 }
3684 #[automatically_derived]
3685 #[doc(hidden)]
3686 impl ::core::convert::From<removeAppointeeCall> for UnderlyingRustTuple<'_> {
3687 fn from(value: removeAppointeeCall) -> Self {
3688 (value.account, value.appointee, value.target, value.selector)
3689 }
3690 }
3691 #[automatically_derived]
3692 #[doc(hidden)]
3693 impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAppointeeCall {
3694 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3695 Self {
3696 account: tuple.0,
3697 appointee: tuple.1,
3698 target: tuple.2,
3699 selector: tuple.3,
3700 }
3701 }
3702 }
3703 }
3704 {
3705 #[doc(hidden)]
3706 type UnderlyingSolTuple<'a> = ();
3707 #[doc(hidden)]
3708 type UnderlyingRustTuple<'a> = ();
3709 #[cfg(test)]
3710 #[allow(dead_code, unreachable_patterns)]
3711 fn _type_assertion(
3712 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3713 ) {
3714 match _t {
3715 alloy_sol_types::private::AssertTypeEq::<
3716 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3717 >(_) => {}
3718 }
3719 }
3720 #[automatically_derived]
3721 #[doc(hidden)]
3722 impl ::core::convert::From<removeAppointeeReturn>
3723 for UnderlyingRustTuple<'_> {
3724 fn from(value: removeAppointeeReturn) -> Self {
3725 ()
3726 }
3727 }
3728 #[automatically_derived]
3729 #[doc(hidden)]
3730 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3731 for removeAppointeeReturn {
3732 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3733 Self {}
3734 }
3735 }
3736 }
3737 #[automatically_derived]
3738 impl alloy_sol_types::SolCall for removeAppointeeCall {
3739 type Parameters<'a> = (
3740 alloy::sol_types::sol_data::Address,
3741 alloy::sol_types::sol_data::Address,
3742 alloy::sol_types::sol_data::Address,
3743 alloy::sol_types::sol_data::FixedBytes<4>,
3744 );
3745 type Token<'a> = <Self::Parameters<
3746 'a,
3747 > as alloy_sol_types::SolType>::Token<'a>;
3748 type Return = removeAppointeeReturn;
3749 type ReturnTuple<'a> = ();
3750 type ReturnToken<'a> = <Self::ReturnTuple<
3751 'a,
3752 > as alloy_sol_types::SolType>::Token<'a>;
3753 const SIGNATURE: &'static str = "removeAppointee(address,address,address,bytes4)";
3754 const SELECTOR: [u8; 4] = [6u8, 100u8, 18u8, 1u8];
3755 #[inline]
3756 fn new<'a>(
3757 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3758 ) -> Self {
3759 tuple.into()
3760 }
3761 #[inline]
3762 fn tokenize(&self) -> Self::Token<'_> {
3763 (
3764 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3765 &self.account,
3766 ),
3767 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3768 &self.appointee,
3769 ),
3770 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3771 &self.target,
3772 ),
3773 <alloy::sol_types::sol_data::FixedBytes<
3774 4,
3775 > as alloy_sol_types::SolType>::tokenize(&self.selector),
3776 )
3777 }
3778 #[inline]
3779 fn abi_decode_returns(
3780 data: &[u8],
3781 validate: bool,
3782 ) -> alloy_sol_types::Result<Self::Return> {
3783 <Self::ReturnTuple<
3784 '_,
3785 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3786 .map(Into::into)
3787 }
3788 }
3789 };
3790 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3791 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3796 #[derive(Clone)]
3797 pub struct removePendingAdminCall {
3798 #[allow(missing_docs)]
3799 pub account: alloy::sol_types::private::Address,
3800 #[allow(missing_docs)]
3801 pub admin: alloy::sol_types::private::Address,
3802 }
3803 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3805 #[derive(Clone)]
3806 pub struct removePendingAdminReturn {}
3807 #[allow(
3808 non_camel_case_types,
3809 non_snake_case,
3810 clippy::pub_underscore_fields,
3811 clippy::style
3812 )]
3813 const _: () = {
3814 use alloy::sol_types as alloy_sol_types;
3815 {
3816 #[doc(hidden)]
3817 type UnderlyingSolTuple<'a> = (
3818 alloy::sol_types::sol_data::Address,
3819 alloy::sol_types::sol_data::Address,
3820 );
3821 #[doc(hidden)]
3822 type UnderlyingRustTuple<'a> = (
3823 alloy::sol_types::private::Address,
3824 alloy::sol_types::private::Address,
3825 );
3826 #[cfg(test)]
3827 #[allow(dead_code, unreachable_patterns)]
3828 fn _type_assertion(
3829 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3830 ) {
3831 match _t {
3832 alloy_sol_types::private::AssertTypeEq::<
3833 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3834 >(_) => {}
3835 }
3836 }
3837 #[automatically_derived]
3838 #[doc(hidden)]
3839 impl ::core::convert::From<removePendingAdminCall>
3840 for UnderlyingRustTuple<'_> {
3841 fn from(value: removePendingAdminCall) -> Self {
3842 (value.account, value.admin)
3843 }
3844 }
3845 #[automatically_derived]
3846 #[doc(hidden)]
3847 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3848 for removePendingAdminCall {
3849 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3850 Self {
3851 account: tuple.0,
3852 admin: tuple.1,
3853 }
3854 }
3855 }
3856 }
3857 {
3858 #[doc(hidden)]
3859 type UnderlyingSolTuple<'a> = ();
3860 #[doc(hidden)]
3861 type UnderlyingRustTuple<'a> = ();
3862 #[cfg(test)]
3863 #[allow(dead_code, unreachable_patterns)]
3864 fn _type_assertion(
3865 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3866 ) {
3867 match _t {
3868 alloy_sol_types::private::AssertTypeEq::<
3869 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3870 >(_) => {}
3871 }
3872 }
3873 #[automatically_derived]
3874 #[doc(hidden)]
3875 impl ::core::convert::From<removePendingAdminReturn>
3876 for UnderlyingRustTuple<'_> {
3877 fn from(value: removePendingAdminReturn) -> Self {
3878 ()
3879 }
3880 }
3881 #[automatically_derived]
3882 #[doc(hidden)]
3883 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3884 for removePendingAdminReturn {
3885 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3886 Self {}
3887 }
3888 }
3889 }
3890 #[automatically_derived]
3891 impl alloy_sol_types::SolCall for removePendingAdminCall {
3892 type Parameters<'a> = (
3893 alloy::sol_types::sol_data::Address,
3894 alloy::sol_types::sol_data::Address,
3895 );
3896 type Token<'a> = <Self::Parameters<
3897 'a,
3898 > as alloy_sol_types::SolType>::Token<'a>;
3899 type Return = removePendingAdminReturn;
3900 type ReturnTuple<'a> = ();
3901 type ReturnToken<'a> = <Self::ReturnTuple<
3902 'a,
3903 > as alloy_sol_types::SolType>::Token<'a>;
3904 const SIGNATURE: &'static str = "removePendingAdmin(address,address)";
3905 const SELECTOR: [u8; 4] = [79u8, 144u8, 108u8, 249u8];
3906 #[inline]
3907 fn new<'a>(
3908 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3909 ) -> Self {
3910 tuple.into()
3911 }
3912 #[inline]
3913 fn tokenize(&self) -> Self::Token<'_> {
3914 (
3915 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3916 &self.account,
3917 ),
3918 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3919 &self.admin,
3920 ),
3921 )
3922 }
3923 #[inline]
3924 fn abi_decode_returns(
3925 data: &[u8],
3926 validate: bool,
3927 ) -> alloy_sol_types::Result<Self::Return> {
3928 <Self::ReturnTuple<
3929 '_,
3930 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3931 .map(Into::into)
3932 }
3933 }
3934 };
3935 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3936 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3941 #[derive(Clone)]
3942 pub struct setAppointeeCall {
3943 #[allow(missing_docs)]
3944 pub account: alloy::sol_types::private::Address,
3945 #[allow(missing_docs)]
3946 pub appointee: alloy::sol_types::private::Address,
3947 #[allow(missing_docs)]
3948 pub target: alloy::sol_types::private::Address,
3949 #[allow(missing_docs)]
3950 pub selector: alloy::sol_types::private::FixedBytes<4>,
3951 }
3952 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3954 #[derive(Clone)]
3955 pub struct setAppointeeReturn {}
3956 #[allow(
3957 non_camel_case_types,
3958 non_snake_case,
3959 clippy::pub_underscore_fields,
3960 clippy::style
3961 )]
3962 const _: () = {
3963 use alloy::sol_types as alloy_sol_types;
3964 {
3965 #[doc(hidden)]
3966 type UnderlyingSolTuple<'a> = (
3967 alloy::sol_types::sol_data::Address,
3968 alloy::sol_types::sol_data::Address,
3969 alloy::sol_types::sol_data::Address,
3970 alloy::sol_types::sol_data::FixedBytes<4>,
3971 );
3972 #[doc(hidden)]
3973 type UnderlyingRustTuple<'a> = (
3974 alloy::sol_types::private::Address,
3975 alloy::sol_types::private::Address,
3976 alloy::sol_types::private::Address,
3977 alloy::sol_types::private::FixedBytes<4>,
3978 );
3979 #[cfg(test)]
3980 #[allow(dead_code, unreachable_patterns)]
3981 fn _type_assertion(
3982 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3983 ) {
3984 match _t {
3985 alloy_sol_types::private::AssertTypeEq::<
3986 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3987 >(_) => {}
3988 }
3989 }
3990 #[automatically_derived]
3991 #[doc(hidden)]
3992 impl ::core::convert::From<setAppointeeCall> for UnderlyingRustTuple<'_> {
3993 fn from(value: setAppointeeCall) -> Self {
3994 (value.account, value.appointee, value.target, value.selector)
3995 }
3996 }
3997 #[automatically_derived]
3998 #[doc(hidden)]
3999 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppointeeCall {
4000 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4001 Self {
4002 account: tuple.0,
4003 appointee: tuple.1,
4004 target: tuple.2,
4005 selector: tuple.3,
4006 }
4007 }
4008 }
4009 }
4010 {
4011 #[doc(hidden)]
4012 type UnderlyingSolTuple<'a> = ();
4013 #[doc(hidden)]
4014 type UnderlyingRustTuple<'a> = ();
4015 #[cfg(test)]
4016 #[allow(dead_code, unreachable_patterns)]
4017 fn _type_assertion(
4018 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4019 ) {
4020 match _t {
4021 alloy_sol_types::private::AssertTypeEq::<
4022 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4023 >(_) => {}
4024 }
4025 }
4026 #[automatically_derived]
4027 #[doc(hidden)]
4028 impl ::core::convert::From<setAppointeeReturn> for UnderlyingRustTuple<'_> {
4029 fn from(value: setAppointeeReturn) -> Self {
4030 ()
4031 }
4032 }
4033 #[automatically_derived]
4034 #[doc(hidden)]
4035 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppointeeReturn {
4036 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4037 Self {}
4038 }
4039 }
4040 }
4041 #[automatically_derived]
4042 impl alloy_sol_types::SolCall for setAppointeeCall {
4043 type Parameters<'a> = (
4044 alloy::sol_types::sol_data::Address,
4045 alloy::sol_types::sol_data::Address,
4046 alloy::sol_types::sol_data::Address,
4047 alloy::sol_types::sol_data::FixedBytes<4>,
4048 );
4049 type Token<'a> = <Self::Parameters<
4050 'a,
4051 > as alloy_sol_types::SolType>::Token<'a>;
4052 type Return = setAppointeeReturn;
4053 type ReturnTuple<'a> = ();
4054 type ReturnToken<'a> = <Self::ReturnTuple<
4055 'a,
4056 > as alloy_sol_types::SolType>::Token<'a>;
4057 const SIGNATURE: &'static str = "setAppointee(address,address,address,bytes4)";
4058 const SELECTOR: [u8; 4] = [149u8, 13u8, 128u8, 110u8];
4059 #[inline]
4060 fn new<'a>(
4061 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4062 ) -> Self {
4063 tuple.into()
4064 }
4065 #[inline]
4066 fn tokenize(&self) -> Self::Token<'_> {
4067 (
4068 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4069 &self.account,
4070 ),
4071 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4072 &self.appointee,
4073 ),
4074 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4075 &self.target,
4076 ),
4077 <alloy::sol_types::sol_data::FixedBytes<
4078 4,
4079 > as alloy_sol_types::SolType>::tokenize(&self.selector),
4080 )
4081 }
4082 #[inline]
4083 fn abi_decode_returns(
4084 data: &[u8],
4085 validate: bool,
4086 ) -> alloy_sol_types::Result<Self::Return> {
4087 <Self::ReturnTuple<
4088 '_,
4089 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4090 .map(Into::into)
4091 }
4092 }
4093 };
4094 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4095 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4100 #[derive(Clone)]
4101 pub struct versionCall {}
4102 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4103 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4105 #[derive(Clone)]
4106 pub struct versionReturn {
4107 #[allow(missing_docs)]
4108 pub _0: alloy::sol_types::private::String,
4109 }
4110 #[allow(
4111 non_camel_case_types,
4112 non_snake_case,
4113 clippy::pub_underscore_fields,
4114 clippy::style
4115 )]
4116 const _: () = {
4117 use alloy::sol_types as alloy_sol_types;
4118 {
4119 #[doc(hidden)]
4120 type UnderlyingSolTuple<'a> = ();
4121 #[doc(hidden)]
4122 type UnderlyingRustTuple<'a> = ();
4123 #[cfg(test)]
4124 #[allow(dead_code, unreachable_patterns)]
4125 fn _type_assertion(
4126 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4127 ) {
4128 match _t {
4129 alloy_sol_types::private::AssertTypeEq::<
4130 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4131 >(_) => {}
4132 }
4133 }
4134 #[automatically_derived]
4135 #[doc(hidden)]
4136 impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
4137 fn from(value: versionCall) -> Self {
4138 ()
4139 }
4140 }
4141 #[automatically_derived]
4142 #[doc(hidden)]
4143 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
4144 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4145 Self {}
4146 }
4147 }
4148 }
4149 {
4150 #[doc(hidden)]
4151 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
4152 #[doc(hidden)]
4153 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
4154 #[cfg(test)]
4155 #[allow(dead_code, unreachable_patterns)]
4156 fn _type_assertion(
4157 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4158 ) {
4159 match _t {
4160 alloy_sol_types::private::AssertTypeEq::<
4161 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4162 >(_) => {}
4163 }
4164 }
4165 #[automatically_derived]
4166 #[doc(hidden)]
4167 impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
4168 fn from(value: versionReturn) -> Self {
4169 (value._0,)
4170 }
4171 }
4172 #[automatically_derived]
4173 #[doc(hidden)]
4174 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
4175 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4176 Self { _0: tuple.0 }
4177 }
4178 }
4179 }
4180 #[automatically_derived]
4181 impl alloy_sol_types::SolCall for versionCall {
4182 type Parameters<'a> = ();
4183 type Token<'a> = <Self::Parameters<
4184 'a,
4185 > as alloy_sol_types::SolType>::Token<'a>;
4186 type Return = versionReturn;
4187 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
4188 type ReturnToken<'a> = <Self::ReturnTuple<
4189 'a,
4190 > as alloy_sol_types::SolType>::Token<'a>;
4191 const SIGNATURE: &'static str = "version()";
4192 const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
4193 #[inline]
4194 fn new<'a>(
4195 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4196 ) -> Self {
4197 tuple.into()
4198 }
4199 #[inline]
4200 fn tokenize(&self) -> Self::Token<'_> {
4201 ()
4202 }
4203 #[inline]
4204 fn abi_decode_returns(
4205 data: &[u8],
4206 validate: bool,
4207 ) -> alloy_sol_types::Result<Self::Return> {
4208 <Self::ReturnTuple<
4209 '_,
4210 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4211 .map(Into::into)
4212 }
4213 }
4214 };
4215 #[derive()]
4217 pub enum PermissionControllerCalls {
4218 #[allow(missing_docs)]
4219 acceptAdmin(acceptAdminCall),
4220 #[allow(missing_docs)]
4221 addPendingAdmin(addPendingAdminCall),
4222 #[allow(missing_docs)]
4223 canCall(canCallCall),
4224 #[allow(missing_docs)]
4225 getAdmins(getAdminsCall),
4226 #[allow(missing_docs)]
4227 getAppointeePermissions(getAppointeePermissionsCall),
4228 #[allow(missing_docs)]
4229 getAppointees(getAppointeesCall),
4230 #[allow(missing_docs)]
4231 getPendingAdmins(getPendingAdminsCall),
4232 #[allow(missing_docs)]
4233 isAdmin(isAdminCall),
4234 #[allow(missing_docs)]
4235 isPendingAdmin(isPendingAdminCall),
4236 #[allow(missing_docs)]
4237 removeAdmin(removeAdminCall),
4238 #[allow(missing_docs)]
4239 removeAppointee(removeAppointeeCall),
4240 #[allow(missing_docs)]
4241 removePendingAdmin(removePendingAdminCall),
4242 #[allow(missing_docs)]
4243 setAppointee(setAppointeeCall),
4244 #[allow(missing_docs)]
4245 version(versionCall),
4246 }
4247 #[automatically_derived]
4248 impl PermissionControllerCalls {
4249 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4256 [6u8, 100u8, 18u8, 1u8],
4257 [38u8, 137u8, 89u8, 229u8],
4258 [79u8, 144u8, 108u8, 249u8],
4259 [84u8, 253u8, 77u8, 80u8],
4260 [98u8, 136u8, 6u8, 239u8],
4261 [107u8, 221u8, 250u8, 31u8],
4262 [136u8, 42u8, 59u8, 56u8],
4263 [145u8, 0u8, 103u8, 69u8],
4264 [149u8, 13u8, 128u8, 110u8],
4265 [173u8, 95u8, 34u8, 16u8],
4266 [173u8, 138u8, 202u8, 119u8],
4267 [223u8, 89u8, 92u8, 184u8],
4268 [235u8, 90u8, 78u8, 135u8],
4269 [253u8, 219u8, 222u8, 253u8],
4270 ];
4271 }
4272 #[automatically_derived]
4273 impl alloy_sol_types::SolInterface for PermissionControllerCalls {
4274 const NAME: &'static str = "PermissionControllerCalls";
4275 const MIN_DATA_LENGTH: usize = 0usize;
4276 const COUNT: usize = 14usize;
4277 #[inline]
4278 fn selector(&self) -> [u8; 4] {
4279 match self {
4280 Self::acceptAdmin(_) => {
4281 <acceptAdminCall as alloy_sol_types::SolCall>::SELECTOR
4282 }
4283 Self::addPendingAdmin(_) => {
4284 <addPendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
4285 }
4286 Self::canCall(_) => <canCallCall as alloy_sol_types::SolCall>::SELECTOR,
4287 Self::getAdmins(_) => {
4288 <getAdminsCall as alloy_sol_types::SolCall>::SELECTOR
4289 }
4290 Self::getAppointeePermissions(_) => {
4291 <getAppointeePermissionsCall as alloy_sol_types::SolCall>::SELECTOR
4292 }
4293 Self::getAppointees(_) => {
4294 <getAppointeesCall as alloy_sol_types::SolCall>::SELECTOR
4295 }
4296 Self::getPendingAdmins(_) => {
4297 <getPendingAdminsCall as alloy_sol_types::SolCall>::SELECTOR
4298 }
4299 Self::isAdmin(_) => <isAdminCall as alloy_sol_types::SolCall>::SELECTOR,
4300 Self::isPendingAdmin(_) => {
4301 <isPendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
4302 }
4303 Self::removeAdmin(_) => {
4304 <removeAdminCall as alloy_sol_types::SolCall>::SELECTOR
4305 }
4306 Self::removeAppointee(_) => {
4307 <removeAppointeeCall as alloy_sol_types::SolCall>::SELECTOR
4308 }
4309 Self::removePendingAdmin(_) => {
4310 <removePendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
4311 }
4312 Self::setAppointee(_) => {
4313 <setAppointeeCall as alloy_sol_types::SolCall>::SELECTOR
4314 }
4315 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
4316 }
4317 }
4318 #[inline]
4319 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4320 Self::SELECTORS.get(i).copied()
4321 }
4322 #[inline]
4323 fn valid_selector(selector: [u8; 4]) -> bool {
4324 Self::SELECTORS.binary_search(&selector).is_ok()
4325 }
4326 #[inline]
4327 #[allow(non_snake_case)]
4328 fn abi_decode_raw(
4329 selector: [u8; 4],
4330 data: &[u8],
4331 validate: bool,
4332 ) -> alloy_sol_types::Result<Self> {
4333 static DECODE_SHIMS: &[fn(
4334 &[u8],
4335 bool,
4336 ) -> alloy_sol_types::Result<PermissionControllerCalls>] = &[
4337 {
4338 fn removeAppointee(
4339 data: &[u8],
4340 validate: bool,
4341 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4342 <removeAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw(
4343 data,
4344 validate,
4345 )
4346 .map(PermissionControllerCalls::removeAppointee)
4347 }
4348 removeAppointee
4349 },
4350 {
4351 fn removeAdmin(
4352 data: &[u8],
4353 validate: bool,
4354 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4355 <removeAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4356 data,
4357 validate,
4358 )
4359 .map(PermissionControllerCalls::removeAdmin)
4360 }
4361 removeAdmin
4362 },
4363 {
4364 fn removePendingAdmin(
4365 data: &[u8],
4366 validate: bool,
4367 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4368 <removePendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4369 data,
4370 validate,
4371 )
4372 .map(PermissionControllerCalls::removePendingAdmin)
4373 }
4374 removePendingAdmin
4375 },
4376 {
4377 fn version(
4378 data: &[u8],
4379 validate: bool,
4380 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4381 <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(
4382 data,
4383 validate,
4384 )
4385 .map(PermissionControllerCalls::version)
4386 }
4387 version
4388 },
4389 {
4390 fn acceptAdmin(
4391 data: &[u8],
4392 validate: bool,
4393 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4394 <acceptAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4395 data,
4396 validate,
4397 )
4398 .map(PermissionControllerCalls::acceptAdmin)
4399 }
4400 acceptAdmin
4401 },
4402 {
4403 fn getPendingAdmins(
4404 data: &[u8],
4405 validate: bool,
4406 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4407 <getPendingAdminsCall as alloy_sol_types::SolCall>::abi_decode_raw(
4408 data,
4409 validate,
4410 )
4411 .map(PermissionControllerCalls::getPendingAdmins)
4412 }
4413 getPendingAdmins
4414 },
4415 {
4416 fn getAppointeePermissions(
4417 data: &[u8],
4418 validate: bool,
4419 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4420 <getAppointeePermissionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
4421 data,
4422 validate,
4423 )
4424 .map(PermissionControllerCalls::getAppointeePermissions)
4425 }
4426 getAppointeePermissions
4427 },
4428 {
4429 fn isAdmin(
4430 data: &[u8],
4431 validate: bool,
4432 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4433 <isAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4434 data,
4435 validate,
4436 )
4437 .map(PermissionControllerCalls::isAdmin)
4438 }
4439 isAdmin
4440 },
4441 {
4442 fn setAppointee(
4443 data: &[u8],
4444 validate: bool,
4445 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4446 <setAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw(
4447 data,
4448 validate,
4449 )
4450 .map(PermissionControllerCalls::setAppointee)
4451 }
4452 setAppointee
4453 },
4454 {
4455 fn getAdmins(
4456 data: &[u8],
4457 validate: bool,
4458 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4459 <getAdminsCall as alloy_sol_types::SolCall>::abi_decode_raw(
4460 data,
4461 validate,
4462 )
4463 .map(PermissionControllerCalls::getAdmins)
4464 }
4465 getAdmins
4466 },
4467 {
4468 fn isPendingAdmin(
4469 data: &[u8],
4470 validate: bool,
4471 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4472 <isPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4473 data,
4474 validate,
4475 )
4476 .map(PermissionControllerCalls::isPendingAdmin)
4477 }
4478 isPendingAdmin
4479 },
4480 {
4481 fn canCall(
4482 data: &[u8],
4483 validate: bool,
4484 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4485 <canCallCall as alloy_sol_types::SolCall>::abi_decode_raw(
4486 data,
4487 validate,
4488 )
4489 .map(PermissionControllerCalls::canCall)
4490 }
4491 canCall
4492 },
4493 {
4494 fn addPendingAdmin(
4495 data: &[u8],
4496 validate: bool,
4497 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4498 <addPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4499 data,
4500 validate,
4501 )
4502 .map(PermissionControllerCalls::addPendingAdmin)
4503 }
4504 addPendingAdmin
4505 },
4506 {
4507 fn getAppointees(
4508 data: &[u8],
4509 validate: bool,
4510 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4511 <getAppointeesCall as alloy_sol_types::SolCall>::abi_decode_raw(
4512 data,
4513 validate,
4514 )
4515 .map(PermissionControllerCalls::getAppointees)
4516 }
4517 getAppointees
4518 },
4519 ];
4520 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4521 return Err(
4522 alloy_sol_types::Error::unknown_selector(
4523 <Self as alloy_sol_types::SolInterface>::NAME,
4524 selector,
4525 ),
4526 );
4527 };
4528 DECODE_SHIMS[idx](data, validate)
4529 }
4530 #[inline]
4531 fn abi_encoded_size(&self) -> usize {
4532 match self {
4533 Self::acceptAdmin(inner) => {
4534 <acceptAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
4535 inner,
4536 )
4537 }
4538 Self::addPendingAdmin(inner) => {
4539 <addPendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
4540 inner,
4541 )
4542 }
4543 Self::canCall(inner) => {
4544 <canCallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4545 }
4546 Self::getAdmins(inner) => {
4547 <getAdminsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4548 }
4549 Self::getAppointeePermissions(inner) => {
4550 <getAppointeePermissionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
4551 inner,
4552 )
4553 }
4554 Self::getAppointees(inner) => {
4555 <getAppointeesCall as alloy_sol_types::SolCall>::abi_encoded_size(
4556 inner,
4557 )
4558 }
4559 Self::getPendingAdmins(inner) => {
4560 <getPendingAdminsCall as alloy_sol_types::SolCall>::abi_encoded_size(
4561 inner,
4562 )
4563 }
4564 Self::isAdmin(inner) => {
4565 <isAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4566 }
4567 Self::isPendingAdmin(inner) => {
4568 <isPendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
4569 inner,
4570 )
4571 }
4572 Self::removeAdmin(inner) => {
4573 <removeAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
4574 inner,
4575 )
4576 }
4577 Self::removeAppointee(inner) => {
4578 <removeAppointeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
4579 inner,
4580 )
4581 }
4582 Self::removePendingAdmin(inner) => {
4583 <removePendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
4584 inner,
4585 )
4586 }
4587 Self::setAppointee(inner) => {
4588 <setAppointeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
4589 inner,
4590 )
4591 }
4592 Self::version(inner) => {
4593 <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4594 }
4595 }
4596 }
4597 #[inline]
4598 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4599 match self {
4600 Self::acceptAdmin(inner) => {
4601 <acceptAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
4602 inner,
4603 out,
4604 )
4605 }
4606 Self::addPendingAdmin(inner) => {
4607 <addPendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
4608 inner,
4609 out,
4610 )
4611 }
4612 Self::canCall(inner) => {
4613 <canCallCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4614 }
4615 Self::getAdmins(inner) => {
4616 <getAdminsCall as alloy_sol_types::SolCall>::abi_encode_raw(
4617 inner,
4618 out,
4619 )
4620 }
4621 Self::getAppointeePermissions(inner) => {
4622 <getAppointeePermissionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
4623 inner,
4624 out,
4625 )
4626 }
4627 Self::getAppointees(inner) => {
4628 <getAppointeesCall as alloy_sol_types::SolCall>::abi_encode_raw(
4629 inner,
4630 out,
4631 )
4632 }
4633 Self::getPendingAdmins(inner) => {
4634 <getPendingAdminsCall as alloy_sol_types::SolCall>::abi_encode_raw(
4635 inner,
4636 out,
4637 )
4638 }
4639 Self::isAdmin(inner) => {
4640 <isAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4641 }
4642 Self::isPendingAdmin(inner) => {
4643 <isPendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
4644 inner,
4645 out,
4646 )
4647 }
4648 Self::removeAdmin(inner) => {
4649 <removeAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
4650 inner,
4651 out,
4652 )
4653 }
4654 Self::removeAppointee(inner) => {
4655 <removeAppointeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
4656 inner,
4657 out,
4658 )
4659 }
4660 Self::removePendingAdmin(inner) => {
4661 <removePendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
4662 inner,
4663 out,
4664 )
4665 }
4666 Self::setAppointee(inner) => {
4667 <setAppointeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
4668 inner,
4669 out,
4670 )
4671 }
4672 Self::version(inner) => {
4673 <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4674 }
4675 }
4676 }
4677 }
4678 #[derive(Debug, PartialEq, Eq, Hash)]
4680 pub enum PermissionControllerErrors {
4681 #[allow(missing_docs)]
4682 AdminAlreadyPending(AdminAlreadyPending),
4683 #[allow(missing_docs)]
4684 AdminAlreadySet(AdminAlreadySet),
4685 #[allow(missing_docs)]
4686 AdminNotPending(AdminNotPending),
4687 #[allow(missing_docs)]
4688 AdminNotSet(AdminNotSet),
4689 #[allow(missing_docs)]
4690 AppointeeAlreadySet(AppointeeAlreadySet),
4691 #[allow(missing_docs)]
4692 AppointeeNotSet(AppointeeNotSet),
4693 #[allow(missing_docs)]
4694 CannotHaveZeroAdmins(CannotHaveZeroAdmins),
4695 #[allow(missing_docs)]
4696 InvalidShortString(InvalidShortString),
4697 #[allow(missing_docs)]
4698 NotAdmin(NotAdmin),
4699 #[allow(missing_docs)]
4700 StringTooLong(StringTooLong),
4701 }
4702 #[automatically_derived]
4703 impl PermissionControllerErrors {
4704 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4711 [38u8, 33u8, 24u8, 205u8],
4712 [48u8, 90u8, 39u8, 169u8],
4713 [51u8, 87u8, 219u8, 198u8],
4714 [123u8, 250u8, 75u8, 159u8],
4715 [134u8, 116u8, 73u8, 88u8],
4716 [152u8, 11u8, 7u8, 40u8],
4717 [173u8, 142u8, 254u8, 183u8],
4718 [179u8, 81u8, 43u8, 12u8],
4719 [190u8, 216u8, 41u8, 95u8],
4720 [226u8, 219u8, 3u8, 96u8],
4721 ];
4722 }
4723 #[automatically_derived]
4724 impl alloy_sol_types::SolInterface for PermissionControllerErrors {
4725 const NAME: &'static str = "PermissionControllerErrors";
4726 const MIN_DATA_LENGTH: usize = 0usize;
4727 const COUNT: usize = 10usize;
4728 #[inline]
4729 fn selector(&self) -> [u8; 4] {
4730 match self {
4731 Self::AdminAlreadyPending(_) => {
4732 <AdminAlreadyPending as alloy_sol_types::SolError>::SELECTOR
4733 }
4734 Self::AdminAlreadySet(_) => {
4735 <AdminAlreadySet as alloy_sol_types::SolError>::SELECTOR
4736 }
4737 Self::AdminNotPending(_) => {
4738 <AdminNotPending as alloy_sol_types::SolError>::SELECTOR
4739 }
4740 Self::AdminNotSet(_) => {
4741 <AdminNotSet as alloy_sol_types::SolError>::SELECTOR
4742 }
4743 Self::AppointeeAlreadySet(_) => {
4744 <AppointeeAlreadySet as alloy_sol_types::SolError>::SELECTOR
4745 }
4746 Self::AppointeeNotSet(_) => {
4747 <AppointeeNotSet as alloy_sol_types::SolError>::SELECTOR
4748 }
4749 Self::CannotHaveZeroAdmins(_) => {
4750 <CannotHaveZeroAdmins as alloy_sol_types::SolError>::SELECTOR
4751 }
4752 Self::InvalidShortString(_) => {
4753 <InvalidShortString as alloy_sol_types::SolError>::SELECTOR
4754 }
4755 Self::NotAdmin(_) => <NotAdmin as alloy_sol_types::SolError>::SELECTOR,
4756 Self::StringTooLong(_) => {
4757 <StringTooLong as alloy_sol_types::SolError>::SELECTOR
4758 }
4759 }
4760 }
4761 #[inline]
4762 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4763 Self::SELECTORS.get(i).copied()
4764 }
4765 #[inline]
4766 fn valid_selector(selector: [u8; 4]) -> bool {
4767 Self::SELECTORS.binary_search(&selector).is_ok()
4768 }
4769 #[inline]
4770 #[allow(non_snake_case)]
4771 fn abi_decode_raw(
4772 selector: [u8; 4],
4773 data: &[u8],
4774 validate: bool,
4775 ) -> alloy_sol_types::Result<Self> {
4776 static DECODE_SHIMS: &[fn(
4777 &[u8],
4778 bool,
4779 ) -> alloy_sol_types::Result<PermissionControllerErrors>] = &[
4780 {
4781 fn AppointeeNotSet(
4782 data: &[u8],
4783 validate: bool,
4784 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4785 <AppointeeNotSet as alloy_sol_types::SolError>::abi_decode_raw(
4786 data,
4787 validate,
4788 )
4789 .map(PermissionControllerErrors::AppointeeNotSet)
4790 }
4791 AppointeeNotSet
4792 },
4793 {
4794 fn StringTooLong(
4795 data: &[u8],
4796 validate: bool,
4797 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4798 <StringTooLong as alloy_sol_types::SolError>::abi_decode_raw(
4799 data,
4800 validate,
4801 )
4802 .map(PermissionControllerErrors::StringTooLong)
4803 }
4804 StringTooLong
4805 },
4806 {
4807 fn AdminAlreadyPending(
4808 data: &[u8],
4809 validate: bool,
4810 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4811 <AdminAlreadyPending as alloy_sol_types::SolError>::abi_decode_raw(
4812 data,
4813 validate,
4814 )
4815 .map(PermissionControllerErrors::AdminAlreadyPending)
4816 }
4817 AdminAlreadyPending
4818 },
4819 {
4820 fn NotAdmin(
4821 data: &[u8],
4822 validate: bool,
4823 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4824 <NotAdmin as alloy_sol_types::SolError>::abi_decode_raw(
4825 data,
4826 validate,
4827 )
4828 .map(PermissionControllerErrors::NotAdmin)
4829 }
4830 NotAdmin
4831 },
4832 {
4833 fn CannotHaveZeroAdmins(
4834 data: &[u8],
4835 validate: bool,
4836 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4837 <CannotHaveZeroAdmins as alloy_sol_types::SolError>::abi_decode_raw(
4838 data,
4839 validate,
4840 )
4841 .map(PermissionControllerErrors::CannotHaveZeroAdmins)
4842 }
4843 CannotHaveZeroAdmins
4844 },
4845 {
4846 fn AdminAlreadySet(
4847 data: &[u8],
4848 validate: bool,
4849 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4850 <AdminAlreadySet as alloy_sol_types::SolError>::abi_decode_raw(
4851 data,
4852 validate,
4853 )
4854 .map(PermissionControllerErrors::AdminAlreadySet)
4855 }
4856 AdminAlreadySet
4857 },
4858 {
4859 fn AppointeeAlreadySet(
4860 data: &[u8],
4861 validate: bool,
4862 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4863 <AppointeeAlreadySet as alloy_sol_types::SolError>::abi_decode_raw(
4864 data,
4865 validate,
4866 )
4867 .map(PermissionControllerErrors::AppointeeAlreadySet)
4868 }
4869 AppointeeAlreadySet
4870 },
4871 {
4872 fn InvalidShortString(
4873 data: &[u8],
4874 validate: bool,
4875 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4876 <InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw(
4877 data,
4878 validate,
4879 )
4880 .map(PermissionControllerErrors::InvalidShortString)
4881 }
4882 InvalidShortString
4883 },
4884 {
4885 fn AdminNotPending(
4886 data: &[u8],
4887 validate: bool,
4888 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4889 <AdminNotPending as alloy_sol_types::SolError>::abi_decode_raw(
4890 data,
4891 validate,
4892 )
4893 .map(PermissionControllerErrors::AdminNotPending)
4894 }
4895 AdminNotPending
4896 },
4897 {
4898 fn AdminNotSet(
4899 data: &[u8],
4900 validate: bool,
4901 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
4902 <AdminNotSet as alloy_sol_types::SolError>::abi_decode_raw(
4903 data,
4904 validate,
4905 )
4906 .map(PermissionControllerErrors::AdminNotSet)
4907 }
4908 AdminNotSet
4909 },
4910 ];
4911 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4912 return Err(
4913 alloy_sol_types::Error::unknown_selector(
4914 <Self as alloy_sol_types::SolInterface>::NAME,
4915 selector,
4916 ),
4917 );
4918 };
4919 DECODE_SHIMS[idx](data, validate)
4920 }
4921 #[inline]
4922 fn abi_encoded_size(&self) -> usize {
4923 match self {
4924 Self::AdminAlreadyPending(inner) => {
4925 <AdminAlreadyPending as alloy_sol_types::SolError>::abi_encoded_size(
4926 inner,
4927 )
4928 }
4929 Self::AdminAlreadySet(inner) => {
4930 <AdminAlreadySet as alloy_sol_types::SolError>::abi_encoded_size(
4931 inner,
4932 )
4933 }
4934 Self::AdminNotPending(inner) => {
4935 <AdminNotPending as alloy_sol_types::SolError>::abi_encoded_size(
4936 inner,
4937 )
4938 }
4939 Self::AdminNotSet(inner) => {
4940 <AdminNotSet as alloy_sol_types::SolError>::abi_encoded_size(inner)
4941 }
4942 Self::AppointeeAlreadySet(inner) => {
4943 <AppointeeAlreadySet as alloy_sol_types::SolError>::abi_encoded_size(
4944 inner,
4945 )
4946 }
4947 Self::AppointeeNotSet(inner) => {
4948 <AppointeeNotSet as alloy_sol_types::SolError>::abi_encoded_size(
4949 inner,
4950 )
4951 }
4952 Self::CannotHaveZeroAdmins(inner) => {
4953 <CannotHaveZeroAdmins as alloy_sol_types::SolError>::abi_encoded_size(
4954 inner,
4955 )
4956 }
4957 Self::InvalidShortString(inner) => {
4958 <InvalidShortString as alloy_sol_types::SolError>::abi_encoded_size(
4959 inner,
4960 )
4961 }
4962 Self::NotAdmin(inner) => {
4963 <NotAdmin as alloy_sol_types::SolError>::abi_encoded_size(inner)
4964 }
4965 Self::StringTooLong(inner) => {
4966 <StringTooLong as alloy_sol_types::SolError>::abi_encoded_size(inner)
4967 }
4968 }
4969 }
4970 #[inline]
4971 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4972 match self {
4973 Self::AdminAlreadyPending(inner) => {
4974 <AdminAlreadyPending as alloy_sol_types::SolError>::abi_encode_raw(
4975 inner,
4976 out,
4977 )
4978 }
4979 Self::AdminAlreadySet(inner) => {
4980 <AdminAlreadySet as alloy_sol_types::SolError>::abi_encode_raw(
4981 inner,
4982 out,
4983 )
4984 }
4985 Self::AdminNotPending(inner) => {
4986 <AdminNotPending as alloy_sol_types::SolError>::abi_encode_raw(
4987 inner,
4988 out,
4989 )
4990 }
4991 Self::AdminNotSet(inner) => {
4992 <AdminNotSet as alloy_sol_types::SolError>::abi_encode_raw(
4993 inner,
4994 out,
4995 )
4996 }
4997 Self::AppointeeAlreadySet(inner) => {
4998 <AppointeeAlreadySet as alloy_sol_types::SolError>::abi_encode_raw(
4999 inner,
5000 out,
5001 )
5002 }
5003 Self::AppointeeNotSet(inner) => {
5004 <AppointeeNotSet as alloy_sol_types::SolError>::abi_encode_raw(
5005 inner,
5006 out,
5007 )
5008 }
5009 Self::CannotHaveZeroAdmins(inner) => {
5010 <CannotHaveZeroAdmins as alloy_sol_types::SolError>::abi_encode_raw(
5011 inner,
5012 out,
5013 )
5014 }
5015 Self::InvalidShortString(inner) => {
5016 <InvalidShortString as alloy_sol_types::SolError>::abi_encode_raw(
5017 inner,
5018 out,
5019 )
5020 }
5021 Self::NotAdmin(inner) => {
5022 <NotAdmin as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5023 }
5024 Self::StringTooLong(inner) => {
5025 <StringTooLong as alloy_sol_types::SolError>::abi_encode_raw(
5026 inner,
5027 out,
5028 )
5029 }
5030 }
5031 }
5032 }
5033 #[derive(Debug, PartialEq, Eq, Hash)]
5035 pub enum PermissionControllerEvents {
5036 #[allow(missing_docs)]
5037 AdminRemoved(AdminRemoved),
5038 #[allow(missing_docs)]
5039 AdminSet(AdminSet),
5040 #[allow(missing_docs)]
5041 AppointeeRemoved(AppointeeRemoved),
5042 #[allow(missing_docs)]
5043 AppointeeSet(AppointeeSet),
5044 #[allow(missing_docs)]
5045 Initialized(Initialized),
5046 #[allow(missing_docs)]
5047 PendingAdminAdded(PendingAdminAdded),
5048 #[allow(missing_docs)]
5049 PendingAdminRemoved(PendingAdminRemoved),
5050 }
5051 #[automatically_derived]
5052 impl PermissionControllerEvents {
5053 pub const SELECTORS: &'static [[u8; 32usize]] = &[
5060 [
5061 3u8, 127u8, 3u8, 162u8, 173u8, 107u8, 150u8, 125u8, 244u8, 160u8, 23u8,
5062 121u8, 182u8, 210u8, 180u8, 200u8, 89u8, 80u8, 223u8, 131u8, 146u8, 93u8,
5063 158u8, 49u8, 54u8, 43u8, 81u8, 148u8, 34u8, 252u8, 1u8, 105u8,
5064 ],
5065 [
5066 24u8, 36u8, 35u8, 38u8, 182u8, 184u8, 98u8, 18u8, 105u8, 112u8, 103u8,
5067 151u8, 89u8, 22u8, 159u8, 1u8, 246u8, 70u8, 189u8, 85u8, 236u8, 91u8,
5068 252u8, 171u8, 133u8, 186u8, 159u8, 51u8, 122u8, 116u8, 224u8, 198u8,
5069 ],
5070 [
5071 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
5072 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
5073 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
5074 ],
5075 [
5076 177u8, 75u8, 154u8, 61u8, 68u8, 140u8, 91u8, 4u8, 240u8, 229u8, 176u8,
5077 135u8, 182u8, 245u8, 25u8, 51u8, 144u8, 219u8, 121u8, 85u8, 72u8, 42u8,
5078 111u8, 251u8, 132u8, 30u8, 123u8, 59u8, 166u8, 26u8, 70u8, 12u8,
5079 ],
5080 [
5081 191u8, 38u8, 94u8, 131u8, 38u8, 40u8, 90u8, 39u8, 71u8, 227u8, 62u8,
5082 84u8, 213u8, 148u8, 95u8, 113u8, 17u8, 242u8, 181u8, 237u8, 184u8, 38u8,
5083 235u8, 140u8, 8u8, 212u8, 103u8, 119u8, 121u8, 179u8, 255u8, 151u8,
5084 ],
5085 [
5086 215u8, 6u8, 237u8, 122u8, 224u8, 68u8, 215u8, 149u8, 180u8, 158u8, 84u8,
5087 201u8, 245u8, 25u8, 246u8, 99u8, 5u8, 57u8, 81u8, 1u8, 25u8, 133u8,
5088 246u8, 99u8, 168u8, 98u8, 205u8, 158u8, 231u8, 42u8, 154u8, 199u8,
5089 ],
5090 [
5091 219u8, 157u8, 93u8, 49u8, 50u8, 13u8, 175u8, 91u8, 199u8, 24u8, 29u8,
5092 86u8, 91u8, 109u8, 164u8, 209u8, 46u8, 48u8, 240u8, 244u8, 213u8, 170u8,
5093 50u8, 74u8, 153u8, 36u8, 38u8, 193u8, 74u8, 29u8, 25u8, 206u8,
5094 ],
5095 ];
5096 }
5097 #[automatically_derived]
5098 impl alloy_sol_types::SolEventInterface for PermissionControllerEvents {
5099 const NAME: &'static str = "PermissionControllerEvents";
5100 const COUNT: usize = 7usize;
5101 fn decode_raw_log(
5102 topics: &[alloy_sol_types::Word],
5103 data: &[u8],
5104 validate: bool,
5105 ) -> alloy_sol_types::Result<Self> {
5106 match topics.first().copied() {
5107 Some(<AdminRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5108 <AdminRemoved as alloy_sol_types::SolEvent>::decode_raw_log(
5109 topics,
5110 data,
5111 validate,
5112 )
5113 .map(Self::AdminRemoved)
5114 }
5115 Some(<AdminSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5116 <AdminSet as alloy_sol_types::SolEvent>::decode_raw_log(
5117 topics,
5118 data,
5119 validate,
5120 )
5121 .map(Self::AdminSet)
5122 }
5123 Some(<AppointeeRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5124 <AppointeeRemoved as alloy_sol_types::SolEvent>::decode_raw_log(
5125 topics,
5126 data,
5127 validate,
5128 )
5129 .map(Self::AppointeeRemoved)
5130 }
5131 Some(<AppointeeSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5132 <AppointeeSet as alloy_sol_types::SolEvent>::decode_raw_log(
5133 topics,
5134 data,
5135 validate,
5136 )
5137 .map(Self::AppointeeSet)
5138 }
5139 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5140 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
5141 topics,
5142 data,
5143 validate,
5144 )
5145 .map(Self::Initialized)
5146 }
5147 Some(
5148 <PendingAdminAdded as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5149 ) => {
5150 <PendingAdminAdded as alloy_sol_types::SolEvent>::decode_raw_log(
5151 topics,
5152 data,
5153 validate,
5154 )
5155 .map(Self::PendingAdminAdded)
5156 }
5157 Some(
5158 <PendingAdminRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5159 ) => {
5160 <PendingAdminRemoved as alloy_sol_types::SolEvent>::decode_raw_log(
5161 topics,
5162 data,
5163 validate,
5164 )
5165 .map(Self::PendingAdminRemoved)
5166 }
5167 _ => {
5168 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
5169 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
5170 log: alloy_sol_types::private::Box::new(
5171 alloy_sol_types::private::LogData::new_unchecked(
5172 topics.to_vec(),
5173 data.to_vec().into(),
5174 ),
5175 ),
5176 })
5177 }
5178 }
5179 }
5180 }
5181 #[automatically_derived]
5182 impl alloy_sol_types::private::IntoLogData for PermissionControllerEvents {
5183 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5184 match self {
5185 Self::AdminRemoved(inner) => {
5186 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5187 }
5188 Self::AdminSet(inner) => {
5189 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5190 }
5191 Self::AppointeeRemoved(inner) => {
5192 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5193 }
5194 Self::AppointeeSet(inner) => {
5195 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5196 }
5197 Self::Initialized(inner) => {
5198 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5199 }
5200 Self::PendingAdminAdded(inner) => {
5201 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5202 }
5203 Self::PendingAdminRemoved(inner) => {
5204 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5205 }
5206 }
5207 }
5208 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5209 match self {
5210 Self::AdminRemoved(inner) => {
5211 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5212 }
5213 Self::AdminSet(inner) => {
5214 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5215 }
5216 Self::AppointeeRemoved(inner) => {
5217 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5218 }
5219 Self::AppointeeSet(inner) => {
5220 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5221 }
5222 Self::Initialized(inner) => {
5223 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5224 }
5225 Self::PendingAdminAdded(inner) => {
5226 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5227 }
5228 Self::PendingAdminRemoved(inner) => {
5229 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5230 }
5231 }
5232 }
5233 }
5234 use alloy::contract as alloy_contract;
5235 #[inline]
5239 pub const fn new<
5240 T: alloy_contract::private::Transport + ::core::clone::Clone,
5241 P: alloy_contract::private::Provider<T, N>,
5242 N: alloy_contract::private::Network,
5243 >(
5244 address: alloy_sol_types::private::Address,
5245 provider: P,
5246 ) -> PermissionControllerInstance<T, P, N> {
5247 PermissionControllerInstance::<T, P, N>::new(address, provider)
5248 }
5249 #[inline]
5255 pub fn deploy<
5256 T: alloy_contract::private::Transport + ::core::clone::Clone,
5257 P: alloy_contract::private::Provider<T, N>,
5258 N: alloy_contract::private::Network,
5259 >(
5260 provider: P,
5261 _version: alloy::sol_types::private::String,
5262 ) -> impl ::core::future::Future<
5263 Output = alloy_contract::Result<PermissionControllerInstance<T, P, N>>,
5264 > {
5265 PermissionControllerInstance::<T, P, N>::deploy(provider, _version)
5266 }
5267 #[inline]
5273 pub fn deploy_builder<
5274 T: alloy_contract::private::Transport + ::core::clone::Clone,
5275 P: alloy_contract::private::Provider<T, N>,
5276 N: alloy_contract::private::Network,
5277 >(
5278 provider: P,
5279 _version: alloy::sol_types::private::String,
5280 ) -> alloy_contract::RawCallBuilder<T, P, N> {
5281 PermissionControllerInstance::<T, P, N>::deploy_builder(provider, _version)
5282 }
5283 #[derive(Clone)]
5295 pub struct PermissionControllerInstance<
5296 T,
5297 P,
5298 N = alloy_contract::private::Ethereum,
5299 > {
5300 address: alloy_sol_types::private::Address,
5301 provider: P,
5302 _network_transport: ::core::marker::PhantomData<(N, T)>,
5303 }
5304 #[automatically_derived]
5305 impl<T, P, N> ::core::fmt::Debug for PermissionControllerInstance<T, P, N> {
5306 #[inline]
5307 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5308 f.debug_tuple("PermissionControllerInstance").field(&self.address).finish()
5309 }
5310 }
5311 #[automatically_derived]
5313 impl<
5314 T: alloy_contract::private::Transport + ::core::clone::Clone,
5315 P: alloy_contract::private::Provider<T, N>,
5316 N: alloy_contract::private::Network,
5317 > PermissionControllerInstance<T, P, N> {
5318 #[inline]
5322 pub const fn new(
5323 address: alloy_sol_types::private::Address,
5324 provider: P,
5325 ) -> Self {
5326 Self {
5327 address,
5328 provider,
5329 _network_transport: ::core::marker::PhantomData,
5330 }
5331 }
5332 #[inline]
5338 pub async fn deploy(
5339 provider: P,
5340 _version: alloy::sol_types::private::String,
5341 ) -> alloy_contract::Result<PermissionControllerInstance<T, P, N>> {
5342 let call_builder = Self::deploy_builder(provider, _version);
5343 let contract_address = call_builder.deploy().await?;
5344 Ok(Self::new(contract_address, call_builder.provider))
5345 }
5346 #[inline]
5352 pub fn deploy_builder(
5353 provider: P,
5354 _version: alloy::sol_types::private::String,
5355 ) -> alloy_contract::RawCallBuilder<T, P, N> {
5356 alloy_contract::RawCallBuilder::new_raw_deploy(
5357 provider,
5358 [
5359 &BYTECODE[..],
5360 &alloy_sol_types::SolConstructor::abi_encode(
5361 &constructorCall { _version },
5362 )[..],
5363 ]
5364 .concat()
5365 .into(),
5366 )
5367 }
5368 #[inline]
5370 pub const fn address(&self) -> &alloy_sol_types::private::Address {
5371 &self.address
5372 }
5373 #[inline]
5375 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
5376 self.address = address;
5377 }
5378 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
5380 self.set_address(address);
5381 self
5382 }
5383 #[inline]
5385 pub const fn provider(&self) -> &P {
5386 &self.provider
5387 }
5388 }
5389 impl<T, P: ::core::clone::Clone, N> PermissionControllerInstance<T, &P, N> {
5390 #[inline]
5392 pub fn with_cloned_provider(self) -> PermissionControllerInstance<T, P, N> {
5393 PermissionControllerInstance {
5394 address: self.address,
5395 provider: ::core::clone::Clone::clone(&self.provider),
5396 _network_transport: ::core::marker::PhantomData,
5397 }
5398 }
5399 }
5400 #[automatically_derived]
5402 impl<
5403 T: alloy_contract::private::Transport + ::core::clone::Clone,
5404 P: alloy_contract::private::Provider<T, N>,
5405 N: alloy_contract::private::Network,
5406 > PermissionControllerInstance<T, P, N> {
5407 pub fn call_builder<C: alloy_sol_types::SolCall>(
5412 &self,
5413 call: &C,
5414 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
5415 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
5416 }
5417 pub fn acceptAdmin(
5419 &self,
5420 account: alloy::sol_types::private::Address,
5421 ) -> alloy_contract::SolCallBuilder<T, &P, acceptAdminCall, N> {
5422 self.call_builder(&acceptAdminCall { account })
5423 }
5424 pub fn addPendingAdmin(
5426 &self,
5427 account: alloy::sol_types::private::Address,
5428 admin: alloy::sol_types::private::Address,
5429 ) -> alloy_contract::SolCallBuilder<T, &P, addPendingAdminCall, N> {
5430 self.call_builder(
5431 &addPendingAdminCall {
5432 account,
5433 admin,
5434 },
5435 )
5436 }
5437 pub fn canCall(
5439 &self,
5440 account: alloy::sol_types::private::Address,
5441 caller: alloy::sol_types::private::Address,
5442 target: alloy::sol_types::private::Address,
5443 selector: alloy::sol_types::private::FixedBytes<4>,
5444 ) -> alloy_contract::SolCallBuilder<T, &P, canCallCall, N> {
5445 self.call_builder(
5446 &canCallCall {
5447 account,
5448 caller,
5449 target,
5450 selector,
5451 },
5452 )
5453 }
5454 pub fn getAdmins(
5456 &self,
5457 account: alloy::sol_types::private::Address,
5458 ) -> alloy_contract::SolCallBuilder<T, &P, getAdminsCall, N> {
5459 self.call_builder(&getAdminsCall { account })
5460 }
5461 pub fn getAppointeePermissions(
5463 &self,
5464 account: alloy::sol_types::private::Address,
5465 appointee: alloy::sol_types::private::Address,
5466 ) -> alloy_contract::SolCallBuilder<T, &P, getAppointeePermissionsCall, N> {
5467 self.call_builder(
5468 &getAppointeePermissionsCall {
5469 account,
5470 appointee,
5471 },
5472 )
5473 }
5474 pub fn getAppointees(
5476 &self,
5477 account: alloy::sol_types::private::Address,
5478 target: alloy::sol_types::private::Address,
5479 selector: alloy::sol_types::private::FixedBytes<4>,
5480 ) -> alloy_contract::SolCallBuilder<T, &P, getAppointeesCall, N> {
5481 self.call_builder(
5482 &getAppointeesCall {
5483 account,
5484 target,
5485 selector,
5486 },
5487 )
5488 }
5489 pub fn getPendingAdmins(
5491 &self,
5492 account: alloy::sol_types::private::Address,
5493 ) -> alloy_contract::SolCallBuilder<T, &P, getPendingAdminsCall, N> {
5494 self.call_builder(&getPendingAdminsCall { account })
5495 }
5496 pub fn isAdmin(
5498 &self,
5499 account: alloy::sol_types::private::Address,
5500 caller: alloy::sol_types::private::Address,
5501 ) -> alloy_contract::SolCallBuilder<T, &P, isAdminCall, N> {
5502 self.call_builder(&isAdminCall { account, caller })
5503 }
5504 pub fn isPendingAdmin(
5506 &self,
5507 account: alloy::sol_types::private::Address,
5508 pendingAdmin: alloy::sol_types::private::Address,
5509 ) -> alloy_contract::SolCallBuilder<T, &P, isPendingAdminCall, N> {
5510 self.call_builder(
5511 &isPendingAdminCall {
5512 account,
5513 pendingAdmin,
5514 },
5515 )
5516 }
5517 pub fn removeAdmin(
5519 &self,
5520 account: alloy::sol_types::private::Address,
5521 admin: alloy::sol_types::private::Address,
5522 ) -> alloy_contract::SolCallBuilder<T, &P, removeAdminCall, N> {
5523 self.call_builder(&removeAdminCall { account, admin })
5524 }
5525 pub fn removeAppointee(
5527 &self,
5528 account: alloy::sol_types::private::Address,
5529 appointee: alloy::sol_types::private::Address,
5530 target: alloy::sol_types::private::Address,
5531 selector: alloy::sol_types::private::FixedBytes<4>,
5532 ) -> alloy_contract::SolCallBuilder<T, &P, removeAppointeeCall, N> {
5533 self.call_builder(
5534 &removeAppointeeCall {
5535 account,
5536 appointee,
5537 target,
5538 selector,
5539 },
5540 )
5541 }
5542 pub fn removePendingAdmin(
5544 &self,
5545 account: alloy::sol_types::private::Address,
5546 admin: alloy::sol_types::private::Address,
5547 ) -> alloy_contract::SolCallBuilder<T, &P, removePendingAdminCall, N> {
5548 self.call_builder(
5549 &removePendingAdminCall {
5550 account,
5551 admin,
5552 },
5553 )
5554 }
5555 pub fn setAppointee(
5557 &self,
5558 account: alloy::sol_types::private::Address,
5559 appointee: alloy::sol_types::private::Address,
5560 target: alloy::sol_types::private::Address,
5561 selector: alloy::sol_types::private::FixedBytes<4>,
5562 ) -> alloy_contract::SolCallBuilder<T, &P, setAppointeeCall, N> {
5563 self.call_builder(
5564 &setAppointeeCall {
5565 account,
5566 appointee,
5567 target,
5568 selector,
5569 },
5570 )
5571 }
5572 pub fn version(&self) -> alloy_contract::SolCallBuilder<T, &P, versionCall, N> {
5574 self.call_builder(&versionCall {})
5575 }
5576 }
5577 #[automatically_derived]
5579 impl<
5580 T: alloy_contract::private::Transport + ::core::clone::Clone,
5581 P: alloy_contract::private::Provider<T, N>,
5582 N: alloy_contract::private::Network,
5583 > PermissionControllerInstance<T, P, N> {
5584 pub fn event_filter<E: alloy_sol_types::SolEvent>(
5589 &self,
5590 ) -> alloy_contract::Event<T, &P, E, N> {
5591 alloy_contract::Event::new_sol(&self.provider, &self.address)
5592 }
5593 pub fn AdminRemoved_filter(
5595 &self,
5596 ) -> alloy_contract::Event<T, &P, AdminRemoved, N> {
5597 self.event_filter::<AdminRemoved>()
5598 }
5599 pub fn AdminSet_filter(&self) -> alloy_contract::Event<T, &P, AdminSet, N> {
5601 self.event_filter::<AdminSet>()
5602 }
5603 pub fn AppointeeRemoved_filter(
5605 &self,
5606 ) -> alloy_contract::Event<T, &P, AppointeeRemoved, N> {
5607 self.event_filter::<AppointeeRemoved>()
5608 }
5609 pub fn AppointeeSet_filter(
5611 &self,
5612 ) -> alloy_contract::Event<T, &P, AppointeeSet, N> {
5613 self.event_filter::<AppointeeSet>()
5614 }
5615 pub fn Initialized_filter(
5617 &self,
5618 ) -> alloy_contract::Event<T, &P, Initialized, N> {
5619 self.event_filter::<Initialized>()
5620 }
5621 pub fn PendingAdminAdded_filter(
5623 &self,
5624 ) -> alloy_contract::Event<T, &P, PendingAdminAdded, N> {
5625 self.event_filter::<PendingAdminAdded>()
5626 }
5627 pub fn PendingAdminRemoved_filter(
5629 &self,
5630 ) -> alloy_contract::Event<T, &P, PendingAdminRemoved, N> {
5631 self.event_filter::<PendingAdminRemoved>()
5632 }
5633 }
5634}