1#[allow(
642 non_camel_case_types,
643 non_snake_case,
644 clippy::pub_underscore_fields,
645 clippy::style,
646 clippy::empty_structs_with_brackets
647)]
648pub mod EspToken {
649 use alloy::sol_types as alloy_sol_types;
650
651 use super::*;
652 #[rustfmt::skip]
658 #[allow(clippy::all)]
659 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
660 b"`\xA0`@R0`\x80R4\x80\x15a\0\x13W__\xFD[Pa\0\x1Ca\0!V[a\0\xD3V[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80Th\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\0qW`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80T`\x01`\x01`@\x1B\x03\x90\x81\x16\x14a\0\xD0W\x80T`\x01`\x01`@\x1B\x03\x19\x16`\x01`\x01`@\x1B\x03\x90\x81\x17\x82U`@Q\x90\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PV[`\x80Qa\x14\xCCa\0\xF9_9_\x81\x81a\x07\xC0\x01R\x81\x81a\x07\xE9\x01Ra\tg\x01Ra\x14\xCC_\xF3\xFE`\x80`@R`\x046\x10a\0\xFAW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\x92W\x80c\x9A\xB86~\x11a\0bW\x80c\x9A\xB86~\x14a\x02\xD0W\x80c\xA9\x05\x9C\xBB\x14a\x02\xEFW\x80c\xAD<\xB1\xCC\x14a\x03\x0EW\x80c\xDDb\xED>\x14a\x03>W\x80c\xF2\xFD\xE3\x8B\x14a\x03]W__\xFD[\x80cp\xA0\x821\x14a\x02\"W\x80cqP\x18\xA6\x14a\x02bW\x80c\x8D\xA5\xCB[\x14a\x02vW\x80c\x95\xD8\x9BA\x14a\x02\xBCW__\xFD[\x80c#\xB8r\xDD\x11a\0\xCDW\x80c#\xB8r\xDD\x14a\x01\xBFW\x80c1<\xE5g\x14a\x01\xDEW\x80cO\x1E\xF2\x86\x14a\x01\xF9W\x80cR\xD1\x90-\x14a\x02\x0EW__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xFEW\x80c\t^\xA7\xB3\x14a\x01(W\x80c\r\x8En,\x14a\x01WW\x80c\x18\x16\r\xDD\x14a\x01\x82W[__\xFD[4\x80\x15a\x01\tW__\xFD[Pa\x01\x12a\x03|V[`@Qa\x01\x1F\x91\x90a\x0F[V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x013W__\xFD[Pa\x01Ga\x01B6`\x04a\x0F\xABV[a\x04<V[`@Q\x90\x15\x15\x81R` \x01a\x01\x1FV[4\x80\x15a\x01bW__\xFD[P`@\x80Q`\x01\x81R_` \x82\x01\x81\x90R\x91\x81\x01\x91\x90\x91R``\x01a\x01\x1FV[4\x80\x15a\x01\x8DW__\xFD[P\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x02T[`@Q\x90\x81R` \x01a\x01\x1FV[4\x80\x15a\x01\xCAW__\xFD[Pa\x01Ga\x01\xD96`\x04a\x0F\xD3V[a\x04UV[4\x80\x15a\x01\xE9W__\xFD[P`@Q`\x12\x81R` \x01a\x01\x1FV[a\x02\x0Ca\x02\x076`\x04a\x10\x98V[a\x04zV[\0[4\x80\x15a\x02\x19W__\xFD[Pa\x01\xB1a\x04\x99V[4\x80\x15a\x02-W__\xFD[Pa\x01\xB1a\x02<6`\x04a\x10\xF6V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R_Q` a\x14\x80_9_Q\x90_R` R`@\x90 T\x90V[4\x80\x15a\x02mW__\xFD[Pa\x02\x0Ca\x04\xB4V[4\x80\x15a\x02\x81W__\xFD[P\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\x1FV[4\x80\x15a\x02\xC7W__\xFD[Pa\x01\x12a\x04\xC7V[4\x80\x15a\x02\xDBW__\xFD[Pa\x02\x0Ca\x02\xEA6`\x04a\x11-V[a\x05\x05V[4\x80\x15a\x02\xFAW__\xFD[Pa\x01Ga\x03\t6`\x04a\x0F\xABV[a\x06KV[4\x80\x15a\x03\x19W__\xFD[Pa\x01\x12`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d\x03R\xE3\x02\xE3`\xDC\x1B\x81RP\x81V[4\x80\x15a\x03IW__\xFD[Pa\x01\xB1a\x03X6`\x04a\x11\xBBV[a\x06XV[4\x80\x15a\x03hW__\xFD[Pa\x02\x0Ca\x03w6`\x04a\x10\xF6V[a\x06\xA1V[\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x03\x80T``\x91_Q` a\x14\x80_9_Q\x90_R\x91a\x03\xBA\x90a\x11\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xE6\x90a\x11\xECV[\x80\x15a\x041W\x80`\x1F\x10a\x04\x08Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x041V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x14W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x91PP\x90V[_3a\x04I\x81\x85\x85a\x06\xE3V[`\x01\x91PP[\x92\x91PPV[_3a\x04b\x85\x82\x85a\x06\xF5V[a\x04m\x85\x85\x85a\x07XV[`\x01\x91PP[\x93\x92PPPV[a\x04\x82a\x07\xB5V[a\x04\x8B\x82a\x08YV[a\x04\x95\x82\x82a\x08\xA0V[PPV[_a\x04\xA2a\t\\V[P_Q` a\x14\xA0_9_Q\x90_R\x90V[a\x04\xBCa\t\xA5V[a\x04\xC5_a\n\0V[V[\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x04\x80T``\x91_Q` a\x14\x80_9_Q\x90_R\x91a\x03\xBA\x90a\x11\xECV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x81\x15\x80\x15a\x05JWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x05fWP0;\x15[\x90P\x81\x15\x80\x15a\x05tWP\x80\x15[\x15a\x05\x92W`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x05\xBCW\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x05\xC6\x87\x87a\npV[a\x05\xCF\x8Aa\n\x82V[a\x05\xD7a\n\x93V[a\x05\xE3`\x12`\na\x13\x1BV[a\x05\xED\x90\x89a\x13)V[\x97Pa\x05\xF9\x89\x89a\n\x9BV[\x83\x15a\x06?W\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPPPPPV[_3a\x04I\x81\x85\x85a\x07XV[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x06\xA9a\t\xA5V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\xD7W`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[a\x06\xE0\x81a\n\0V[PV[a\x06\xF0\x83\x83\x83`\x01a\n\xCFV[PPPV[_a\x07\0\x84\x84a\x06XV[\x90P_\x19\x81\x14a\x07RW\x81\x81\x10\x15a\x07DW`@Qc}\xC7\xA0\xD9`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01R`$\x81\x01\x82\x90R`D\x81\x01\x83\x90R`d\x01a\x06\xCEV[a\x07R\x84\x84\x84\x84\x03_a\n\xCFV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07\x81W`@QcKc~\x8F`\xE1\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xAAW`@Qc\xECD/\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[a\x06\xF0\x83\x83\x83a\x0B\xB3V[0`\x01`\x01`\xA0\x1B\x03\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\0\x16\x14\x80a\x08;WP\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\0`\x01`\x01`\xA0\x1B\x03\x16a\x08/_Q` a\x14\xA0_9_Q\x90_RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x04\xC5W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08aa\t\xA5V[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01`@Q\x80\x91\x03\x90\xA1PV[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\x08\xFAWP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x08\xF7\x91\x81\x01\x90a\x13@V[`\x01[a\t\"W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06\xCEV[_Q` a\x14\xA0_9_Q\x90_R\x81\x14a\tRW`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x06\xCEV[a\x06\xF0\x83\x83a\x0C\xECV[0`\x01`\x01`\xA0\x1B\x03\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\0\x16\x14a\x04\xC5W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3a\t\xD7\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x04\xC5W`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x06\xCEV[\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x82\x17\x84U`@Q\x92\x16\x91\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPPV[a\nxa\rAV[a\x04\x95\x82\x82a\r\x8AV[a\n\x8Aa\rAV[a\x06\xE0\x81a\r\xDAV[a\x04\xC5a\rAV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xC4W`@Qc\xECD/\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[a\x04\x95_\x83\x83a\x0B\xB3V[_Q` a\x14\x80_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x85\x16a\x0B\x06W`@Qc\xE6\x02\xDF\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0B/W`@QcJ\x14\x06\xB1`\xE1\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\x01\x83\x01` \x90\x81R`@\x80\x83 \x93\x88\x16\x83R\x92\x90R \x83\x90U\x81\x15a\x0B\xACW\x83`\x01`\x01`\xA0\x1B\x03\x16\x85`\x01`\x01`\xA0\x1B\x03\x16\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x85`@Qa\x0B\xA3\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3[PPPPPV[_Q` a\x14\x80_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0B\xEDW\x81\x81`\x02\x01_\x82\x82Ta\x0B\xE2\x91\x90a\x13WV[\x90\x91UPa\x0C]\x90PV[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R` \x82\x90R`@\x90 T\x82\x81\x10\x15a\x0C?W`@Qc9\x144\xE3`\xE2\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x86\x16`\x04\x82\x01R`$\x81\x01\x82\x90R`D\x81\x01\x84\x90R`d\x01a\x06\xCEV[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R` \x83\x90R`@\x90 \x90\x83\x90\x03\x90U[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x0C{W`\x02\x81\x01\x80T\x83\x90\x03\x90Ua\x0C\x99V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x82\x90R`@\x90 \x80T\x83\x01\x90U[\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x84`@Qa\x0C\xDE\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[a\x0C\xF5\x82a\r\xE2V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\r9Wa\x06\xF0\x82\x82a\x0EEV[a\x04\x95a\x0E\xB7V[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0T`\x01`@\x1B\x90\x04`\xFF\x16a\x04\xC5W`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\r\x92a\rAV[_Q` a\x14\x80_9_Q\x90_R\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x03a\r\xCB\x84\x82a\x13\xAEV[P`\x04\x81\x01a\x07R\x83\x82a\x13\xAEV[a\x06\xA9a\rAV[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x0E\x17W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x06\xCEV[_Q` a\x14\xA0_9_Q\x90_R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``__\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\x0Ea\x91\x90a\x14iV[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x0E\x99W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0E\x9EV[``\x91P[P\x91P\x91Pa\x0E\xAE\x85\x83\x83a\x0E\xD6V[\x95\x94PPPPPV[4\x15a\x04\xC5W`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82a\x0E\xEBWa\x0E\xE6\x82a\x0F2V[a\x04sV[\x81Q\x15\x80\x15a\x0F\x02WP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x0F+W`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\x06\xCEV[P\x80a\x04sV[\x80Q\x15a\x0FBW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0F\xA6W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0F\xBCW__\xFD[a\x0F\xC5\x83a\x0F\x90V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0F\xE5W__\xFD[a\x0F\xEE\x84a\x0F\x90V[\x92Pa\x0F\xFC` \x85\x01a\x0F\x90V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[__g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x11\x15a\x10;Wa\x10;a\x10\rV[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x10jWa\x10ja\x10\rV[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\x10\x81W__\xFD[\x83\x83` \x83\x017_` \x85\x83\x01\x01RP\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x10\xA9W__\xFD[a\x10\xB2\x83a\x0F\x90V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xCDW__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a\x10\xDDW__\xFD[a\x10\xEC\x85\x825` \x84\x01a\x10!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x11\x06W__\xFD[a\x04s\x82a\x0F\x90V[_\x82`\x1F\x83\x01\x12a\x11\x1EW__\xFD[a\x04s\x83\x835` \x85\x01a\x10!V[_____`\xA0\x86\x88\x03\x12\x15a\x11AW__\xFD[a\x11J\x86a\x0F\x90V[\x94Pa\x11X` \x87\x01a\x0F\x90V[\x93P`@\x86\x015\x92P``\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11zW__\xFD[a\x11\x86\x88\x82\x89\x01a\x11\x0FV[\x92PP`\x80\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\xA2W__\xFD[a\x11\xAE\x88\x82\x89\x01a\x11\x0FV[\x91PP\x92\x95P\x92\x95\x90\x93PV[__`@\x83\x85\x03\x12\x15a\x11\xCCW__\xFD[a\x11\xD5\x83a\x0F\x90V[\x91Pa\x11\xE3` \x84\x01a\x0F\x90V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x12\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x12\x1EWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[`\x01\x81[`\x01\x84\x11\x15a\x12sW\x80\x85\x04\x81\x11\x15a\x12WWa\x12Wa\x12$V[`\x01\x84\x16\x15a\x12eW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x12<V[\x93P\x93\x91PPV[_\x82a\x12\x89WP`\x01a\x04OV[\x81a\x12\x95WP_a\x04OV[\x81`\x01\x81\x14a\x12\xABW`\x02\x81\x14a\x12\xB5Wa\x12\xD1V[`\x01\x91PPa\x04OV[`\xFF\x84\x11\x15a\x12\xC6Wa\x12\xC6a\x12$V[PP`\x01\x82\x1Ba\x04OV[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x12\xF4WP\x81\x81\na\x04OV[a\x13\0_\x19\x84\x84a\x128V[\x80_\x19\x04\x82\x11\x15a\x13\x13Wa\x13\x13a\x12$V[\x02\x93\x92PPPV[_a\x04s`\xFF\x84\x16\x83a\x12{V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x04OWa\x04Oa\x12$V[_` \x82\x84\x03\x12\x15a\x13PW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x04OWa\x04Oa\x12$V[`\x1F\x82\x11\x15a\x06\xF0W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x13\x8FWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0B\xACW_\x81U`\x01\x01a\x13\x9BV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xC8Wa\x13\xC8a\x10\rV[a\x13\xDC\x81a\x13\xD6\x84Ta\x11\xECV[\x84a\x13jV[` `\x1F\x82\x11`\x01\x81\x14a\x14\x0EW_\x83\x15a\x13\xF7WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0B\xACV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x14=W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x14\x1DV[P\x84\x82\x10\x15a\x14ZW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV\xFER\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x006\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08\x1C\0\n",
661 );
662 #[rustfmt::skip]
668 #[allow(clippy::all)]
669 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
670 b"`\x80`@R`\x046\x10a\0\xFAW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\x92W\x80c\x9A\xB86~\x11a\0bW\x80c\x9A\xB86~\x14a\x02\xD0W\x80c\xA9\x05\x9C\xBB\x14a\x02\xEFW\x80c\xAD<\xB1\xCC\x14a\x03\x0EW\x80c\xDDb\xED>\x14a\x03>W\x80c\xF2\xFD\xE3\x8B\x14a\x03]W__\xFD[\x80cp\xA0\x821\x14a\x02\"W\x80cqP\x18\xA6\x14a\x02bW\x80c\x8D\xA5\xCB[\x14a\x02vW\x80c\x95\xD8\x9BA\x14a\x02\xBCW__\xFD[\x80c#\xB8r\xDD\x11a\0\xCDW\x80c#\xB8r\xDD\x14a\x01\xBFW\x80c1<\xE5g\x14a\x01\xDEW\x80cO\x1E\xF2\x86\x14a\x01\xF9W\x80cR\xD1\x90-\x14a\x02\x0EW__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xFEW\x80c\t^\xA7\xB3\x14a\x01(W\x80c\r\x8En,\x14a\x01WW\x80c\x18\x16\r\xDD\x14a\x01\x82W[__\xFD[4\x80\x15a\x01\tW__\xFD[Pa\x01\x12a\x03|V[`@Qa\x01\x1F\x91\x90a\x0F[V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x013W__\xFD[Pa\x01Ga\x01B6`\x04a\x0F\xABV[a\x04<V[`@Q\x90\x15\x15\x81R` \x01a\x01\x1FV[4\x80\x15a\x01bW__\xFD[P`@\x80Q`\x01\x81R_` \x82\x01\x81\x90R\x91\x81\x01\x91\x90\x91R``\x01a\x01\x1FV[4\x80\x15a\x01\x8DW__\xFD[P\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x02T[`@Q\x90\x81R` \x01a\x01\x1FV[4\x80\x15a\x01\xCAW__\xFD[Pa\x01Ga\x01\xD96`\x04a\x0F\xD3V[a\x04UV[4\x80\x15a\x01\xE9W__\xFD[P`@Q`\x12\x81R` \x01a\x01\x1FV[a\x02\x0Ca\x02\x076`\x04a\x10\x98V[a\x04zV[\0[4\x80\x15a\x02\x19W__\xFD[Pa\x01\xB1a\x04\x99V[4\x80\x15a\x02-W__\xFD[Pa\x01\xB1a\x02<6`\x04a\x10\xF6V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R_Q` a\x14\x80_9_Q\x90_R` R`@\x90 T\x90V[4\x80\x15a\x02mW__\xFD[Pa\x02\x0Ca\x04\xB4V[4\x80\x15a\x02\x81W__\xFD[P\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\x1FV[4\x80\x15a\x02\xC7W__\xFD[Pa\x01\x12a\x04\xC7V[4\x80\x15a\x02\xDBW__\xFD[Pa\x02\x0Ca\x02\xEA6`\x04a\x11-V[a\x05\x05V[4\x80\x15a\x02\xFAW__\xFD[Pa\x01Ga\x03\t6`\x04a\x0F\xABV[a\x06KV[4\x80\x15a\x03\x19W__\xFD[Pa\x01\x12`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d\x03R\xE3\x02\xE3`\xDC\x1B\x81RP\x81V[4\x80\x15a\x03IW__\xFD[Pa\x01\xB1a\x03X6`\x04a\x11\xBBV[a\x06XV[4\x80\x15a\x03hW__\xFD[Pa\x02\x0Ca\x03w6`\x04a\x10\xF6V[a\x06\xA1V[\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x03\x80T``\x91_Q` a\x14\x80_9_Q\x90_R\x91a\x03\xBA\x90a\x11\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xE6\x90a\x11\xECV[\x80\x15a\x041W\x80`\x1F\x10a\x04\x08Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x041V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x14W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x91PP\x90V[_3a\x04I\x81\x85\x85a\x06\xE3V[`\x01\x91PP[\x92\x91PPV[_3a\x04b\x85\x82\x85a\x06\xF5V[a\x04m\x85\x85\x85a\x07XV[`\x01\x91PP[\x93\x92PPPV[a\x04\x82a\x07\xB5V[a\x04\x8B\x82a\x08YV[a\x04\x95\x82\x82a\x08\xA0V[PPV[_a\x04\xA2a\t\\V[P_Q` a\x14\xA0_9_Q\x90_R\x90V[a\x04\xBCa\t\xA5V[a\x04\xC5_a\n\0V[V[\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x04\x80T``\x91_Q` a\x14\x80_9_Q\x90_R\x91a\x03\xBA\x90a\x11\xECV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x81\x15\x80\x15a\x05JWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x05fWP0;\x15[\x90P\x81\x15\x80\x15a\x05tWP\x80\x15[\x15a\x05\x92W`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x05\xBCW\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x05\xC6\x87\x87a\npV[a\x05\xCF\x8Aa\n\x82V[a\x05\xD7a\n\x93V[a\x05\xE3`\x12`\na\x13\x1BV[a\x05\xED\x90\x89a\x13)V[\x97Pa\x05\xF9\x89\x89a\n\x9BV[\x83\x15a\x06?W\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPPPPPV[_3a\x04I\x81\x85\x85a\x07XV[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x06\xA9a\t\xA5V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\xD7W`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[a\x06\xE0\x81a\n\0V[PV[a\x06\xF0\x83\x83\x83`\x01a\n\xCFV[PPPV[_a\x07\0\x84\x84a\x06XV[\x90P_\x19\x81\x14a\x07RW\x81\x81\x10\x15a\x07DW`@Qc}\xC7\xA0\xD9`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01R`$\x81\x01\x82\x90R`D\x81\x01\x83\x90R`d\x01a\x06\xCEV[a\x07R\x84\x84\x84\x84\x03_a\n\xCFV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07\x81W`@QcKc~\x8F`\xE1\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xAAW`@Qc\xECD/\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[a\x06\xF0\x83\x83\x83a\x0B\xB3V[0`\x01`\x01`\xA0\x1B\x03\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\0\x16\x14\x80a\x08;WP\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\0`\x01`\x01`\xA0\x1B\x03\x16a\x08/_Q` a\x14\xA0_9_Q\x90_RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x04\xC5W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08aa\t\xA5V[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01`@Q\x80\x91\x03\x90\xA1PV[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\x08\xFAWP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x08\xF7\x91\x81\x01\x90a\x13@V[`\x01[a\t\"W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x06\xCEV[_Q` a\x14\xA0_9_Q\x90_R\x81\x14a\tRW`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x06\xCEV[a\x06\xF0\x83\x83a\x0C\xECV[0`\x01`\x01`\xA0\x1B\x03\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\0\x16\x14a\x04\xC5W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3a\t\xD7\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x04\xC5W`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x06\xCEV[\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x82\x17\x84U`@Q\x92\x16\x91\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPPV[a\nxa\rAV[a\x04\x95\x82\x82a\r\x8AV[a\n\x8Aa\rAV[a\x06\xE0\x81a\r\xDAV[a\x04\xC5a\rAV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xC4W`@Qc\xECD/\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[a\x04\x95_\x83\x83a\x0B\xB3V[_Q` a\x14\x80_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x85\x16a\x0B\x06W`@Qc\xE6\x02\xDF\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0B/W`@QcJ\x14\x06\xB1`\xE1\x1B\x81R_`\x04\x82\x01R`$\x01a\x06\xCEV[`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x90\x81R`\x01\x83\x01` \x90\x81R`@\x80\x83 \x93\x88\x16\x83R\x92\x90R \x83\x90U\x81\x15a\x0B\xACW\x83`\x01`\x01`\xA0\x1B\x03\x16\x85`\x01`\x01`\xA0\x1B\x03\x16\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x85`@Qa\x0B\xA3\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3[PPPPPV[_Q` a\x14\x80_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0B\xEDW\x81\x81`\x02\x01_\x82\x82Ta\x0B\xE2\x91\x90a\x13WV[\x90\x91UPa\x0C]\x90PV[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R` \x82\x90R`@\x90 T\x82\x81\x10\x15a\x0C?W`@Qc9\x144\xE3`\xE2\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x86\x16`\x04\x82\x01R`$\x81\x01\x82\x90R`D\x81\x01\x84\x90R`d\x01a\x06\xCEV[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R` \x83\x90R`@\x90 \x90\x83\x90\x03\x90U[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x0C{W`\x02\x81\x01\x80T\x83\x90\x03\x90Ua\x0C\x99V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x82\x90R`@\x90 \x80T\x83\x01\x90U[\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x84`@Qa\x0C\xDE\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[a\x0C\xF5\x82a\r\xE2V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\r9Wa\x06\xF0\x82\x82a\x0EEV[a\x04\x95a\x0E\xB7V[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0T`\x01`@\x1B\x90\x04`\xFF\x16a\x04\xC5W`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\r\x92a\rAV[_Q` a\x14\x80_9_Q\x90_R\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x03a\r\xCB\x84\x82a\x13\xAEV[P`\x04\x81\x01a\x07R\x83\x82a\x13\xAEV[a\x06\xA9a\rAV[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x0E\x17W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x06\xCEV[_Q` a\x14\xA0_9_Q\x90_R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``__\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\x0Ea\x91\x90a\x14iV[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x0E\x99W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0E\x9EV[``\x91P[P\x91P\x91Pa\x0E\xAE\x85\x83\x83a\x0E\xD6V[\x95\x94PPPPPV[4\x15a\x04\xC5W`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82a\x0E\xEBWa\x0E\xE6\x82a\x0F2V[a\x04sV[\x81Q\x15\x80\x15a\x0F\x02WP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x0F+W`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\x06\xCEV[P\x80a\x04sV[\x80Q\x15a\x0FBW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0F\xA6W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0F\xBCW__\xFD[a\x0F\xC5\x83a\x0F\x90V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0F\xE5W__\xFD[a\x0F\xEE\x84a\x0F\x90V[\x92Pa\x0F\xFC` \x85\x01a\x0F\x90V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[__g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x11\x15a\x10;Wa\x10;a\x10\rV[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x10jWa\x10ja\x10\rV[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\x10\x81W__\xFD[\x83\x83` \x83\x017_` \x85\x83\x01\x01RP\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x10\xA9W__\xFD[a\x10\xB2\x83a\x0F\x90V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xCDW__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a\x10\xDDW__\xFD[a\x10\xEC\x85\x825` \x84\x01a\x10!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x11\x06W__\xFD[a\x04s\x82a\x0F\x90V[_\x82`\x1F\x83\x01\x12a\x11\x1EW__\xFD[a\x04s\x83\x835` \x85\x01a\x10!V[_____`\xA0\x86\x88\x03\x12\x15a\x11AW__\xFD[a\x11J\x86a\x0F\x90V[\x94Pa\x11X` \x87\x01a\x0F\x90V[\x93P`@\x86\x015\x92P``\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11zW__\xFD[a\x11\x86\x88\x82\x89\x01a\x11\x0FV[\x92PP`\x80\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\xA2W__\xFD[a\x11\xAE\x88\x82\x89\x01a\x11\x0FV[\x91PP\x92\x95P\x92\x95\x90\x93PV[__`@\x83\x85\x03\x12\x15a\x11\xCCW__\xFD[a\x11\xD5\x83a\x0F\x90V[\x91Pa\x11\xE3` \x84\x01a\x0F\x90V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x12\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x12\x1EWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[`\x01\x81[`\x01\x84\x11\x15a\x12sW\x80\x85\x04\x81\x11\x15a\x12WWa\x12Wa\x12$V[`\x01\x84\x16\x15a\x12eW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x12<V[\x93P\x93\x91PPV[_\x82a\x12\x89WP`\x01a\x04OV[\x81a\x12\x95WP_a\x04OV[\x81`\x01\x81\x14a\x12\xABW`\x02\x81\x14a\x12\xB5Wa\x12\xD1V[`\x01\x91PPa\x04OV[`\xFF\x84\x11\x15a\x12\xC6Wa\x12\xC6a\x12$V[PP`\x01\x82\x1Ba\x04OV[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x12\xF4WP\x81\x81\na\x04OV[a\x13\0_\x19\x84\x84a\x128V[\x80_\x19\x04\x82\x11\x15a\x13\x13Wa\x13\x13a\x12$V[\x02\x93\x92PPPV[_a\x04s`\xFF\x84\x16\x83a\x12{V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x04OWa\x04Oa\x12$V[_` \x82\x84\x03\x12\x15a\x13PW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x04OWa\x04Oa\x12$V[`\x1F\x82\x11\x15a\x06\xF0W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x13\x8FWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0B\xACW_\x81U`\x01\x01a\x13\x9BV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xC8Wa\x13\xC8a\x10\rV[a\x13\xDC\x81a\x13\xD6\x84Ta\x11\xECV[\x84a\x13jV[` `\x1F\x82\x11`\x01\x81\x14a\x14\x0EW_\x83\x15a\x13\xF7WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0B\xACV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x14=W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x14\x1DV[P\x84\x82\x10\x15a\x14ZW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV\xFER\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x006\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08\x1C\0\n",
671 );
672 #[derive(Default, Debug, PartialEq, Eq, Hash)]
673 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
678 #[derive(Clone)]
679 pub struct AddressEmptyCode {
680 #[allow(missing_docs)]
681 pub target: alloy::sol_types::private::Address,
682 }
683 #[allow(
684 non_camel_case_types,
685 non_snake_case,
686 clippy::pub_underscore_fields,
687 clippy::style
688 )]
689 const _: () = {
690 use alloy::sol_types as alloy_sol_types;
691 #[doc(hidden)]
692 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
693 #[doc(hidden)]
694 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
695 #[cfg(test)]
696 #[allow(dead_code, unreachable_patterns)]
697 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
698 match _t {
699 alloy_sol_types::private::AssertTypeEq::<
700 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
701 >(_) => {},
702 }
703 }
704 #[automatically_derived]
705 #[doc(hidden)]
706 impl ::core::convert::From<AddressEmptyCode> for UnderlyingRustTuple<'_> {
707 fn from(value: AddressEmptyCode) -> Self {
708 (value.target,)
709 }
710 }
711 #[automatically_derived]
712 #[doc(hidden)]
713 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressEmptyCode {
714 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
715 Self { target: tuple.0 }
716 }
717 }
718 #[automatically_derived]
719 impl alloy_sol_types::SolError for AddressEmptyCode {
720 type Parameters<'a> = UnderlyingSolTuple<'a>;
721 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
722 const SIGNATURE: &'static str = "AddressEmptyCode(address)";
723 const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8];
724 #[inline]
725 fn new<'a>(
726 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
727 ) -> Self {
728 tuple.into()
729 }
730 #[inline]
731 fn tokenize(&self) -> Self::Token<'_> {
732 (
733 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
734 &self.target,
735 ),
736 )
737 }
738 }
739 };
740 #[derive(Default, Debug, PartialEq, Eq, Hash)]
741 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
746 #[derive(Clone)]
747 pub struct ERC1967InvalidImplementation {
748 #[allow(missing_docs)]
749 pub implementation: alloy::sol_types::private::Address,
750 }
751 #[allow(
752 non_camel_case_types,
753 non_snake_case,
754 clippy::pub_underscore_fields,
755 clippy::style
756 )]
757 const _: () = {
758 use alloy::sol_types as alloy_sol_types;
759 #[doc(hidden)]
760 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
761 #[doc(hidden)]
762 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
763 #[cfg(test)]
764 #[allow(dead_code, unreachable_patterns)]
765 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
766 match _t {
767 alloy_sol_types::private::AssertTypeEq::<
768 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
769 >(_) => {},
770 }
771 }
772 #[automatically_derived]
773 #[doc(hidden)]
774 impl ::core::convert::From<ERC1967InvalidImplementation> for UnderlyingRustTuple<'_> {
775 fn from(value: ERC1967InvalidImplementation) -> Self {
776 (value.implementation,)
777 }
778 }
779 #[automatically_derived]
780 #[doc(hidden)]
781 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1967InvalidImplementation {
782 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
783 Self {
784 implementation: tuple.0,
785 }
786 }
787 }
788 #[automatically_derived]
789 impl alloy_sol_types::SolError for ERC1967InvalidImplementation {
790 type Parameters<'a> = UnderlyingSolTuple<'a>;
791 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
792 const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)";
793 const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8];
794 #[inline]
795 fn new<'a>(
796 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
797 ) -> Self {
798 tuple.into()
799 }
800 #[inline]
801 fn tokenize(&self) -> Self::Token<'_> {
802 (
803 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
804 &self.implementation,
805 ),
806 )
807 }
808 }
809 };
810 #[derive(Default, Debug, PartialEq, Eq, Hash)]
811 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
816 #[derive(Clone)]
817 pub struct ERC1967NonPayable {}
818 #[allow(
819 non_camel_case_types,
820 non_snake_case,
821 clippy::pub_underscore_fields,
822 clippy::style
823 )]
824 const _: () = {
825 use alloy::sol_types as alloy_sol_types;
826 #[doc(hidden)]
827 type UnderlyingSolTuple<'a> = ();
828 #[doc(hidden)]
829 type UnderlyingRustTuple<'a> = ();
830 #[cfg(test)]
831 #[allow(dead_code, unreachable_patterns)]
832 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
833 match _t {
834 alloy_sol_types::private::AssertTypeEq::<
835 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
836 >(_) => {},
837 }
838 }
839 #[automatically_derived]
840 #[doc(hidden)]
841 impl ::core::convert::From<ERC1967NonPayable> for UnderlyingRustTuple<'_> {
842 fn from(value: ERC1967NonPayable) -> Self {
843 ()
844 }
845 }
846 #[automatically_derived]
847 #[doc(hidden)]
848 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1967NonPayable {
849 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
850 Self {}
851 }
852 }
853 #[automatically_derived]
854 impl alloy_sol_types::SolError for ERC1967NonPayable {
855 type Parameters<'a> = UnderlyingSolTuple<'a>;
856 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
857 const SIGNATURE: &'static str = "ERC1967NonPayable()";
858 const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8];
859 #[inline]
860 fn new<'a>(
861 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
862 ) -> Self {
863 tuple.into()
864 }
865 #[inline]
866 fn tokenize(&self) -> Self::Token<'_> {
867 ()
868 }
869 }
870 };
871 #[derive(Default, Debug, PartialEq, Eq, Hash)]
872 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
877 #[derive(Clone)]
878 pub struct ERC20InsufficientAllowance {
879 #[allow(missing_docs)]
880 pub spender: alloy::sol_types::private::Address,
881 #[allow(missing_docs)]
882 pub allowance: alloy::sol_types::private::primitives::aliases::U256,
883 #[allow(missing_docs)]
884 pub needed: alloy::sol_types::private::primitives::aliases::U256,
885 }
886 #[allow(
887 non_camel_case_types,
888 non_snake_case,
889 clippy::pub_underscore_fields,
890 clippy::style
891 )]
892 const _: () = {
893 use alloy::sol_types as alloy_sol_types;
894 #[doc(hidden)]
895 type UnderlyingSolTuple<'a> = (
896 alloy::sol_types::sol_data::Address,
897 alloy::sol_types::sol_data::Uint<256>,
898 alloy::sol_types::sol_data::Uint<256>,
899 );
900 #[doc(hidden)]
901 type UnderlyingRustTuple<'a> = (
902 alloy::sol_types::private::Address,
903 alloy::sol_types::private::primitives::aliases::U256,
904 alloy::sol_types::private::primitives::aliases::U256,
905 );
906 #[cfg(test)]
907 #[allow(dead_code, unreachable_patterns)]
908 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
909 match _t {
910 alloy_sol_types::private::AssertTypeEq::<
911 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
912 >(_) => {},
913 }
914 }
915 #[automatically_derived]
916 #[doc(hidden)]
917 impl ::core::convert::From<ERC20InsufficientAllowance> for UnderlyingRustTuple<'_> {
918 fn from(value: ERC20InsufficientAllowance) -> Self {
919 (value.spender, value.allowance, value.needed)
920 }
921 }
922 #[automatically_derived]
923 #[doc(hidden)]
924 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InsufficientAllowance {
925 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
926 Self {
927 spender: tuple.0,
928 allowance: tuple.1,
929 needed: tuple.2,
930 }
931 }
932 }
933 #[automatically_derived]
934 impl alloy_sol_types::SolError for ERC20InsufficientAllowance {
935 type Parameters<'a> = UnderlyingSolTuple<'a>;
936 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
937 const SIGNATURE: &'static str = "ERC20InsufficientAllowance(address,uint256,uint256)";
938 const SELECTOR: [u8; 4] = [251u8, 143u8, 65u8, 178u8];
939 #[inline]
940 fn new<'a>(
941 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
942 ) -> Self {
943 tuple.into()
944 }
945 #[inline]
946 fn tokenize(&self) -> Self::Token<'_> {
947 (
948 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
949 &self.spender,
950 ),
951 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
952 &self.allowance,
953 ),
954 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
955 &self.needed,
956 ),
957 )
958 }
959 }
960 };
961 #[derive(Default, Debug, PartialEq, Eq, Hash)]
962 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
967 #[derive(Clone)]
968 pub struct ERC20InsufficientBalance {
969 #[allow(missing_docs)]
970 pub sender: alloy::sol_types::private::Address,
971 #[allow(missing_docs)]
972 pub balance: alloy::sol_types::private::primitives::aliases::U256,
973 #[allow(missing_docs)]
974 pub needed: alloy::sol_types::private::primitives::aliases::U256,
975 }
976 #[allow(
977 non_camel_case_types,
978 non_snake_case,
979 clippy::pub_underscore_fields,
980 clippy::style
981 )]
982 const _: () = {
983 use alloy::sol_types as alloy_sol_types;
984 #[doc(hidden)]
985 type UnderlyingSolTuple<'a> = (
986 alloy::sol_types::sol_data::Address,
987 alloy::sol_types::sol_data::Uint<256>,
988 alloy::sol_types::sol_data::Uint<256>,
989 );
990 #[doc(hidden)]
991 type UnderlyingRustTuple<'a> = (
992 alloy::sol_types::private::Address,
993 alloy::sol_types::private::primitives::aliases::U256,
994 alloy::sol_types::private::primitives::aliases::U256,
995 );
996 #[cfg(test)]
997 #[allow(dead_code, unreachable_patterns)]
998 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
999 match _t {
1000 alloy_sol_types::private::AssertTypeEq::<
1001 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1002 >(_) => {},
1003 }
1004 }
1005 #[automatically_derived]
1006 #[doc(hidden)]
1007 impl ::core::convert::From<ERC20InsufficientBalance> for UnderlyingRustTuple<'_> {
1008 fn from(value: ERC20InsufficientBalance) -> Self {
1009 (value.sender, value.balance, value.needed)
1010 }
1011 }
1012 #[automatically_derived]
1013 #[doc(hidden)]
1014 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InsufficientBalance {
1015 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1016 Self {
1017 sender: tuple.0,
1018 balance: tuple.1,
1019 needed: tuple.2,
1020 }
1021 }
1022 }
1023 #[automatically_derived]
1024 impl alloy_sol_types::SolError for ERC20InsufficientBalance {
1025 type Parameters<'a> = UnderlyingSolTuple<'a>;
1026 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1027 const SIGNATURE: &'static str = "ERC20InsufficientBalance(address,uint256,uint256)";
1028 const SELECTOR: [u8; 4] = [228u8, 80u8, 211u8, 140u8];
1029 #[inline]
1030 fn new<'a>(
1031 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1032 ) -> Self {
1033 tuple.into()
1034 }
1035 #[inline]
1036 fn tokenize(&self) -> Self::Token<'_> {
1037 (
1038 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1039 &self.sender,
1040 ),
1041 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1042 &self.balance,
1043 ),
1044 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1045 &self.needed,
1046 ),
1047 )
1048 }
1049 }
1050 };
1051 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1052 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1057 #[derive(Clone)]
1058 pub struct ERC20InvalidApprover {
1059 #[allow(missing_docs)]
1060 pub approver: alloy::sol_types::private::Address,
1061 }
1062 #[allow(
1063 non_camel_case_types,
1064 non_snake_case,
1065 clippy::pub_underscore_fields,
1066 clippy::style
1067 )]
1068 const _: () = {
1069 use alloy::sol_types as alloy_sol_types;
1070 #[doc(hidden)]
1071 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1072 #[doc(hidden)]
1073 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1074 #[cfg(test)]
1075 #[allow(dead_code, unreachable_patterns)]
1076 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1077 match _t {
1078 alloy_sol_types::private::AssertTypeEq::<
1079 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1080 >(_) => {},
1081 }
1082 }
1083 #[automatically_derived]
1084 #[doc(hidden)]
1085 impl ::core::convert::From<ERC20InvalidApprover> for UnderlyingRustTuple<'_> {
1086 fn from(value: ERC20InvalidApprover) -> Self {
1087 (value.approver,)
1088 }
1089 }
1090 #[automatically_derived]
1091 #[doc(hidden)]
1092 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidApprover {
1093 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1094 Self { approver: tuple.0 }
1095 }
1096 }
1097 #[automatically_derived]
1098 impl alloy_sol_types::SolError for ERC20InvalidApprover {
1099 type Parameters<'a> = UnderlyingSolTuple<'a>;
1100 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1101 const SIGNATURE: &'static str = "ERC20InvalidApprover(address)";
1102 const SELECTOR: [u8; 4] = [230u8, 2u8, 223u8, 5u8];
1103 #[inline]
1104 fn new<'a>(
1105 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1106 ) -> Self {
1107 tuple.into()
1108 }
1109 #[inline]
1110 fn tokenize(&self) -> Self::Token<'_> {
1111 (
1112 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1113 &self.approver,
1114 ),
1115 )
1116 }
1117 }
1118 };
1119 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1120 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1125 #[derive(Clone)]
1126 pub struct ERC20InvalidReceiver {
1127 #[allow(missing_docs)]
1128 pub receiver: alloy::sol_types::private::Address,
1129 }
1130 #[allow(
1131 non_camel_case_types,
1132 non_snake_case,
1133 clippy::pub_underscore_fields,
1134 clippy::style
1135 )]
1136 const _: () = {
1137 use alloy::sol_types as alloy_sol_types;
1138 #[doc(hidden)]
1139 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1140 #[doc(hidden)]
1141 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1142 #[cfg(test)]
1143 #[allow(dead_code, unreachable_patterns)]
1144 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1145 match _t {
1146 alloy_sol_types::private::AssertTypeEq::<
1147 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1148 >(_) => {},
1149 }
1150 }
1151 #[automatically_derived]
1152 #[doc(hidden)]
1153 impl ::core::convert::From<ERC20InvalidReceiver> for UnderlyingRustTuple<'_> {
1154 fn from(value: ERC20InvalidReceiver) -> Self {
1155 (value.receiver,)
1156 }
1157 }
1158 #[automatically_derived]
1159 #[doc(hidden)]
1160 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidReceiver {
1161 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1162 Self { receiver: tuple.0 }
1163 }
1164 }
1165 #[automatically_derived]
1166 impl alloy_sol_types::SolError for ERC20InvalidReceiver {
1167 type Parameters<'a> = UnderlyingSolTuple<'a>;
1168 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1169 const SIGNATURE: &'static str = "ERC20InvalidReceiver(address)";
1170 const SELECTOR: [u8; 4] = [236u8, 68u8, 47u8, 5u8];
1171 #[inline]
1172 fn new<'a>(
1173 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1174 ) -> Self {
1175 tuple.into()
1176 }
1177 #[inline]
1178 fn tokenize(&self) -> Self::Token<'_> {
1179 (
1180 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1181 &self.receiver,
1182 ),
1183 )
1184 }
1185 }
1186 };
1187 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1188 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1193 #[derive(Clone)]
1194 pub struct ERC20InvalidSender {
1195 #[allow(missing_docs)]
1196 pub sender: alloy::sol_types::private::Address,
1197 }
1198 #[allow(
1199 non_camel_case_types,
1200 non_snake_case,
1201 clippy::pub_underscore_fields,
1202 clippy::style
1203 )]
1204 const _: () = {
1205 use alloy::sol_types as alloy_sol_types;
1206 #[doc(hidden)]
1207 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1208 #[doc(hidden)]
1209 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1210 #[cfg(test)]
1211 #[allow(dead_code, unreachable_patterns)]
1212 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1213 match _t {
1214 alloy_sol_types::private::AssertTypeEq::<
1215 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1216 >(_) => {},
1217 }
1218 }
1219 #[automatically_derived]
1220 #[doc(hidden)]
1221 impl ::core::convert::From<ERC20InvalidSender> for UnderlyingRustTuple<'_> {
1222 fn from(value: ERC20InvalidSender) -> Self {
1223 (value.sender,)
1224 }
1225 }
1226 #[automatically_derived]
1227 #[doc(hidden)]
1228 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidSender {
1229 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1230 Self { sender: tuple.0 }
1231 }
1232 }
1233 #[automatically_derived]
1234 impl alloy_sol_types::SolError for ERC20InvalidSender {
1235 type Parameters<'a> = UnderlyingSolTuple<'a>;
1236 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1237 const SIGNATURE: &'static str = "ERC20InvalidSender(address)";
1238 const SELECTOR: [u8; 4] = [150u8, 198u8, 253u8, 30u8];
1239 #[inline]
1240 fn new<'a>(
1241 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1242 ) -> Self {
1243 tuple.into()
1244 }
1245 #[inline]
1246 fn tokenize(&self) -> Self::Token<'_> {
1247 (
1248 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1249 &self.sender,
1250 ),
1251 )
1252 }
1253 }
1254 };
1255 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1256 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1261 #[derive(Clone)]
1262 pub struct ERC20InvalidSpender {
1263 #[allow(missing_docs)]
1264 pub spender: alloy::sol_types::private::Address,
1265 }
1266 #[allow(
1267 non_camel_case_types,
1268 non_snake_case,
1269 clippy::pub_underscore_fields,
1270 clippy::style
1271 )]
1272 const _: () = {
1273 use alloy::sol_types as alloy_sol_types;
1274 #[doc(hidden)]
1275 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1276 #[doc(hidden)]
1277 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1278 #[cfg(test)]
1279 #[allow(dead_code, unreachable_patterns)]
1280 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1281 match _t {
1282 alloy_sol_types::private::AssertTypeEq::<
1283 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1284 >(_) => {},
1285 }
1286 }
1287 #[automatically_derived]
1288 #[doc(hidden)]
1289 impl ::core::convert::From<ERC20InvalidSpender> for UnderlyingRustTuple<'_> {
1290 fn from(value: ERC20InvalidSpender) -> Self {
1291 (value.spender,)
1292 }
1293 }
1294 #[automatically_derived]
1295 #[doc(hidden)]
1296 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidSpender {
1297 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1298 Self { spender: tuple.0 }
1299 }
1300 }
1301 #[automatically_derived]
1302 impl alloy_sol_types::SolError for ERC20InvalidSpender {
1303 type Parameters<'a> = UnderlyingSolTuple<'a>;
1304 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1305 const SIGNATURE: &'static str = "ERC20InvalidSpender(address)";
1306 const SELECTOR: [u8; 4] = [148u8, 40u8, 13u8, 98u8];
1307 #[inline]
1308 fn new<'a>(
1309 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1310 ) -> Self {
1311 tuple.into()
1312 }
1313 #[inline]
1314 fn tokenize(&self) -> Self::Token<'_> {
1315 (
1316 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1317 &self.spender,
1318 ),
1319 )
1320 }
1321 }
1322 };
1323 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1324 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1329 #[derive(Clone)]
1330 pub struct FailedInnerCall {}
1331 #[allow(
1332 non_camel_case_types,
1333 non_snake_case,
1334 clippy::pub_underscore_fields,
1335 clippy::style
1336 )]
1337 const _: () = {
1338 use alloy::sol_types as alloy_sol_types;
1339 #[doc(hidden)]
1340 type UnderlyingSolTuple<'a> = ();
1341 #[doc(hidden)]
1342 type UnderlyingRustTuple<'a> = ();
1343 #[cfg(test)]
1344 #[allow(dead_code, unreachable_patterns)]
1345 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1346 match _t {
1347 alloy_sol_types::private::AssertTypeEq::<
1348 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1349 >(_) => {},
1350 }
1351 }
1352 #[automatically_derived]
1353 #[doc(hidden)]
1354 impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
1355 fn from(value: FailedInnerCall) -> Self {
1356 ()
1357 }
1358 }
1359 #[automatically_derived]
1360 #[doc(hidden)]
1361 impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
1362 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1363 Self {}
1364 }
1365 }
1366 #[automatically_derived]
1367 impl alloy_sol_types::SolError for FailedInnerCall {
1368 type Parameters<'a> = UnderlyingSolTuple<'a>;
1369 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1370 const SIGNATURE: &'static str = "FailedInnerCall()";
1371 const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
1372 #[inline]
1373 fn new<'a>(
1374 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1375 ) -> Self {
1376 tuple.into()
1377 }
1378 #[inline]
1379 fn tokenize(&self) -> Self::Token<'_> {
1380 ()
1381 }
1382 }
1383 };
1384 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1385 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1390 #[derive(Clone)]
1391 pub struct InvalidInitialization {}
1392 #[allow(
1393 non_camel_case_types,
1394 non_snake_case,
1395 clippy::pub_underscore_fields,
1396 clippy::style
1397 )]
1398 const _: () = {
1399 use alloy::sol_types as alloy_sol_types;
1400 #[doc(hidden)]
1401 type UnderlyingSolTuple<'a> = ();
1402 #[doc(hidden)]
1403 type UnderlyingRustTuple<'a> = ();
1404 #[cfg(test)]
1405 #[allow(dead_code, unreachable_patterns)]
1406 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1407 match _t {
1408 alloy_sol_types::private::AssertTypeEq::<
1409 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1410 >(_) => {},
1411 }
1412 }
1413 #[automatically_derived]
1414 #[doc(hidden)]
1415 impl ::core::convert::From<InvalidInitialization> for UnderlyingRustTuple<'_> {
1416 fn from(value: InvalidInitialization) -> Self {
1417 ()
1418 }
1419 }
1420 #[automatically_derived]
1421 #[doc(hidden)]
1422 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInitialization {
1423 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1424 Self {}
1425 }
1426 }
1427 #[automatically_derived]
1428 impl alloy_sol_types::SolError for InvalidInitialization {
1429 type Parameters<'a> = UnderlyingSolTuple<'a>;
1430 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1431 const SIGNATURE: &'static str = "InvalidInitialization()";
1432 const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8];
1433 #[inline]
1434 fn new<'a>(
1435 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1436 ) -> Self {
1437 tuple.into()
1438 }
1439 #[inline]
1440 fn tokenize(&self) -> Self::Token<'_> {
1441 ()
1442 }
1443 }
1444 };
1445 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1446 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1451 #[derive(Clone)]
1452 pub struct NotInitializing {}
1453 #[allow(
1454 non_camel_case_types,
1455 non_snake_case,
1456 clippy::pub_underscore_fields,
1457 clippy::style
1458 )]
1459 const _: () = {
1460 use alloy::sol_types as alloy_sol_types;
1461 #[doc(hidden)]
1462 type UnderlyingSolTuple<'a> = ();
1463 #[doc(hidden)]
1464 type UnderlyingRustTuple<'a> = ();
1465 #[cfg(test)]
1466 #[allow(dead_code, unreachable_patterns)]
1467 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1468 match _t {
1469 alloy_sol_types::private::AssertTypeEq::<
1470 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1471 >(_) => {},
1472 }
1473 }
1474 #[automatically_derived]
1475 #[doc(hidden)]
1476 impl ::core::convert::From<NotInitializing> for UnderlyingRustTuple<'_> {
1477 fn from(value: NotInitializing) -> Self {
1478 ()
1479 }
1480 }
1481 #[automatically_derived]
1482 #[doc(hidden)]
1483 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotInitializing {
1484 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1485 Self {}
1486 }
1487 }
1488 #[automatically_derived]
1489 impl alloy_sol_types::SolError for NotInitializing {
1490 type Parameters<'a> = UnderlyingSolTuple<'a>;
1491 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1492 const SIGNATURE: &'static str = "NotInitializing()";
1493 const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8];
1494 #[inline]
1495 fn new<'a>(
1496 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1497 ) -> Self {
1498 tuple.into()
1499 }
1500 #[inline]
1501 fn tokenize(&self) -> Self::Token<'_> {
1502 ()
1503 }
1504 }
1505 };
1506 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1507 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1512 #[derive(Clone)]
1513 pub struct OwnableInvalidOwner {
1514 #[allow(missing_docs)]
1515 pub owner: alloy::sol_types::private::Address,
1516 }
1517 #[allow(
1518 non_camel_case_types,
1519 non_snake_case,
1520 clippy::pub_underscore_fields,
1521 clippy::style
1522 )]
1523 const _: () = {
1524 use alloy::sol_types as alloy_sol_types;
1525 #[doc(hidden)]
1526 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1527 #[doc(hidden)]
1528 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1529 #[cfg(test)]
1530 #[allow(dead_code, unreachable_patterns)]
1531 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1532 match _t {
1533 alloy_sol_types::private::AssertTypeEq::<
1534 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1535 >(_) => {},
1536 }
1537 }
1538 #[automatically_derived]
1539 #[doc(hidden)]
1540 impl ::core::convert::From<OwnableInvalidOwner> for UnderlyingRustTuple<'_> {
1541 fn from(value: OwnableInvalidOwner) -> Self {
1542 (value.owner,)
1543 }
1544 }
1545 #[automatically_derived]
1546 #[doc(hidden)]
1547 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableInvalidOwner {
1548 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1549 Self { owner: tuple.0 }
1550 }
1551 }
1552 #[automatically_derived]
1553 impl alloy_sol_types::SolError for OwnableInvalidOwner {
1554 type Parameters<'a> = UnderlyingSolTuple<'a>;
1555 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1556 const SIGNATURE: &'static str = "OwnableInvalidOwner(address)";
1557 const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8];
1558 #[inline]
1559 fn new<'a>(
1560 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1561 ) -> Self {
1562 tuple.into()
1563 }
1564 #[inline]
1565 fn tokenize(&self) -> Self::Token<'_> {
1566 (
1567 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1568 &self.owner,
1569 ),
1570 )
1571 }
1572 }
1573 };
1574 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1575 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1580 #[derive(Clone)]
1581 pub struct OwnableUnauthorizedAccount {
1582 #[allow(missing_docs)]
1583 pub account: alloy::sol_types::private::Address,
1584 }
1585 #[allow(
1586 non_camel_case_types,
1587 non_snake_case,
1588 clippy::pub_underscore_fields,
1589 clippy::style
1590 )]
1591 const _: () = {
1592 use alloy::sol_types as alloy_sol_types;
1593 #[doc(hidden)]
1594 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1595 #[doc(hidden)]
1596 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1597 #[cfg(test)]
1598 #[allow(dead_code, unreachable_patterns)]
1599 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1600 match _t {
1601 alloy_sol_types::private::AssertTypeEq::<
1602 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1603 >(_) => {},
1604 }
1605 }
1606 #[automatically_derived]
1607 #[doc(hidden)]
1608 impl ::core::convert::From<OwnableUnauthorizedAccount> for UnderlyingRustTuple<'_> {
1609 fn from(value: OwnableUnauthorizedAccount) -> Self {
1610 (value.account,)
1611 }
1612 }
1613 #[automatically_derived]
1614 #[doc(hidden)]
1615 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableUnauthorizedAccount {
1616 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1617 Self { account: tuple.0 }
1618 }
1619 }
1620 #[automatically_derived]
1621 impl alloy_sol_types::SolError for OwnableUnauthorizedAccount {
1622 type Parameters<'a> = UnderlyingSolTuple<'a>;
1623 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1624 const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)";
1625 const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8];
1626 #[inline]
1627 fn new<'a>(
1628 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1629 ) -> Self {
1630 tuple.into()
1631 }
1632 #[inline]
1633 fn tokenize(&self) -> Self::Token<'_> {
1634 (
1635 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1636 &self.account,
1637 ),
1638 )
1639 }
1640 }
1641 };
1642 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1643 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1648 #[derive(Clone)]
1649 pub struct UUPSUnauthorizedCallContext {}
1650 #[allow(
1651 non_camel_case_types,
1652 non_snake_case,
1653 clippy::pub_underscore_fields,
1654 clippy::style
1655 )]
1656 const _: () = {
1657 use alloy::sol_types as alloy_sol_types;
1658 #[doc(hidden)]
1659 type UnderlyingSolTuple<'a> = ();
1660 #[doc(hidden)]
1661 type UnderlyingRustTuple<'a> = ();
1662 #[cfg(test)]
1663 #[allow(dead_code, unreachable_patterns)]
1664 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1665 match _t {
1666 alloy_sol_types::private::AssertTypeEq::<
1667 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1668 >(_) => {},
1669 }
1670 }
1671 #[automatically_derived]
1672 #[doc(hidden)]
1673 impl ::core::convert::From<UUPSUnauthorizedCallContext> for UnderlyingRustTuple<'_> {
1674 fn from(value: UUPSUnauthorizedCallContext) -> Self {
1675 ()
1676 }
1677 }
1678 #[automatically_derived]
1679 #[doc(hidden)]
1680 impl ::core::convert::From<UnderlyingRustTuple<'_>> for UUPSUnauthorizedCallContext {
1681 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1682 Self {}
1683 }
1684 }
1685 #[automatically_derived]
1686 impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext {
1687 type Parameters<'a> = UnderlyingSolTuple<'a>;
1688 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1689 const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()";
1690 const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8];
1691 #[inline]
1692 fn new<'a>(
1693 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1694 ) -> Self {
1695 tuple.into()
1696 }
1697 #[inline]
1698 fn tokenize(&self) -> Self::Token<'_> {
1699 ()
1700 }
1701 }
1702 };
1703 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1704 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1709 #[derive(Clone)]
1710 pub struct UUPSUnsupportedProxiableUUID {
1711 #[allow(missing_docs)]
1712 pub slot: alloy::sol_types::private::FixedBytes<32>,
1713 }
1714 #[allow(
1715 non_camel_case_types,
1716 non_snake_case,
1717 clippy::pub_underscore_fields,
1718 clippy::style
1719 )]
1720 const _: () = {
1721 use alloy::sol_types as alloy_sol_types;
1722 #[doc(hidden)]
1723 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1724 #[doc(hidden)]
1725 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1726 #[cfg(test)]
1727 #[allow(dead_code, unreachable_patterns)]
1728 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1729 match _t {
1730 alloy_sol_types::private::AssertTypeEq::<
1731 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1732 >(_) => {},
1733 }
1734 }
1735 #[automatically_derived]
1736 #[doc(hidden)]
1737 impl ::core::convert::From<UUPSUnsupportedProxiableUUID> for UnderlyingRustTuple<'_> {
1738 fn from(value: UUPSUnsupportedProxiableUUID) -> Self {
1739 (value.slot,)
1740 }
1741 }
1742 #[automatically_derived]
1743 #[doc(hidden)]
1744 impl ::core::convert::From<UnderlyingRustTuple<'_>> for UUPSUnsupportedProxiableUUID {
1745 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1746 Self { slot: tuple.0 }
1747 }
1748 }
1749 #[automatically_derived]
1750 impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID {
1751 type Parameters<'a> = UnderlyingSolTuple<'a>;
1752 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1753 const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)";
1754 const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8];
1755 #[inline]
1756 fn new<'a>(
1757 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1758 ) -> Self {
1759 tuple.into()
1760 }
1761 #[inline]
1762 fn tokenize(&self) -> Self::Token<'_> {
1763 (
1764 <alloy::sol_types::sol_data::FixedBytes<
1765 32,
1766 > as alloy_sol_types::SolType>::tokenize(&self.slot),
1767 )
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 Approval {
1784 #[allow(missing_docs)]
1785 pub owner: alloy::sol_types::private::Address,
1786 #[allow(missing_docs)]
1787 pub spender: alloy::sol_types::private::Address,
1788 #[allow(missing_docs)]
1789 pub value: alloy::sol_types::private::primitives::aliases::U256,
1790 }
1791 #[allow(
1792 non_camel_case_types,
1793 non_snake_case,
1794 clippy::pub_underscore_fields,
1795 clippy::style
1796 )]
1797 const _: () = {
1798 use alloy::sol_types as alloy_sol_types;
1799 #[automatically_derived]
1800 impl alloy_sol_types::SolEvent for Approval {
1801 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1802 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1803 type TopicList = (
1804 alloy_sol_types::sol_data::FixedBytes<32>,
1805 alloy::sol_types::sol_data::Address,
1806 alloy::sol_types::sol_data::Address,
1807 );
1808 const SIGNATURE: &'static str = "Approval(address,address,uint256)";
1809 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
1810 alloy_sol_types::private::B256::new([
1811 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
1812 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
1813 91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
1814 ]);
1815 const ANONYMOUS: bool = false;
1816 #[allow(unused_variables)]
1817 #[inline]
1818 fn new(
1819 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1820 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1821 ) -> Self {
1822 Self {
1823 owner: topics.1,
1824 spender: topics.2,
1825 value: data.0,
1826 }
1827 }
1828 #[inline]
1829 fn check_signature(
1830 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1831 ) -> alloy_sol_types::Result<()> {
1832 if topics.0 != Self::SIGNATURE_HASH {
1833 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
1834 Self::SIGNATURE,
1835 topics.0,
1836 Self::SIGNATURE_HASH,
1837 ));
1838 }
1839 Ok(())
1840 }
1841 #[inline]
1842 fn tokenize_body(&self) -> Self::DataToken<'_> {
1843 (
1844 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1845 &self.value,
1846 ),
1847 )
1848 }
1849 #[inline]
1850 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1851 (
1852 Self::SIGNATURE_HASH.into(),
1853 self.owner.clone(),
1854 self.spender.clone(),
1855 )
1856 }
1857 #[inline]
1858 fn encode_topics_raw(
1859 &self,
1860 out: &mut [alloy_sol_types::abi::token::WordToken],
1861 ) -> alloy_sol_types::Result<()> {
1862 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1863 return Err(alloy_sol_types::Error::Overrun);
1864 }
1865 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
1866 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1867 &self.owner,
1868 );
1869 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1870 &self.spender,
1871 );
1872 Ok(())
1873 }
1874 }
1875 #[automatically_derived]
1876 impl alloy_sol_types::private::IntoLogData for Approval {
1877 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1878 From::from(self)
1879 }
1880 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1881 From::from(&self)
1882 }
1883 }
1884 #[automatically_derived]
1885 impl From<&Approval> for alloy_sol_types::private::LogData {
1886 #[inline]
1887 fn from(this: &Approval) -> alloy_sol_types::private::LogData {
1888 alloy_sol_types::SolEvent::encode_log_data(this)
1889 }
1890 }
1891 };
1892 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1893 #[allow(
1898 non_camel_case_types,
1899 non_snake_case,
1900 clippy::pub_underscore_fields,
1901 clippy::style
1902 )]
1903 #[derive(Clone)]
1904 pub struct Initialized {
1905 #[allow(missing_docs)]
1906 pub version: u64,
1907 }
1908 #[allow(
1909 non_camel_case_types,
1910 non_snake_case,
1911 clippy::pub_underscore_fields,
1912 clippy::style
1913 )]
1914 const _: () = {
1915 use alloy::sol_types as alloy_sol_types;
1916 #[automatically_derived]
1917 impl alloy_sol_types::SolEvent for Initialized {
1918 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
1919 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1920 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1921 const SIGNATURE: &'static str = "Initialized(uint64)";
1922 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
1923 alloy_sol_types::private::B256::new([
1924 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8,
1925 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8,
1926 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
1927 ]);
1928 const ANONYMOUS: bool = false;
1929 #[allow(unused_variables)]
1930 #[inline]
1931 fn new(
1932 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1933 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1934 ) -> Self {
1935 Self { version: data.0 }
1936 }
1937 #[inline]
1938 fn check_signature(
1939 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1940 ) -> alloy_sol_types::Result<()> {
1941 if topics.0 != Self::SIGNATURE_HASH {
1942 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
1943 Self::SIGNATURE,
1944 topics.0,
1945 Self::SIGNATURE_HASH,
1946 ));
1947 }
1948 Ok(())
1949 }
1950 #[inline]
1951 fn tokenize_body(&self) -> Self::DataToken<'_> {
1952 (
1953 <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
1954 &self.version,
1955 ),
1956 )
1957 }
1958 #[inline]
1959 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1960 (Self::SIGNATURE_HASH.into(),)
1961 }
1962 #[inline]
1963 fn encode_topics_raw(
1964 &self,
1965 out: &mut [alloy_sol_types::abi::token::WordToken],
1966 ) -> alloy_sol_types::Result<()> {
1967 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1968 return Err(alloy_sol_types::Error::Overrun);
1969 }
1970 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
1971 Ok(())
1972 }
1973 }
1974 #[automatically_derived]
1975 impl alloy_sol_types::private::IntoLogData for Initialized {
1976 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1977 From::from(self)
1978 }
1979 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1980 From::from(&self)
1981 }
1982 }
1983 #[automatically_derived]
1984 impl From<&Initialized> for alloy_sol_types::private::LogData {
1985 #[inline]
1986 fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
1987 alloy_sol_types::SolEvent::encode_log_data(this)
1988 }
1989 }
1990 };
1991 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1992 #[allow(
1997 non_camel_case_types,
1998 non_snake_case,
1999 clippy::pub_underscore_fields,
2000 clippy::style
2001 )]
2002 #[derive(Clone)]
2003 pub struct OwnershipTransferred {
2004 #[allow(missing_docs)]
2005 pub previousOwner: alloy::sol_types::private::Address,
2006 #[allow(missing_docs)]
2007 pub newOwner: alloy::sol_types::private::Address,
2008 }
2009 #[allow(
2010 non_camel_case_types,
2011 non_snake_case,
2012 clippy::pub_underscore_fields,
2013 clippy::style
2014 )]
2015 const _: () = {
2016 use alloy::sol_types as alloy_sol_types;
2017 #[automatically_derived]
2018 impl alloy_sol_types::SolEvent for OwnershipTransferred {
2019 type DataTuple<'a> = ();
2020 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2021 type TopicList = (
2022 alloy_sol_types::sol_data::FixedBytes<32>,
2023 alloy::sol_types::sol_data::Address,
2024 alloy::sol_types::sol_data::Address,
2025 );
2026 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
2027 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2028 alloy_sol_types::private::B256::new([
2029 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8,
2030 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8,
2031 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
2032 ]);
2033 const ANONYMOUS: bool = false;
2034 #[allow(unused_variables)]
2035 #[inline]
2036 fn new(
2037 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2038 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2039 ) -> Self {
2040 Self {
2041 previousOwner: topics.1,
2042 newOwner: topics.2,
2043 }
2044 }
2045 #[inline]
2046 fn check_signature(
2047 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2048 ) -> alloy_sol_types::Result<()> {
2049 if topics.0 != Self::SIGNATURE_HASH {
2050 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2051 Self::SIGNATURE,
2052 topics.0,
2053 Self::SIGNATURE_HASH,
2054 ));
2055 }
2056 Ok(())
2057 }
2058 #[inline]
2059 fn tokenize_body(&self) -> Self::DataToken<'_> {
2060 ()
2061 }
2062 #[inline]
2063 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2064 (
2065 Self::SIGNATURE_HASH.into(),
2066 self.previousOwner.clone(),
2067 self.newOwner.clone(),
2068 )
2069 }
2070 #[inline]
2071 fn encode_topics_raw(
2072 &self,
2073 out: &mut [alloy_sol_types::abi::token::WordToken],
2074 ) -> alloy_sol_types::Result<()> {
2075 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2076 return Err(alloy_sol_types::Error::Overrun);
2077 }
2078 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2079 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2080 &self.previousOwner,
2081 );
2082 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2083 &self.newOwner,
2084 );
2085 Ok(())
2086 }
2087 }
2088 #[automatically_derived]
2089 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
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<&OwnershipTransferred> for alloy_sol_types::private::LogData {
2099 #[inline]
2100 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
2101 alloy_sol_types::SolEvent::encode_log_data(this)
2102 }
2103 }
2104 };
2105 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2106 #[allow(
2111 non_camel_case_types,
2112 non_snake_case,
2113 clippy::pub_underscore_fields,
2114 clippy::style
2115 )]
2116 #[derive(Clone)]
2117 pub struct Transfer {
2118 #[allow(missing_docs)]
2119 pub from: alloy::sol_types::private::Address,
2120 #[allow(missing_docs)]
2121 pub to: alloy::sol_types::private::Address,
2122 #[allow(missing_docs)]
2123 pub value: alloy::sol_types::private::primitives::aliases::U256,
2124 }
2125 #[allow(
2126 non_camel_case_types,
2127 non_snake_case,
2128 clippy::pub_underscore_fields,
2129 clippy::style
2130 )]
2131 const _: () = {
2132 use alloy::sol_types as alloy_sol_types;
2133 #[automatically_derived]
2134 impl alloy_sol_types::SolEvent for Transfer {
2135 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2136 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2137 type TopicList = (
2138 alloy_sol_types::sol_data::FixedBytes<32>,
2139 alloy::sol_types::sol_data::Address,
2140 alloy::sol_types::sol_data::Address,
2141 );
2142 const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
2143 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2144 alloy_sol_types::private::B256::new([
2145 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
2146 104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
2147 161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
2148 ]);
2149 const ANONYMOUS: bool = false;
2150 #[allow(unused_variables)]
2151 #[inline]
2152 fn new(
2153 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2154 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2155 ) -> Self {
2156 Self {
2157 from: topics.1,
2158 to: topics.2,
2159 value: data.0,
2160 }
2161 }
2162 #[inline]
2163 fn check_signature(
2164 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2165 ) -> alloy_sol_types::Result<()> {
2166 if topics.0 != Self::SIGNATURE_HASH {
2167 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2168 Self::SIGNATURE,
2169 topics.0,
2170 Self::SIGNATURE_HASH,
2171 ));
2172 }
2173 Ok(())
2174 }
2175 #[inline]
2176 fn tokenize_body(&self) -> Self::DataToken<'_> {
2177 (
2178 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
2179 &self.value,
2180 ),
2181 )
2182 }
2183 #[inline]
2184 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2185 (
2186 Self::SIGNATURE_HASH.into(),
2187 self.from.clone(),
2188 self.to.clone(),
2189 )
2190 }
2191 #[inline]
2192 fn encode_topics_raw(
2193 &self,
2194 out: &mut [alloy_sol_types::abi::token::WordToken],
2195 ) -> alloy_sol_types::Result<()> {
2196 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2197 return Err(alloy_sol_types::Error::Overrun);
2198 }
2199 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2200 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2201 &self.from,
2202 );
2203 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2204 &self.to,
2205 );
2206 Ok(())
2207 }
2208 }
2209 #[automatically_derived]
2210 impl alloy_sol_types::private::IntoLogData for Transfer {
2211 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2212 From::from(self)
2213 }
2214 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2215 From::from(&self)
2216 }
2217 }
2218 #[automatically_derived]
2219 impl From<&Transfer> for alloy_sol_types::private::LogData {
2220 #[inline]
2221 fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
2222 alloy_sol_types::SolEvent::encode_log_data(this)
2223 }
2224 }
2225 };
2226 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2227 #[allow(
2232 non_camel_case_types,
2233 non_snake_case,
2234 clippy::pub_underscore_fields,
2235 clippy::style
2236 )]
2237 #[derive(Clone)]
2238 pub struct Upgrade {
2239 #[allow(missing_docs)]
2240 pub implementation: alloy::sol_types::private::Address,
2241 }
2242 #[allow(
2243 non_camel_case_types,
2244 non_snake_case,
2245 clippy::pub_underscore_fields,
2246 clippy::style
2247 )]
2248 const _: () = {
2249 use alloy::sol_types as alloy_sol_types;
2250 #[automatically_derived]
2251 impl alloy_sol_types::SolEvent for Upgrade {
2252 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
2253 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2254 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
2255 const SIGNATURE: &'static str = "Upgrade(address)";
2256 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2257 alloy_sol_types::private::B256::new([
2258 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8,
2259 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8,
2260 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
2261 ]);
2262 const ANONYMOUS: bool = false;
2263 #[allow(unused_variables)]
2264 #[inline]
2265 fn new(
2266 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2267 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2268 ) -> Self {
2269 Self {
2270 implementation: data.0,
2271 }
2272 }
2273 #[inline]
2274 fn check_signature(
2275 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2276 ) -> alloy_sol_types::Result<()> {
2277 if topics.0 != Self::SIGNATURE_HASH {
2278 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2279 Self::SIGNATURE,
2280 topics.0,
2281 Self::SIGNATURE_HASH,
2282 ));
2283 }
2284 Ok(())
2285 }
2286 #[inline]
2287 fn tokenize_body(&self) -> Self::DataToken<'_> {
2288 (
2289 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2290 &self.implementation,
2291 ),
2292 )
2293 }
2294 #[inline]
2295 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2296 (Self::SIGNATURE_HASH.into(),)
2297 }
2298 #[inline]
2299 fn encode_topics_raw(
2300 &self,
2301 out: &mut [alloy_sol_types::abi::token::WordToken],
2302 ) -> alloy_sol_types::Result<()> {
2303 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2304 return Err(alloy_sol_types::Error::Overrun);
2305 }
2306 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2307 Ok(())
2308 }
2309 }
2310 #[automatically_derived]
2311 impl alloy_sol_types::private::IntoLogData for Upgrade {
2312 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2313 From::from(self)
2314 }
2315 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2316 From::from(&self)
2317 }
2318 }
2319 #[automatically_derived]
2320 impl From<&Upgrade> for alloy_sol_types::private::LogData {
2321 #[inline]
2322 fn from(this: &Upgrade) -> alloy_sol_types::private::LogData {
2323 alloy_sol_types::SolEvent::encode_log_data(this)
2324 }
2325 }
2326 };
2327 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2328 #[allow(
2333 non_camel_case_types,
2334 non_snake_case,
2335 clippy::pub_underscore_fields,
2336 clippy::style
2337 )]
2338 #[derive(Clone)]
2339 pub struct Upgraded {
2340 #[allow(missing_docs)]
2341 pub implementation: alloy::sol_types::private::Address,
2342 }
2343 #[allow(
2344 non_camel_case_types,
2345 non_snake_case,
2346 clippy::pub_underscore_fields,
2347 clippy::style
2348 )]
2349 const _: () = {
2350 use alloy::sol_types as alloy_sol_types;
2351 #[automatically_derived]
2352 impl alloy_sol_types::SolEvent for Upgraded {
2353 type DataTuple<'a> = ();
2354 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2355 type TopicList = (
2356 alloy_sol_types::sol_data::FixedBytes<32>,
2357 alloy::sol_types::sol_data::Address,
2358 );
2359 const SIGNATURE: &'static str = "Upgraded(address)";
2360 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2361 alloy_sol_types::private::B256::new([
2362 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
2363 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8,
2364 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
2365 ]);
2366 const ANONYMOUS: bool = false;
2367 #[allow(unused_variables)]
2368 #[inline]
2369 fn new(
2370 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2371 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2372 ) -> Self {
2373 Self {
2374 implementation: topics.1,
2375 }
2376 }
2377 #[inline]
2378 fn check_signature(
2379 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2380 ) -> alloy_sol_types::Result<()> {
2381 if topics.0 != Self::SIGNATURE_HASH {
2382 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2383 Self::SIGNATURE,
2384 topics.0,
2385 Self::SIGNATURE_HASH,
2386 ));
2387 }
2388 Ok(())
2389 }
2390 #[inline]
2391 fn tokenize_body(&self) -> Self::DataToken<'_> {
2392 ()
2393 }
2394 #[inline]
2395 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2396 (Self::SIGNATURE_HASH.into(), self.implementation.clone())
2397 }
2398 #[inline]
2399 fn encode_topics_raw(
2400 &self,
2401 out: &mut [alloy_sol_types::abi::token::WordToken],
2402 ) -> alloy_sol_types::Result<()> {
2403 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2404 return Err(alloy_sol_types::Error::Overrun);
2405 }
2406 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2407 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2408 &self.implementation,
2409 );
2410 Ok(())
2411 }
2412 }
2413 #[automatically_derived]
2414 impl alloy_sol_types::private::IntoLogData for Upgraded {
2415 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2416 From::from(self)
2417 }
2418 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2419 From::from(&self)
2420 }
2421 }
2422 #[automatically_derived]
2423 impl From<&Upgraded> for alloy_sol_types::private::LogData {
2424 #[inline]
2425 fn from(this: &Upgraded) -> alloy_sol_types::private::LogData {
2426 alloy_sol_types::SolEvent::encode_log_data(this)
2427 }
2428 }
2429 };
2430 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2435 #[derive(Clone)]
2436 pub struct constructorCall {}
2437 const _: () = {
2438 use alloy::sol_types as alloy_sol_types;
2439 {
2440 #[doc(hidden)]
2441 type UnderlyingSolTuple<'a> = ();
2442 #[doc(hidden)]
2443 type UnderlyingRustTuple<'a> = ();
2444 #[cfg(test)]
2445 #[allow(dead_code, unreachable_patterns)]
2446 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2447 match _t {
2448 alloy_sol_types::private::AssertTypeEq::<
2449 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2450 >(_) => {},
2451 }
2452 }
2453 #[automatically_derived]
2454 #[doc(hidden)]
2455 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
2456 fn from(value: constructorCall) -> Self {
2457 ()
2458 }
2459 }
2460 #[automatically_derived]
2461 #[doc(hidden)]
2462 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
2463 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2464 Self {}
2465 }
2466 }
2467 }
2468 #[automatically_derived]
2469 impl alloy_sol_types::SolConstructor for constructorCall {
2470 type Parameters<'a> = ();
2471 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2472 #[inline]
2473 fn new<'a>(
2474 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2475 ) -> Self {
2476 tuple.into()
2477 }
2478 #[inline]
2479 fn tokenize(&self) -> Self::Token<'_> {
2480 ()
2481 }
2482 }
2483 };
2484 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2485 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2490 #[derive(Clone)]
2491 pub struct UPGRADE_INTERFACE_VERSIONCall {}
2492 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2493 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2495 #[derive(Clone)]
2496 pub struct UPGRADE_INTERFACE_VERSIONReturn {
2497 #[allow(missing_docs)]
2498 pub _0: alloy::sol_types::private::String,
2499 }
2500 #[allow(
2501 non_camel_case_types,
2502 non_snake_case,
2503 clippy::pub_underscore_fields,
2504 clippy::style
2505 )]
2506 const _: () = {
2507 use alloy::sol_types as alloy_sol_types;
2508 {
2509 #[doc(hidden)]
2510 type UnderlyingSolTuple<'a> = ();
2511 #[doc(hidden)]
2512 type UnderlyingRustTuple<'a> = ();
2513 #[cfg(test)]
2514 #[allow(dead_code, unreachable_patterns)]
2515 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2516 match _t {
2517 alloy_sol_types::private::AssertTypeEq::<
2518 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2519 >(_) => {},
2520 }
2521 }
2522 #[automatically_derived]
2523 #[doc(hidden)]
2524 impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONCall> for UnderlyingRustTuple<'_> {
2525 fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self {
2526 ()
2527 }
2528 }
2529 #[automatically_derived]
2530 #[doc(hidden)]
2531 impl ::core::convert::From<UnderlyingRustTuple<'_>> for UPGRADE_INTERFACE_VERSIONCall {
2532 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2533 Self {}
2534 }
2535 }
2536 }
2537 {
2538 #[doc(hidden)]
2539 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2540 #[doc(hidden)]
2541 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2542 #[cfg(test)]
2543 #[allow(dead_code, unreachable_patterns)]
2544 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2545 match _t {
2546 alloy_sol_types::private::AssertTypeEq::<
2547 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2548 >(_) => {},
2549 }
2550 }
2551 #[automatically_derived]
2552 #[doc(hidden)]
2553 impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONReturn> for UnderlyingRustTuple<'_> {
2554 fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self {
2555 (value._0,)
2556 }
2557 }
2558 #[automatically_derived]
2559 #[doc(hidden)]
2560 impl ::core::convert::From<UnderlyingRustTuple<'_>> for UPGRADE_INTERFACE_VERSIONReturn {
2561 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2562 Self { _0: tuple.0 }
2563 }
2564 }
2565 }
2566 #[automatically_derived]
2567 impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall {
2568 type Parameters<'a> = ();
2569 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2570 type Return = UPGRADE_INTERFACE_VERSIONReturn;
2571 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2572 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2573 const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()";
2574 const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8];
2575 #[inline]
2576 fn new<'a>(
2577 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2578 ) -> Self {
2579 tuple.into()
2580 }
2581 #[inline]
2582 fn tokenize(&self) -> Self::Token<'_> {
2583 ()
2584 }
2585 #[inline]
2586 fn abi_decode_returns(
2587 data: &[u8],
2588 validate: bool,
2589 ) -> alloy_sol_types::Result<Self::Return> {
2590 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
2591 data, validate,
2592 )
2593 .map(Into::into)
2594 }
2595 }
2596 };
2597 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2598 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2603 #[derive(Clone)]
2604 pub struct allowanceCall {
2605 #[allow(missing_docs)]
2606 pub owner: alloy::sol_types::private::Address,
2607 #[allow(missing_docs)]
2608 pub spender: alloy::sol_types::private::Address,
2609 }
2610 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2611 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2613 #[derive(Clone)]
2614 pub struct allowanceReturn {
2615 #[allow(missing_docs)]
2616 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2617 }
2618 #[allow(
2619 non_camel_case_types,
2620 non_snake_case,
2621 clippy::pub_underscore_fields,
2622 clippy::style
2623 )]
2624 const _: () = {
2625 use alloy::sol_types as alloy_sol_types;
2626 {
2627 #[doc(hidden)]
2628 type UnderlyingSolTuple<'a> = (
2629 alloy::sol_types::sol_data::Address,
2630 alloy::sol_types::sol_data::Address,
2631 );
2632 #[doc(hidden)]
2633 type UnderlyingRustTuple<'a> = (
2634 alloy::sol_types::private::Address,
2635 alloy::sol_types::private::Address,
2636 );
2637 #[cfg(test)]
2638 #[allow(dead_code, unreachable_patterns)]
2639 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2640 match _t {
2641 alloy_sol_types::private::AssertTypeEq::<
2642 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2643 >(_) => {},
2644 }
2645 }
2646 #[automatically_derived]
2647 #[doc(hidden)]
2648 impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
2649 fn from(value: allowanceCall) -> Self {
2650 (value.owner, value.spender)
2651 }
2652 }
2653 #[automatically_derived]
2654 #[doc(hidden)]
2655 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
2656 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2657 Self {
2658 owner: tuple.0,
2659 spender: tuple.1,
2660 }
2661 }
2662 }
2663 }
2664 {
2665 #[doc(hidden)]
2666 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2667 #[doc(hidden)]
2668 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
2669 #[cfg(test)]
2670 #[allow(dead_code, unreachable_patterns)]
2671 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
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<allowanceReturn> for UnderlyingRustTuple<'_> {
2681 fn from(value: allowanceReturn) -> Self {
2682 (value._0,)
2683 }
2684 }
2685 #[automatically_derived]
2686 #[doc(hidden)]
2687 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
2688 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2689 Self { _0: tuple.0 }
2690 }
2691 }
2692 }
2693 #[automatically_derived]
2694 impl alloy_sol_types::SolCall for allowanceCall {
2695 type Parameters<'a> = (
2696 alloy::sol_types::sol_data::Address,
2697 alloy::sol_types::sol_data::Address,
2698 );
2699 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2700 type Return = allowanceReturn;
2701 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2702 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2703 const SIGNATURE: &'static str = "allowance(address,address)";
2704 const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
2705 #[inline]
2706 fn new<'a>(
2707 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2708 ) -> Self {
2709 tuple.into()
2710 }
2711 #[inline]
2712 fn tokenize(&self) -> Self::Token<'_> {
2713 (
2714 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2715 &self.owner,
2716 ),
2717 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2718 &self.spender,
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<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
2728 data, validate,
2729 )
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 approveCall {
2742 #[allow(missing_docs)]
2743 pub spender: alloy::sol_types::private::Address,
2744 #[allow(missing_docs)]
2745 pub value: alloy::sol_types::private::primitives::aliases::U256,
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 approveReturn {
2752 #[allow(missing_docs)]
2753 pub _0: bool,
2754 }
2755 #[allow(
2756 non_camel_case_types,
2757 non_snake_case,
2758 clippy::pub_underscore_fields,
2759 clippy::style
2760 )]
2761 const _: () = {
2762 use alloy::sol_types as alloy_sol_types;
2763 {
2764 #[doc(hidden)]
2765 type UnderlyingSolTuple<'a> = (
2766 alloy::sol_types::sol_data::Address,
2767 alloy::sol_types::sol_data::Uint<256>,
2768 );
2769 #[doc(hidden)]
2770 type UnderlyingRustTuple<'a> = (
2771 alloy::sol_types::private::Address,
2772 alloy::sol_types::private::primitives::aliases::U256,
2773 );
2774 #[cfg(test)]
2775 #[allow(dead_code, unreachable_patterns)]
2776 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2777 match _t {
2778 alloy_sol_types::private::AssertTypeEq::<
2779 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2780 >(_) => {},
2781 }
2782 }
2783 #[automatically_derived]
2784 #[doc(hidden)]
2785 impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
2786 fn from(value: approveCall) -> Self {
2787 (value.spender, value.value)
2788 }
2789 }
2790 #[automatically_derived]
2791 #[doc(hidden)]
2792 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
2793 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2794 Self {
2795 spender: tuple.0,
2796 value: tuple.1,
2797 }
2798 }
2799 }
2800 }
2801 {
2802 #[doc(hidden)]
2803 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2804 #[doc(hidden)]
2805 type UnderlyingRustTuple<'a> = (bool,);
2806 #[cfg(test)]
2807 #[allow(dead_code, unreachable_patterns)]
2808 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2809 match _t {
2810 alloy_sol_types::private::AssertTypeEq::<
2811 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2812 >(_) => {},
2813 }
2814 }
2815 #[automatically_derived]
2816 #[doc(hidden)]
2817 impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
2818 fn from(value: approveReturn) -> Self {
2819 (value._0,)
2820 }
2821 }
2822 #[automatically_derived]
2823 #[doc(hidden)]
2824 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
2825 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2826 Self { _0: tuple.0 }
2827 }
2828 }
2829 }
2830 #[automatically_derived]
2831 impl alloy_sol_types::SolCall for approveCall {
2832 type Parameters<'a> = (
2833 alloy::sol_types::sol_data::Address,
2834 alloy::sol_types::sol_data::Uint<256>,
2835 );
2836 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2837 type Return = approveReturn;
2838 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2839 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2840 const SIGNATURE: &'static str = "approve(address,uint256)";
2841 const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
2842 #[inline]
2843 fn new<'a>(
2844 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2845 ) -> Self {
2846 tuple.into()
2847 }
2848 #[inline]
2849 fn tokenize(&self) -> Self::Token<'_> {
2850 (
2851 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2852 &self.spender,
2853 ),
2854 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
2855 &self.value,
2856 ),
2857 )
2858 }
2859 #[inline]
2860 fn abi_decode_returns(
2861 data: &[u8],
2862 validate: bool,
2863 ) -> alloy_sol_types::Result<Self::Return> {
2864 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
2865 data, validate,
2866 )
2867 .map(Into::into)
2868 }
2869 }
2870 };
2871 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2872 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2877 #[derive(Clone)]
2878 pub struct balanceOfCall {
2879 #[allow(missing_docs)]
2880 pub account: alloy::sol_types::private::Address,
2881 }
2882 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2883 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2885 #[derive(Clone)]
2886 pub struct balanceOfReturn {
2887 #[allow(missing_docs)]
2888 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2889 }
2890 #[allow(
2891 non_camel_case_types,
2892 non_snake_case,
2893 clippy::pub_underscore_fields,
2894 clippy::style
2895 )]
2896 const _: () = {
2897 use alloy::sol_types as alloy_sol_types;
2898 {
2899 #[doc(hidden)]
2900 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2901 #[doc(hidden)]
2902 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2903 #[cfg(test)]
2904 #[allow(dead_code, unreachable_patterns)]
2905 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2906 match _t {
2907 alloy_sol_types::private::AssertTypeEq::<
2908 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2909 >(_) => {},
2910 }
2911 }
2912 #[automatically_derived]
2913 #[doc(hidden)]
2914 impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
2915 fn from(value: balanceOfCall) -> Self {
2916 (value.account,)
2917 }
2918 }
2919 #[automatically_derived]
2920 #[doc(hidden)]
2921 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
2922 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2923 Self { account: tuple.0 }
2924 }
2925 }
2926 }
2927 {
2928 #[doc(hidden)]
2929 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2930 #[doc(hidden)]
2931 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
2932 #[cfg(test)]
2933 #[allow(dead_code, unreachable_patterns)]
2934 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2935 match _t {
2936 alloy_sol_types::private::AssertTypeEq::<
2937 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2938 >(_) => {},
2939 }
2940 }
2941 #[automatically_derived]
2942 #[doc(hidden)]
2943 impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
2944 fn from(value: balanceOfReturn) -> Self {
2945 (value._0,)
2946 }
2947 }
2948 #[automatically_derived]
2949 #[doc(hidden)]
2950 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
2951 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2952 Self { _0: tuple.0 }
2953 }
2954 }
2955 }
2956 #[automatically_derived]
2957 impl alloy_sol_types::SolCall for balanceOfCall {
2958 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2959 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2960 type Return = balanceOfReturn;
2961 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2962 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2963 const SIGNATURE: &'static str = "balanceOf(address)";
2964 const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
2965 #[inline]
2966 fn new<'a>(
2967 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2968 ) -> Self {
2969 tuple.into()
2970 }
2971 #[inline]
2972 fn tokenize(&self) -> Self::Token<'_> {
2973 (
2974 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2975 &self.account,
2976 ),
2977 )
2978 }
2979 #[inline]
2980 fn abi_decode_returns(
2981 data: &[u8],
2982 validate: bool,
2983 ) -> alloy_sol_types::Result<Self::Return> {
2984 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
2985 data, validate,
2986 )
2987 .map(Into::into)
2988 }
2989 }
2990 };
2991 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2992 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2997 #[derive(Clone)]
2998 pub struct decimalsCall {}
2999 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3000 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3002 #[derive(Clone)]
3003 pub struct decimalsReturn {
3004 #[allow(missing_docs)]
3005 pub _0: u8,
3006 }
3007 #[allow(
3008 non_camel_case_types,
3009 non_snake_case,
3010 clippy::pub_underscore_fields,
3011 clippy::style
3012 )]
3013 const _: () = {
3014 use alloy::sol_types as alloy_sol_types;
3015 {
3016 #[doc(hidden)]
3017 type UnderlyingSolTuple<'a> = ();
3018 #[doc(hidden)]
3019 type UnderlyingRustTuple<'a> = ();
3020 #[cfg(test)]
3021 #[allow(dead_code, unreachable_patterns)]
3022 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3023 match _t {
3024 alloy_sol_types::private::AssertTypeEq::<
3025 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3026 >(_) => {},
3027 }
3028 }
3029 #[automatically_derived]
3030 #[doc(hidden)]
3031 impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
3032 fn from(value: decimalsCall) -> Self {
3033 ()
3034 }
3035 }
3036 #[automatically_derived]
3037 #[doc(hidden)]
3038 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
3039 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3040 Self {}
3041 }
3042 }
3043 }
3044 {
3045 #[doc(hidden)]
3046 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3047 #[doc(hidden)]
3048 type UnderlyingRustTuple<'a> = (u8,);
3049 #[cfg(test)]
3050 #[allow(dead_code, unreachable_patterns)]
3051 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3052 match _t {
3053 alloy_sol_types::private::AssertTypeEq::<
3054 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3055 >(_) => {},
3056 }
3057 }
3058 #[automatically_derived]
3059 #[doc(hidden)]
3060 impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
3061 fn from(value: decimalsReturn) -> Self {
3062 (value._0,)
3063 }
3064 }
3065 #[automatically_derived]
3066 #[doc(hidden)]
3067 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
3068 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3069 Self { _0: tuple.0 }
3070 }
3071 }
3072 }
3073 #[automatically_derived]
3074 impl alloy_sol_types::SolCall for decimalsCall {
3075 type Parameters<'a> = ();
3076 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3077 type Return = decimalsReturn;
3078 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3079 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3080 const SIGNATURE: &'static str = "decimals()";
3081 const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
3082 #[inline]
3083 fn new<'a>(
3084 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3085 ) -> Self {
3086 tuple.into()
3087 }
3088 #[inline]
3089 fn tokenize(&self) -> Self::Token<'_> {
3090 ()
3091 }
3092 #[inline]
3093 fn abi_decode_returns(
3094 data: &[u8],
3095 validate: bool,
3096 ) -> alloy_sol_types::Result<Self::Return> {
3097 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3098 data, validate,
3099 )
3100 .map(Into::into)
3101 }
3102 }
3103 };
3104 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3105 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3110 #[derive(Clone)]
3111 pub struct getVersionCall {}
3112 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3113 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3115 #[derive(Clone)]
3116 pub struct getVersionReturn {
3117 #[allow(missing_docs)]
3118 pub majorVersion: u8,
3119 #[allow(missing_docs)]
3120 pub minorVersion: u8,
3121 #[allow(missing_docs)]
3122 pub patchVersion: u8,
3123 }
3124 #[allow(
3125 non_camel_case_types,
3126 non_snake_case,
3127 clippy::pub_underscore_fields,
3128 clippy::style
3129 )]
3130 const _: () = {
3131 use alloy::sol_types as alloy_sol_types;
3132 {
3133 #[doc(hidden)]
3134 type UnderlyingSolTuple<'a> = ();
3135 #[doc(hidden)]
3136 type UnderlyingRustTuple<'a> = ();
3137 #[cfg(test)]
3138 #[allow(dead_code, unreachable_patterns)]
3139 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3140 match _t {
3141 alloy_sol_types::private::AssertTypeEq::<
3142 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3143 >(_) => {},
3144 }
3145 }
3146 #[automatically_derived]
3147 #[doc(hidden)]
3148 impl ::core::convert::From<getVersionCall> for UnderlyingRustTuple<'_> {
3149 fn from(value: getVersionCall) -> Self {
3150 ()
3151 }
3152 }
3153 #[automatically_derived]
3154 #[doc(hidden)]
3155 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionCall {
3156 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3157 Self {}
3158 }
3159 }
3160 }
3161 {
3162 #[doc(hidden)]
3163 type UnderlyingSolTuple<'a> = (
3164 alloy::sol_types::sol_data::Uint<8>,
3165 alloy::sol_types::sol_data::Uint<8>,
3166 alloy::sol_types::sol_data::Uint<8>,
3167 );
3168 #[doc(hidden)]
3169 type UnderlyingRustTuple<'a> = (u8, u8, u8);
3170 #[cfg(test)]
3171 #[allow(dead_code, unreachable_patterns)]
3172 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3173 match _t {
3174 alloy_sol_types::private::AssertTypeEq::<
3175 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3176 >(_) => {},
3177 }
3178 }
3179 #[automatically_derived]
3180 #[doc(hidden)]
3181 impl ::core::convert::From<getVersionReturn> for UnderlyingRustTuple<'_> {
3182 fn from(value: getVersionReturn) -> Self {
3183 (value.majorVersion, value.minorVersion, value.patchVersion)
3184 }
3185 }
3186 #[automatically_derived]
3187 #[doc(hidden)]
3188 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionReturn {
3189 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3190 Self {
3191 majorVersion: tuple.0,
3192 minorVersion: tuple.1,
3193 patchVersion: tuple.2,
3194 }
3195 }
3196 }
3197 }
3198 #[automatically_derived]
3199 impl alloy_sol_types::SolCall for getVersionCall {
3200 type Parameters<'a> = ();
3201 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3202 type Return = getVersionReturn;
3203 type ReturnTuple<'a> = (
3204 alloy::sol_types::sol_data::Uint<8>,
3205 alloy::sol_types::sol_data::Uint<8>,
3206 alloy::sol_types::sol_data::Uint<8>,
3207 );
3208 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3209 const SIGNATURE: &'static str = "getVersion()";
3210 const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8];
3211 #[inline]
3212 fn new<'a>(
3213 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3214 ) -> Self {
3215 tuple.into()
3216 }
3217 #[inline]
3218 fn tokenize(&self) -> Self::Token<'_> {
3219 ()
3220 }
3221 #[inline]
3222 fn abi_decode_returns(
3223 data: &[u8],
3224 validate: bool,
3225 ) -> alloy_sol_types::Result<Self::Return> {
3226 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3227 data, validate,
3228 )
3229 .map(Into::into)
3230 }
3231 }
3232 };
3233 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3234 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3239 #[derive(Clone)]
3240 pub struct initializeCall {
3241 #[allow(missing_docs)]
3242 pub owner: alloy::sol_types::private::Address,
3243 #[allow(missing_docs)]
3244 pub initialRecipient: alloy::sol_types::private::Address,
3245 #[allow(missing_docs)]
3246 pub initialSupply: alloy::sol_types::private::primitives::aliases::U256,
3247 #[allow(missing_docs)]
3248 pub name: alloy::sol_types::private::String,
3249 #[allow(missing_docs)]
3250 pub symbol: alloy::sol_types::private::String,
3251 }
3252 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3254 #[derive(Clone)]
3255 pub struct initializeReturn {}
3256 #[allow(
3257 non_camel_case_types,
3258 non_snake_case,
3259 clippy::pub_underscore_fields,
3260 clippy::style
3261 )]
3262 const _: () = {
3263 use alloy::sol_types as alloy_sol_types;
3264 {
3265 #[doc(hidden)]
3266 type UnderlyingSolTuple<'a> = (
3267 alloy::sol_types::sol_data::Address,
3268 alloy::sol_types::sol_data::Address,
3269 alloy::sol_types::sol_data::Uint<256>,
3270 alloy::sol_types::sol_data::String,
3271 alloy::sol_types::sol_data::String,
3272 );
3273 #[doc(hidden)]
3274 type UnderlyingRustTuple<'a> = (
3275 alloy::sol_types::private::Address,
3276 alloy::sol_types::private::Address,
3277 alloy::sol_types::private::primitives::aliases::U256,
3278 alloy::sol_types::private::String,
3279 alloy::sol_types::private::String,
3280 );
3281 #[cfg(test)]
3282 #[allow(dead_code, unreachable_patterns)]
3283 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3284 match _t {
3285 alloy_sol_types::private::AssertTypeEq::<
3286 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3287 >(_) => {},
3288 }
3289 }
3290 #[automatically_derived]
3291 #[doc(hidden)]
3292 impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
3293 fn from(value: initializeCall) -> Self {
3294 (
3295 value.owner,
3296 value.initialRecipient,
3297 value.initialSupply,
3298 value.name,
3299 value.symbol,
3300 )
3301 }
3302 }
3303 #[automatically_derived]
3304 #[doc(hidden)]
3305 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
3306 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3307 Self {
3308 owner: tuple.0,
3309 initialRecipient: tuple.1,
3310 initialSupply: tuple.2,
3311 name: tuple.3,
3312 symbol: tuple.4,
3313 }
3314 }
3315 }
3316 }
3317 {
3318 #[doc(hidden)]
3319 type UnderlyingSolTuple<'a> = ();
3320 #[doc(hidden)]
3321 type UnderlyingRustTuple<'a> = ();
3322 #[cfg(test)]
3323 #[allow(dead_code, unreachable_patterns)]
3324 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3325 match _t {
3326 alloy_sol_types::private::AssertTypeEq::<
3327 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3328 >(_) => {},
3329 }
3330 }
3331 #[automatically_derived]
3332 #[doc(hidden)]
3333 impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
3334 fn from(value: initializeReturn) -> Self {
3335 ()
3336 }
3337 }
3338 #[automatically_derived]
3339 #[doc(hidden)]
3340 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
3341 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3342 Self {}
3343 }
3344 }
3345 }
3346 #[automatically_derived]
3347 impl alloy_sol_types::SolCall for initializeCall {
3348 type Parameters<'a> = (
3349 alloy::sol_types::sol_data::Address,
3350 alloy::sol_types::sol_data::Address,
3351 alloy::sol_types::sol_data::Uint<256>,
3352 alloy::sol_types::sol_data::String,
3353 alloy::sol_types::sol_data::String,
3354 );
3355 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3356 type Return = initializeReturn;
3357 type ReturnTuple<'a> = ();
3358 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3359 const SIGNATURE: &'static str = "initialize(address,address,uint256,string,string)";
3360 const SELECTOR: [u8; 4] = [154u8, 184u8, 54u8, 126u8];
3361 #[inline]
3362 fn new<'a>(
3363 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3364 ) -> Self {
3365 tuple.into()
3366 }
3367 #[inline]
3368 fn tokenize(&self) -> Self::Token<'_> {
3369 (
3370 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3371 &self.owner,
3372 ),
3373 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3374 &self.initialRecipient,
3375 ),
3376 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
3377 &self.initialSupply,
3378 ),
3379 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
3380 &self.name,
3381 ),
3382 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
3383 &self.symbol,
3384 ),
3385 )
3386 }
3387 #[inline]
3388 fn abi_decode_returns(
3389 data: &[u8],
3390 validate: bool,
3391 ) -> alloy_sol_types::Result<Self::Return> {
3392 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3393 data, validate,
3394 )
3395 .map(Into::into)
3396 }
3397 }
3398 };
3399 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3400 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3405 #[derive(Clone)]
3406 pub struct nameCall {}
3407 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3408 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3410 #[derive(Clone)]
3411 pub struct nameReturn {
3412 #[allow(missing_docs)]
3413 pub _0: alloy::sol_types::private::String,
3414 }
3415 #[allow(
3416 non_camel_case_types,
3417 non_snake_case,
3418 clippy::pub_underscore_fields,
3419 clippy::style
3420 )]
3421 const _: () = {
3422 use alloy::sol_types as alloy_sol_types;
3423 {
3424 #[doc(hidden)]
3425 type UnderlyingSolTuple<'a> = ();
3426 #[doc(hidden)]
3427 type UnderlyingRustTuple<'a> = ();
3428 #[cfg(test)]
3429 #[allow(dead_code, unreachable_patterns)]
3430 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3431 match _t {
3432 alloy_sol_types::private::AssertTypeEq::<
3433 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3434 >(_) => {},
3435 }
3436 }
3437 #[automatically_derived]
3438 #[doc(hidden)]
3439 impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
3440 fn from(value: nameCall) -> Self {
3441 ()
3442 }
3443 }
3444 #[automatically_derived]
3445 #[doc(hidden)]
3446 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
3447 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3448 Self {}
3449 }
3450 }
3451 }
3452 {
3453 #[doc(hidden)]
3454 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
3455 #[doc(hidden)]
3456 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
3457 #[cfg(test)]
3458 #[allow(dead_code, unreachable_patterns)]
3459 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3460 match _t {
3461 alloy_sol_types::private::AssertTypeEq::<
3462 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3463 >(_) => {},
3464 }
3465 }
3466 #[automatically_derived]
3467 #[doc(hidden)]
3468 impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
3469 fn from(value: nameReturn) -> Self {
3470 (value._0,)
3471 }
3472 }
3473 #[automatically_derived]
3474 #[doc(hidden)]
3475 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
3476 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3477 Self { _0: tuple.0 }
3478 }
3479 }
3480 }
3481 #[automatically_derived]
3482 impl alloy_sol_types::SolCall for nameCall {
3483 type Parameters<'a> = ();
3484 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3485 type Return = nameReturn;
3486 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
3487 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3488 const SIGNATURE: &'static str = "name()";
3489 const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
3490 #[inline]
3491 fn new<'a>(
3492 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3493 ) -> Self {
3494 tuple.into()
3495 }
3496 #[inline]
3497 fn tokenize(&self) -> Self::Token<'_> {
3498 ()
3499 }
3500 #[inline]
3501 fn abi_decode_returns(
3502 data: &[u8],
3503 validate: bool,
3504 ) -> alloy_sol_types::Result<Self::Return> {
3505 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3506 data, validate,
3507 )
3508 .map(Into::into)
3509 }
3510 }
3511 };
3512 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3513 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3518 #[derive(Clone)]
3519 pub struct ownerCall {}
3520 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3521 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3523 #[derive(Clone)]
3524 pub struct ownerReturn {
3525 #[allow(missing_docs)]
3526 pub _0: alloy::sol_types::private::Address,
3527 }
3528 #[allow(
3529 non_camel_case_types,
3530 non_snake_case,
3531 clippy::pub_underscore_fields,
3532 clippy::style
3533 )]
3534 const _: () = {
3535 use alloy::sol_types as alloy_sol_types;
3536 {
3537 #[doc(hidden)]
3538 type UnderlyingSolTuple<'a> = ();
3539 #[doc(hidden)]
3540 type UnderlyingRustTuple<'a> = ();
3541 #[cfg(test)]
3542 #[allow(dead_code, unreachable_patterns)]
3543 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3544 match _t {
3545 alloy_sol_types::private::AssertTypeEq::<
3546 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3547 >(_) => {},
3548 }
3549 }
3550 #[automatically_derived]
3551 #[doc(hidden)]
3552 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
3553 fn from(value: ownerCall) -> Self {
3554 ()
3555 }
3556 }
3557 #[automatically_derived]
3558 #[doc(hidden)]
3559 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
3560 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3561 Self {}
3562 }
3563 }
3564 }
3565 {
3566 #[doc(hidden)]
3567 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3568 #[doc(hidden)]
3569 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3570 #[cfg(test)]
3571 #[allow(dead_code, unreachable_patterns)]
3572 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3573 match _t {
3574 alloy_sol_types::private::AssertTypeEq::<
3575 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3576 >(_) => {},
3577 }
3578 }
3579 #[automatically_derived]
3580 #[doc(hidden)]
3581 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
3582 fn from(value: ownerReturn) -> Self {
3583 (value._0,)
3584 }
3585 }
3586 #[automatically_derived]
3587 #[doc(hidden)]
3588 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
3589 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3590 Self { _0: tuple.0 }
3591 }
3592 }
3593 }
3594 #[automatically_derived]
3595 impl alloy_sol_types::SolCall for ownerCall {
3596 type Parameters<'a> = ();
3597 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3598 type Return = ownerReturn;
3599 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3600 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3601 const SIGNATURE: &'static str = "owner()";
3602 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
3603 #[inline]
3604 fn new<'a>(
3605 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3606 ) -> Self {
3607 tuple.into()
3608 }
3609 #[inline]
3610 fn tokenize(&self) -> Self::Token<'_> {
3611 ()
3612 }
3613 #[inline]
3614 fn abi_decode_returns(
3615 data: &[u8],
3616 validate: bool,
3617 ) -> alloy_sol_types::Result<Self::Return> {
3618 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3619 data, validate,
3620 )
3621 .map(Into::into)
3622 }
3623 }
3624 };
3625 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3626 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3631 #[derive(Clone)]
3632 pub struct proxiableUUIDCall {}
3633 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3634 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3636 #[derive(Clone)]
3637 pub struct proxiableUUIDReturn {
3638 #[allow(missing_docs)]
3639 pub _0: alloy::sol_types::private::FixedBytes<32>,
3640 }
3641 #[allow(
3642 non_camel_case_types,
3643 non_snake_case,
3644 clippy::pub_underscore_fields,
3645 clippy::style
3646 )]
3647 const _: () = {
3648 use alloy::sol_types as alloy_sol_types;
3649 {
3650 #[doc(hidden)]
3651 type UnderlyingSolTuple<'a> = ();
3652 #[doc(hidden)]
3653 type UnderlyingRustTuple<'a> = ();
3654 #[cfg(test)]
3655 #[allow(dead_code, unreachable_patterns)]
3656 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3657 match _t {
3658 alloy_sol_types::private::AssertTypeEq::<
3659 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3660 >(_) => {},
3661 }
3662 }
3663 #[automatically_derived]
3664 #[doc(hidden)]
3665 impl ::core::convert::From<proxiableUUIDCall> for UnderlyingRustTuple<'_> {
3666 fn from(value: proxiableUUIDCall) -> Self {
3667 ()
3668 }
3669 }
3670 #[automatically_derived]
3671 #[doc(hidden)]
3672 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDCall {
3673 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3674 Self {}
3675 }
3676 }
3677 }
3678 {
3679 #[doc(hidden)]
3680 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3681 #[doc(hidden)]
3682 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3683 #[cfg(test)]
3684 #[allow(dead_code, unreachable_patterns)]
3685 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3686 match _t {
3687 alloy_sol_types::private::AssertTypeEq::<
3688 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3689 >(_) => {},
3690 }
3691 }
3692 #[automatically_derived]
3693 #[doc(hidden)]
3694 impl ::core::convert::From<proxiableUUIDReturn> for UnderlyingRustTuple<'_> {
3695 fn from(value: proxiableUUIDReturn) -> Self {
3696 (value._0,)
3697 }
3698 }
3699 #[automatically_derived]
3700 #[doc(hidden)]
3701 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDReturn {
3702 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3703 Self { _0: tuple.0 }
3704 }
3705 }
3706 }
3707 #[automatically_derived]
3708 impl alloy_sol_types::SolCall for proxiableUUIDCall {
3709 type Parameters<'a> = ();
3710 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3711 type Return = proxiableUUIDReturn;
3712 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3713 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3714 const SIGNATURE: &'static str = "proxiableUUID()";
3715 const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8];
3716 #[inline]
3717 fn new<'a>(
3718 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3719 ) -> Self {
3720 tuple.into()
3721 }
3722 #[inline]
3723 fn tokenize(&self) -> Self::Token<'_> {
3724 ()
3725 }
3726 #[inline]
3727 fn abi_decode_returns(
3728 data: &[u8],
3729 validate: bool,
3730 ) -> alloy_sol_types::Result<Self::Return> {
3731 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3732 data, validate,
3733 )
3734 .map(Into::into)
3735 }
3736 }
3737 };
3738 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3739 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3744 #[derive(Clone)]
3745 pub struct renounceOwnershipCall {}
3746 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3748 #[derive(Clone)]
3749 pub struct renounceOwnershipReturn {}
3750 #[allow(
3751 non_camel_case_types,
3752 non_snake_case,
3753 clippy::pub_underscore_fields,
3754 clippy::style
3755 )]
3756 const _: () = {
3757 use alloy::sol_types as alloy_sol_types;
3758 {
3759 #[doc(hidden)]
3760 type UnderlyingSolTuple<'a> = ();
3761 #[doc(hidden)]
3762 type UnderlyingRustTuple<'a> = ();
3763 #[cfg(test)]
3764 #[allow(dead_code, unreachable_patterns)]
3765 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3766 match _t {
3767 alloy_sol_types::private::AssertTypeEq::<
3768 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3769 >(_) => {},
3770 }
3771 }
3772 #[automatically_derived]
3773 #[doc(hidden)]
3774 impl ::core::convert::From<renounceOwnershipCall> for UnderlyingRustTuple<'_> {
3775 fn from(value: renounceOwnershipCall) -> Self {
3776 ()
3777 }
3778 }
3779 #[automatically_derived]
3780 #[doc(hidden)]
3781 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipCall {
3782 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3783 Self {}
3784 }
3785 }
3786 }
3787 {
3788 #[doc(hidden)]
3789 type UnderlyingSolTuple<'a> = ();
3790 #[doc(hidden)]
3791 type UnderlyingRustTuple<'a> = ();
3792 #[cfg(test)]
3793 #[allow(dead_code, unreachable_patterns)]
3794 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3795 match _t {
3796 alloy_sol_types::private::AssertTypeEq::<
3797 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3798 >(_) => {},
3799 }
3800 }
3801 #[automatically_derived]
3802 #[doc(hidden)]
3803 impl ::core::convert::From<renounceOwnershipReturn> for UnderlyingRustTuple<'_> {
3804 fn from(value: renounceOwnershipReturn) -> Self {
3805 ()
3806 }
3807 }
3808 #[automatically_derived]
3809 #[doc(hidden)]
3810 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipReturn {
3811 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3812 Self {}
3813 }
3814 }
3815 }
3816 #[automatically_derived]
3817 impl alloy_sol_types::SolCall for renounceOwnershipCall {
3818 type Parameters<'a> = ();
3819 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3820 type Return = renounceOwnershipReturn;
3821 type ReturnTuple<'a> = ();
3822 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3823 const SIGNATURE: &'static str = "renounceOwnership()";
3824 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
3825 #[inline]
3826 fn new<'a>(
3827 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3828 ) -> Self {
3829 tuple.into()
3830 }
3831 #[inline]
3832 fn tokenize(&self) -> Self::Token<'_> {
3833 ()
3834 }
3835 #[inline]
3836 fn abi_decode_returns(
3837 data: &[u8],
3838 validate: bool,
3839 ) -> alloy_sol_types::Result<Self::Return> {
3840 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3841 data, validate,
3842 )
3843 .map(Into::into)
3844 }
3845 }
3846 };
3847 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3848 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3853 #[derive(Clone)]
3854 pub struct symbolCall {}
3855 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3856 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3858 #[derive(Clone)]
3859 pub struct symbolReturn {
3860 #[allow(missing_docs)]
3861 pub _0: alloy::sol_types::private::String,
3862 }
3863 #[allow(
3864 non_camel_case_types,
3865 non_snake_case,
3866 clippy::pub_underscore_fields,
3867 clippy::style
3868 )]
3869 const _: () = {
3870 use alloy::sol_types as alloy_sol_types;
3871 {
3872 #[doc(hidden)]
3873 type UnderlyingSolTuple<'a> = ();
3874 #[doc(hidden)]
3875 type UnderlyingRustTuple<'a> = ();
3876 #[cfg(test)]
3877 #[allow(dead_code, unreachable_patterns)]
3878 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3879 match _t {
3880 alloy_sol_types::private::AssertTypeEq::<
3881 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3882 >(_) => {},
3883 }
3884 }
3885 #[automatically_derived]
3886 #[doc(hidden)]
3887 impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
3888 fn from(value: symbolCall) -> Self {
3889 ()
3890 }
3891 }
3892 #[automatically_derived]
3893 #[doc(hidden)]
3894 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
3895 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3896 Self {}
3897 }
3898 }
3899 }
3900 {
3901 #[doc(hidden)]
3902 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
3903 #[doc(hidden)]
3904 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
3905 #[cfg(test)]
3906 #[allow(dead_code, unreachable_patterns)]
3907 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3908 match _t {
3909 alloy_sol_types::private::AssertTypeEq::<
3910 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3911 >(_) => {},
3912 }
3913 }
3914 #[automatically_derived]
3915 #[doc(hidden)]
3916 impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
3917 fn from(value: symbolReturn) -> Self {
3918 (value._0,)
3919 }
3920 }
3921 #[automatically_derived]
3922 #[doc(hidden)]
3923 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
3924 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3925 Self { _0: tuple.0 }
3926 }
3927 }
3928 }
3929 #[automatically_derived]
3930 impl alloy_sol_types::SolCall for symbolCall {
3931 type Parameters<'a> = ();
3932 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3933 type Return = symbolReturn;
3934 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
3935 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3936 const SIGNATURE: &'static str = "symbol()";
3937 const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
3938 #[inline]
3939 fn new<'a>(
3940 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3941 ) -> Self {
3942 tuple.into()
3943 }
3944 #[inline]
3945 fn tokenize(&self) -> Self::Token<'_> {
3946 ()
3947 }
3948 #[inline]
3949 fn abi_decode_returns(
3950 data: &[u8],
3951 validate: bool,
3952 ) -> alloy_sol_types::Result<Self::Return> {
3953 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3954 data, validate,
3955 )
3956 .map(Into::into)
3957 }
3958 }
3959 };
3960 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3961 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3966 #[derive(Clone)]
3967 pub struct totalSupplyCall {}
3968 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3969 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3971 #[derive(Clone)]
3972 pub struct totalSupplyReturn {
3973 #[allow(missing_docs)]
3974 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3975 }
3976 #[allow(
3977 non_camel_case_types,
3978 non_snake_case,
3979 clippy::pub_underscore_fields,
3980 clippy::style
3981 )]
3982 const _: () = {
3983 use alloy::sol_types as alloy_sol_types;
3984 {
3985 #[doc(hidden)]
3986 type UnderlyingSolTuple<'a> = ();
3987 #[doc(hidden)]
3988 type UnderlyingRustTuple<'a> = ();
3989 #[cfg(test)]
3990 #[allow(dead_code, unreachable_patterns)]
3991 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3992 match _t {
3993 alloy_sol_types::private::AssertTypeEq::<
3994 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3995 >(_) => {},
3996 }
3997 }
3998 #[automatically_derived]
3999 #[doc(hidden)]
4000 impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
4001 fn from(value: totalSupplyCall) -> Self {
4002 ()
4003 }
4004 }
4005 #[automatically_derived]
4006 #[doc(hidden)]
4007 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
4008 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4009 Self {}
4010 }
4011 }
4012 }
4013 {
4014 #[doc(hidden)]
4015 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4016 #[doc(hidden)]
4017 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
4018 #[cfg(test)]
4019 #[allow(dead_code, unreachable_patterns)]
4020 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4021 match _t {
4022 alloy_sol_types::private::AssertTypeEq::<
4023 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4024 >(_) => {},
4025 }
4026 }
4027 #[automatically_derived]
4028 #[doc(hidden)]
4029 impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
4030 fn from(value: totalSupplyReturn) -> Self {
4031 (value._0,)
4032 }
4033 }
4034 #[automatically_derived]
4035 #[doc(hidden)]
4036 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
4037 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4038 Self { _0: tuple.0 }
4039 }
4040 }
4041 }
4042 #[automatically_derived]
4043 impl alloy_sol_types::SolCall for totalSupplyCall {
4044 type Parameters<'a> = ();
4045 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4046 type Return = totalSupplyReturn;
4047 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4048 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4049 const SIGNATURE: &'static str = "totalSupply()";
4050 const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
4051 #[inline]
4052 fn new<'a>(
4053 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4054 ) -> Self {
4055 tuple.into()
4056 }
4057 #[inline]
4058 fn tokenize(&self) -> Self::Token<'_> {
4059 ()
4060 }
4061 #[inline]
4062 fn abi_decode_returns(
4063 data: &[u8],
4064 validate: bool,
4065 ) -> alloy_sol_types::Result<Self::Return> {
4066 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4067 data, validate,
4068 )
4069 .map(Into::into)
4070 }
4071 }
4072 };
4073 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4074 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4079 #[derive(Clone)]
4080 pub struct transferCall {
4081 #[allow(missing_docs)]
4082 pub to: alloy::sol_types::private::Address,
4083 #[allow(missing_docs)]
4084 pub value: alloy::sol_types::private::primitives::aliases::U256,
4085 }
4086 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4087 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4089 #[derive(Clone)]
4090 pub struct transferReturn {
4091 #[allow(missing_docs)]
4092 pub _0: bool,
4093 }
4094 #[allow(
4095 non_camel_case_types,
4096 non_snake_case,
4097 clippy::pub_underscore_fields,
4098 clippy::style
4099 )]
4100 const _: () = {
4101 use alloy::sol_types as alloy_sol_types;
4102 {
4103 #[doc(hidden)]
4104 type UnderlyingSolTuple<'a> = (
4105 alloy::sol_types::sol_data::Address,
4106 alloy::sol_types::sol_data::Uint<256>,
4107 );
4108 #[doc(hidden)]
4109 type UnderlyingRustTuple<'a> = (
4110 alloy::sol_types::private::Address,
4111 alloy::sol_types::private::primitives::aliases::U256,
4112 );
4113 #[cfg(test)]
4114 #[allow(dead_code, unreachable_patterns)]
4115 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4116 match _t {
4117 alloy_sol_types::private::AssertTypeEq::<
4118 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4119 >(_) => {},
4120 }
4121 }
4122 #[automatically_derived]
4123 #[doc(hidden)]
4124 impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
4125 fn from(value: transferCall) -> Self {
4126 (value.to, value.value)
4127 }
4128 }
4129 #[automatically_derived]
4130 #[doc(hidden)]
4131 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
4132 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4133 Self {
4134 to: tuple.0,
4135 value: tuple.1,
4136 }
4137 }
4138 }
4139 }
4140 {
4141 #[doc(hidden)]
4142 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4143 #[doc(hidden)]
4144 type UnderlyingRustTuple<'a> = (bool,);
4145 #[cfg(test)]
4146 #[allow(dead_code, unreachable_patterns)]
4147 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4148 match _t {
4149 alloy_sol_types::private::AssertTypeEq::<
4150 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4151 >(_) => {},
4152 }
4153 }
4154 #[automatically_derived]
4155 #[doc(hidden)]
4156 impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
4157 fn from(value: transferReturn) -> Self {
4158 (value._0,)
4159 }
4160 }
4161 #[automatically_derived]
4162 #[doc(hidden)]
4163 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
4164 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4165 Self { _0: tuple.0 }
4166 }
4167 }
4168 }
4169 #[automatically_derived]
4170 impl alloy_sol_types::SolCall for transferCall {
4171 type Parameters<'a> = (
4172 alloy::sol_types::sol_data::Address,
4173 alloy::sol_types::sol_data::Uint<256>,
4174 );
4175 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4176 type Return = transferReturn;
4177 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4178 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4179 const SIGNATURE: &'static str = "transfer(address,uint256)";
4180 const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
4181 #[inline]
4182 fn new<'a>(
4183 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4184 ) -> Self {
4185 tuple.into()
4186 }
4187 #[inline]
4188 fn tokenize(&self) -> Self::Token<'_> {
4189 (
4190 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4191 &self.to,
4192 ),
4193 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
4194 &self.value,
4195 ),
4196 )
4197 }
4198 #[inline]
4199 fn abi_decode_returns(
4200 data: &[u8],
4201 validate: bool,
4202 ) -> alloy_sol_types::Result<Self::Return> {
4203 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4204 data, validate,
4205 )
4206 .map(Into::into)
4207 }
4208 }
4209 };
4210 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4211 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4216 #[derive(Clone)]
4217 pub struct transferFromCall {
4218 #[allow(missing_docs)]
4219 pub from: alloy::sol_types::private::Address,
4220 #[allow(missing_docs)]
4221 pub to: alloy::sol_types::private::Address,
4222 #[allow(missing_docs)]
4223 pub value: alloy::sol_types::private::primitives::aliases::U256,
4224 }
4225 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4226 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4228 #[derive(Clone)]
4229 pub struct transferFromReturn {
4230 #[allow(missing_docs)]
4231 pub _0: bool,
4232 }
4233 #[allow(
4234 non_camel_case_types,
4235 non_snake_case,
4236 clippy::pub_underscore_fields,
4237 clippy::style
4238 )]
4239 const _: () = {
4240 use alloy::sol_types as alloy_sol_types;
4241 {
4242 #[doc(hidden)]
4243 type UnderlyingSolTuple<'a> = (
4244 alloy::sol_types::sol_data::Address,
4245 alloy::sol_types::sol_data::Address,
4246 alloy::sol_types::sol_data::Uint<256>,
4247 );
4248 #[doc(hidden)]
4249 type UnderlyingRustTuple<'a> = (
4250 alloy::sol_types::private::Address,
4251 alloy::sol_types::private::Address,
4252 alloy::sol_types::private::primitives::aliases::U256,
4253 );
4254 #[cfg(test)]
4255 #[allow(dead_code, unreachable_patterns)]
4256 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4257 match _t {
4258 alloy_sol_types::private::AssertTypeEq::<
4259 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4260 >(_) => {},
4261 }
4262 }
4263 #[automatically_derived]
4264 #[doc(hidden)]
4265 impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
4266 fn from(value: transferFromCall) -> Self {
4267 (value.from, value.to, value.value)
4268 }
4269 }
4270 #[automatically_derived]
4271 #[doc(hidden)]
4272 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
4273 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4274 Self {
4275 from: tuple.0,
4276 to: tuple.1,
4277 value: tuple.2,
4278 }
4279 }
4280 }
4281 }
4282 {
4283 #[doc(hidden)]
4284 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4285 #[doc(hidden)]
4286 type UnderlyingRustTuple<'a> = (bool,);
4287 #[cfg(test)]
4288 #[allow(dead_code, unreachable_patterns)]
4289 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4290 match _t {
4291 alloy_sol_types::private::AssertTypeEq::<
4292 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4293 >(_) => {},
4294 }
4295 }
4296 #[automatically_derived]
4297 #[doc(hidden)]
4298 impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
4299 fn from(value: transferFromReturn) -> Self {
4300 (value._0,)
4301 }
4302 }
4303 #[automatically_derived]
4304 #[doc(hidden)]
4305 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
4306 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4307 Self { _0: tuple.0 }
4308 }
4309 }
4310 }
4311 #[automatically_derived]
4312 impl alloy_sol_types::SolCall for transferFromCall {
4313 type Parameters<'a> = (
4314 alloy::sol_types::sol_data::Address,
4315 alloy::sol_types::sol_data::Address,
4316 alloy::sol_types::sol_data::Uint<256>,
4317 );
4318 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4319 type Return = transferFromReturn;
4320 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4321 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4322 const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
4323 const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
4324 #[inline]
4325 fn new<'a>(
4326 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4327 ) -> Self {
4328 tuple.into()
4329 }
4330 #[inline]
4331 fn tokenize(&self) -> Self::Token<'_> {
4332 (
4333 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4334 &self.from,
4335 ),
4336 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4337 &self.to,
4338 ),
4339 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
4340 &self.value,
4341 ),
4342 )
4343 }
4344 #[inline]
4345 fn abi_decode_returns(
4346 data: &[u8],
4347 validate: bool,
4348 ) -> alloy_sol_types::Result<Self::Return> {
4349 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4350 data, validate,
4351 )
4352 .map(Into::into)
4353 }
4354 }
4355 };
4356 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4357 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4362 #[derive(Clone)]
4363 pub struct transferOwnershipCall {
4364 #[allow(missing_docs)]
4365 pub newOwner: alloy::sol_types::private::Address,
4366 }
4367 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4369 #[derive(Clone)]
4370 pub struct transferOwnershipReturn {}
4371 #[allow(
4372 non_camel_case_types,
4373 non_snake_case,
4374 clippy::pub_underscore_fields,
4375 clippy::style
4376 )]
4377 const _: () = {
4378 use alloy::sol_types as alloy_sol_types;
4379 {
4380 #[doc(hidden)]
4381 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4382 #[doc(hidden)]
4383 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4384 #[cfg(test)]
4385 #[allow(dead_code, unreachable_patterns)]
4386 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4387 match _t {
4388 alloy_sol_types::private::AssertTypeEq::<
4389 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4390 >(_) => {},
4391 }
4392 }
4393 #[automatically_derived]
4394 #[doc(hidden)]
4395 impl ::core::convert::From<transferOwnershipCall> for UnderlyingRustTuple<'_> {
4396 fn from(value: transferOwnershipCall) -> Self {
4397 (value.newOwner,)
4398 }
4399 }
4400 #[automatically_derived]
4401 #[doc(hidden)]
4402 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipCall {
4403 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4404 Self { newOwner: tuple.0 }
4405 }
4406 }
4407 }
4408 {
4409 #[doc(hidden)]
4410 type UnderlyingSolTuple<'a> = ();
4411 #[doc(hidden)]
4412 type UnderlyingRustTuple<'a> = ();
4413 #[cfg(test)]
4414 #[allow(dead_code, unreachable_patterns)]
4415 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4416 match _t {
4417 alloy_sol_types::private::AssertTypeEq::<
4418 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4419 >(_) => {},
4420 }
4421 }
4422 #[automatically_derived]
4423 #[doc(hidden)]
4424 impl ::core::convert::From<transferOwnershipReturn> for UnderlyingRustTuple<'_> {
4425 fn from(value: transferOwnershipReturn) -> Self {
4426 ()
4427 }
4428 }
4429 #[automatically_derived]
4430 #[doc(hidden)]
4431 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipReturn {
4432 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4433 Self {}
4434 }
4435 }
4436 }
4437 #[automatically_derived]
4438 impl alloy_sol_types::SolCall for transferOwnershipCall {
4439 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4440 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4441 type Return = transferOwnershipReturn;
4442 type ReturnTuple<'a> = ();
4443 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4444 const SIGNATURE: &'static str = "transferOwnership(address)";
4445 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
4446 #[inline]
4447 fn new<'a>(
4448 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4449 ) -> Self {
4450 tuple.into()
4451 }
4452 #[inline]
4453 fn tokenize(&self) -> Self::Token<'_> {
4454 (
4455 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4456 &self.newOwner,
4457 ),
4458 )
4459 }
4460 #[inline]
4461 fn abi_decode_returns(
4462 data: &[u8],
4463 validate: bool,
4464 ) -> alloy_sol_types::Result<Self::Return> {
4465 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4466 data, validate,
4467 )
4468 .map(Into::into)
4469 }
4470 }
4471 };
4472 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4473 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4478 #[derive(Clone)]
4479 pub struct upgradeToAndCallCall {
4480 #[allow(missing_docs)]
4481 pub newImplementation: alloy::sol_types::private::Address,
4482 #[allow(missing_docs)]
4483 pub data: alloy::sol_types::private::Bytes,
4484 }
4485 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4487 #[derive(Clone)]
4488 pub struct upgradeToAndCallReturn {}
4489 #[allow(
4490 non_camel_case_types,
4491 non_snake_case,
4492 clippy::pub_underscore_fields,
4493 clippy::style
4494 )]
4495 const _: () = {
4496 use alloy::sol_types as alloy_sol_types;
4497 {
4498 #[doc(hidden)]
4499 type UnderlyingSolTuple<'a> = (
4500 alloy::sol_types::sol_data::Address,
4501 alloy::sol_types::sol_data::Bytes,
4502 );
4503 #[doc(hidden)]
4504 type UnderlyingRustTuple<'a> = (
4505 alloy::sol_types::private::Address,
4506 alloy::sol_types::private::Bytes,
4507 );
4508 #[cfg(test)]
4509 #[allow(dead_code, unreachable_patterns)]
4510 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4511 match _t {
4512 alloy_sol_types::private::AssertTypeEq::<
4513 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4514 >(_) => {},
4515 }
4516 }
4517 #[automatically_derived]
4518 #[doc(hidden)]
4519 impl ::core::convert::From<upgradeToAndCallCall> for UnderlyingRustTuple<'_> {
4520 fn from(value: upgradeToAndCallCall) -> Self {
4521 (value.newImplementation, value.data)
4522 }
4523 }
4524 #[automatically_derived]
4525 #[doc(hidden)]
4526 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeToAndCallCall {
4527 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4528 Self {
4529 newImplementation: tuple.0,
4530 data: tuple.1,
4531 }
4532 }
4533 }
4534 }
4535 {
4536 #[doc(hidden)]
4537 type UnderlyingSolTuple<'a> = ();
4538 #[doc(hidden)]
4539 type UnderlyingRustTuple<'a> = ();
4540 #[cfg(test)]
4541 #[allow(dead_code, unreachable_patterns)]
4542 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4543 match _t {
4544 alloy_sol_types::private::AssertTypeEq::<
4545 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4546 >(_) => {},
4547 }
4548 }
4549 #[automatically_derived]
4550 #[doc(hidden)]
4551 impl ::core::convert::From<upgradeToAndCallReturn> for UnderlyingRustTuple<'_> {
4552 fn from(value: upgradeToAndCallReturn) -> Self {
4553 ()
4554 }
4555 }
4556 #[automatically_derived]
4557 #[doc(hidden)]
4558 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeToAndCallReturn {
4559 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4560 Self {}
4561 }
4562 }
4563 }
4564 #[automatically_derived]
4565 impl alloy_sol_types::SolCall for upgradeToAndCallCall {
4566 type Parameters<'a> = (
4567 alloy::sol_types::sol_data::Address,
4568 alloy::sol_types::sol_data::Bytes,
4569 );
4570 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4571 type Return = upgradeToAndCallReturn;
4572 type ReturnTuple<'a> = ();
4573 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4574 const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)";
4575 const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8];
4576 #[inline]
4577 fn new<'a>(
4578 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4579 ) -> Self {
4580 tuple.into()
4581 }
4582 #[inline]
4583 fn tokenize(&self) -> Self::Token<'_> {
4584 (
4585 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4586 &self.newImplementation,
4587 ),
4588 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
4589 &self.data,
4590 ),
4591 )
4592 }
4593 #[inline]
4594 fn abi_decode_returns(
4595 data: &[u8],
4596 validate: bool,
4597 ) -> alloy_sol_types::Result<Self::Return> {
4598 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4599 data, validate,
4600 )
4601 .map(Into::into)
4602 }
4603 }
4604 };
4605 #[derive()]
4607 pub enum EspTokenCalls {
4608 #[allow(missing_docs)]
4609 UPGRADE_INTERFACE_VERSION(UPGRADE_INTERFACE_VERSIONCall),
4610 #[allow(missing_docs)]
4611 allowance(allowanceCall),
4612 #[allow(missing_docs)]
4613 approve(approveCall),
4614 #[allow(missing_docs)]
4615 balanceOf(balanceOfCall),
4616 #[allow(missing_docs)]
4617 decimals(decimalsCall),
4618 #[allow(missing_docs)]
4619 getVersion(getVersionCall),
4620 #[allow(missing_docs)]
4621 initialize(initializeCall),
4622 #[allow(missing_docs)]
4623 name(nameCall),
4624 #[allow(missing_docs)]
4625 owner(ownerCall),
4626 #[allow(missing_docs)]
4627 proxiableUUID(proxiableUUIDCall),
4628 #[allow(missing_docs)]
4629 renounceOwnership(renounceOwnershipCall),
4630 #[allow(missing_docs)]
4631 symbol(symbolCall),
4632 #[allow(missing_docs)]
4633 totalSupply(totalSupplyCall),
4634 #[allow(missing_docs)]
4635 transfer(transferCall),
4636 #[allow(missing_docs)]
4637 transferFrom(transferFromCall),
4638 #[allow(missing_docs)]
4639 transferOwnership(transferOwnershipCall),
4640 #[allow(missing_docs)]
4641 upgradeToAndCall(upgradeToAndCallCall),
4642 }
4643 #[automatically_derived]
4644 impl EspTokenCalls {
4645 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4652 [6u8, 253u8, 222u8, 3u8],
4653 [9u8, 94u8, 167u8, 179u8],
4654 [13u8, 142u8, 110u8, 44u8],
4655 [24u8, 22u8, 13u8, 221u8],
4656 [35u8, 184u8, 114u8, 221u8],
4657 [49u8, 60u8, 229u8, 103u8],
4658 [79u8, 30u8, 242u8, 134u8],
4659 [82u8, 209u8, 144u8, 45u8],
4660 [112u8, 160u8, 130u8, 49u8],
4661 [113u8, 80u8, 24u8, 166u8],
4662 [141u8, 165u8, 203u8, 91u8],
4663 [149u8, 216u8, 155u8, 65u8],
4664 [154u8, 184u8, 54u8, 126u8],
4665 [169u8, 5u8, 156u8, 187u8],
4666 [173u8, 60u8, 177u8, 204u8],
4667 [221u8, 98u8, 237u8, 62u8],
4668 [242u8, 253u8, 227u8, 139u8],
4669 ];
4670 }
4671 #[automatically_derived]
4672 impl alloy_sol_types::SolInterface for EspTokenCalls {
4673 const NAME: &'static str = "EspTokenCalls";
4674 const MIN_DATA_LENGTH: usize = 0usize;
4675 const COUNT: usize = 17usize;
4676 #[inline]
4677 fn selector(&self) -> [u8; 4] {
4678 match self {
4679 Self::UPGRADE_INTERFACE_VERSION(_) => {
4680 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SELECTOR
4681 },
4682 Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
4683 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
4684 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
4685 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
4686 Self::getVersion(_) => <getVersionCall as alloy_sol_types::SolCall>::SELECTOR,
4687 Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
4688 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
4689 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
4690 Self::proxiableUUID(_) => <proxiableUUIDCall as alloy_sol_types::SolCall>::SELECTOR,
4691 Self::renounceOwnership(_) => {
4692 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4693 },
4694 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
4695 Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
4696 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
4697 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
4698 Self::transferOwnership(_) => {
4699 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4700 },
4701 Self::upgradeToAndCall(_) => {
4702 <upgradeToAndCallCall as alloy_sol_types::SolCall>::SELECTOR
4703 },
4704 }
4705 }
4706 #[inline]
4707 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4708 Self::SELECTORS.get(i).copied()
4709 }
4710 #[inline]
4711 fn valid_selector(selector: [u8; 4]) -> bool {
4712 Self::SELECTORS.binary_search(&selector).is_ok()
4713 }
4714 #[inline]
4715 #[allow(non_snake_case)]
4716 fn abi_decode_raw(
4717 selector: [u8; 4],
4718 data: &[u8],
4719 validate: bool,
4720 ) -> alloy_sol_types::Result<Self> {
4721 static DECODE_SHIMS: &[fn(&[u8], bool) -> alloy_sol_types::Result<EspTokenCalls>] = &[
4722 {
4723 fn name(data: &[u8], validate: bool) -> alloy_sol_types::Result<EspTokenCalls> {
4724 <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4725 .map(EspTokenCalls::name)
4726 }
4727 name
4728 },
4729 {
4730 fn approve(
4731 data: &[u8],
4732 validate: bool,
4733 ) -> alloy_sol_types::Result<EspTokenCalls> {
4734 <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4735 .map(EspTokenCalls::approve)
4736 }
4737 approve
4738 },
4739 {
4740 fn getVersion(
4741 data: &[u8],
4742 validate: bool,
4743 ) -> alloy_sol_types::Result<EspTokenCalls> {
4744 <getVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4745 .map(EspTokenCalls::getVersion)
4746 }
4747 getVersion
4748 },
4749 {
4750 fn totalSupply(
4751 data: &[u8],
4752 validate: bool,
4753 ) -> alloy_sol_types::Result<EspTokenCalls> {
4754 <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(
4755 data, validate,
4756 )
4757 .map(EspTokenCalls::totalSupply)
4758 }
4759 totalSupply
4760 },
4761 {
4762 fn transferFrom(
4763 data: &[u8],
4764 validate: bool,
4765 ) -> alloy_sol_types::Result<EspTokenCalls> {
4766 <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(
4767 data, validate,
4768 )
4769 .map(EspTokenCalls::transferFrom)
4770 }
4771 transferFrom
4772 },
4773 {
4774 fn decimals(
4775 data: &[u8],
4776 validate: bool,
4777 ) -> alloy_sol_types::Result<EspTokenCalls> {
4778 <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4779 .map(EspTokenCalls::decimals)
4780 }
4781 decimals
4782 },
4783 {
4784 fn upgradeToAndCall(
4785 data: &[u8],
4786 validate: bool,
4787 ) -> alloy_sol_types::Result<EspTokenCalls> {
4788 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(
4789 data, validate,
4790 )
4791 .map(EspTokenCalls::upgradeToAndCall)
4792 }
4793 upgradeToAndCall
4794 },
4795 {
4796 fn proxiableUUID(
4797 data: &[u8],
4798 validate: bool,
4799 ) -> alloy_sol_types::Result<EspTokenCalls> {
4800 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
4801 data, validate,
4802 )
4803 .map(EspTokenCalls::proxiableUUID)
4804 }
4805 proxiableUUID
4806 },
4807 {
4808 fn balanceOf(
4809 data: &[u8],
4810 validate: bool,
4811 ) -> alloy_sol_types::Result<EspTokenCalls> {
4812 <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4813 .map(EspTokenCalls::balanceOf)
4814 }
4815 balanceOf
4816 },
4817 {
4818 fn renounceOwnership(
4819 data: &[u8],
4820 validate: bool,
4821 ) -> alloy_sol_types::Result<EspTokenCalls> {
4822 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
4823 data, validate,
4824 )
4825 .map(EspTokenCalls::renounceOwnership)
4826 }
4827 renounceOwnership
4828 },
4829 {
4830 fn owner(
4831 data: &[u8],
4832 validate: bool,
4833 ) -> alloy_sol_types::Result<EspTokenCalls> {
4834 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4835 .map(EspTokenCalls::owner)
4836 }
4837 owner
4838 },
4839 {
4840 fn symbol(
4841 data: &[u8],
4842 validate: bool,
4843 ) -> alloy_sol_types::Result<EspTokenCalls> {
4844 <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4845 .map(EspTokenCalls::symbol)
4846 }
4847 symbol
4848 },
4849 {
4850 fn initialize(
4851 data: &[u8],
4852 validate: bool,
4853 ) -> alloy_sol_types::Result<EspTokenCalls> {
4854 <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4855 .map(EspTokenCalls::initialize)
4856 }
4857 initialize
4858 },
4859 {
4860 fn transfer(
4861 data: &[u8],
4862 validate: bool,
4863 ) -> alloy_sol_types::Result<EspTokenCalls> {
4864 <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4865 .map(EspTokenCalls::transfer)
4866 }
4867 transfer
4868 },
4869 {
4870 fn UPGRADE_INTERFACE_VERSION(
4871 data: &[u8],
4872 validate: bool,
4873 ) -> alloy_sol_types::Result<EspTokenCalls> {
4874 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(
4875 data, validate,
4876 )
4877 .map(EspTokenCalls::UPGRADE_INTERFACE_VERSION)
4878 }
4879 UPGRADE_INTERFACE_VERSION
4880 },
4881 {
4882 fn allowance(
4883 data: &[u8],
4884 validate: bool,
4885 ) -> alloy_sol_types::Result<EspTokenCalls> {
4886 <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4887 .map(EspTokenCalls::allowance)
4888 }
4889 allowance
4890 },
4891 {
4892 fn transferOwnership(
4893 data: &[u8],
4894 validate: bool,
4895 ) -> alloy_sol_types::Result<EspTokenCalls> {
4896 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
4897 data, validate,
4898 )
4899 .map(EspTokenCalls::transferOwnership)
4900 }
4901 transferOwnership
4902 },
4903 ];
4904 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4905 return Err(alloy_sol_types::Error::unknown_selector(
4906 <Self as alloy_sol_types::SolInterface>::NAME,
4907 selector,
4908 ));
4909 };
4910 DECODE_SHIMS[idx](data, validate)
4911 }
4912 #[inline]
4913 fn abi_encoded_size(&self) -> usize {
4914 match self {
4915 Self::UPGRADE_INTERFACE_VERSION(inner) => {
4916 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
4917 inner,
4918 )
4919 },
4920 Self::allowance(inner) => {
4921 <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4922 },
4923 Self::approve(inner) => {
4924 <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4925 },
4926 Self::balanceOf(inner) => {
4927 <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4928 },
4929 Self::decimals(inner) => {
4930 <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4931 },
4932 Self::getVersion(inner) => {
4933 <getVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4934 },
4935 Self::initialize(inner) => {
4936 <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4937 },
4938 Self::name(inner) => {
4939 <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4940 },
4941 Self::owner(inner) => {
4942 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4943 },
4944 Self::proxiableUUID(inner) => {
4945 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4946 },
4947 Self::renounceOwnership(inner) => {
4948 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4949 },
4950 Self::symbol(inner) => {
4951 <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4952 },
4953 Self::totalSupply(inner) => {
4954 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4955 },
4956 Self::transfer(inner) => {
4957 <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4958 },
4959 Self::transferFrom(inner) => {
4960 <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4961 },
4962 Self::transferOwnership(inner) => {
4963 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4964 },
4965 Self::upgradeToAndCall(inner) => {
4966 <upgradeToAndCallCall as alloy_sol_types::SolCall>::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::UPGRADE_INTERFACE_VERSION(inner) => {
4974 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
4975 inner, out,
4976 )
4977 },
4978 Self::allowance(inner) => {
4979 <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4980 },
4981 Self::approve(inner) => {
4982 <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4983 },
4984 Self::balanceOf(inner) => {
4985 <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4986 },
4987 Self::decimals(inner) => {
4988 <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4989 },
4990 Self::getVersion(inner) => {
4991 <getVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4992 },
4993 Self::initialize(inner) => {
4994 <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4995 },
4996 Self::name(inner) => {
4997 <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4998 },
4999 Self::owner(inner) => {
5000 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5001 },
5002 Self::proxiableUUID(inner) => {
5003 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5004 },
5005 Self::renounceOwnership(inner) => {
5006 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5007 },
5008 Self::symbol(inner) => {
5009 <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5010 },
5011 Self::totalSupply(inner) => {
5012 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5013 },
5014 Self::transfer(inner) => {
5015 <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5016 },
5017 Self::transferFrom(inner) => {
5018 <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5019 },
5020 Self::transferOwnership(inner) => {
5021 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5022 },
5023 Self::upgradeToAndCall(inner) => {
5024 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5025 },
5026 }
5027 }
5028 }
5029 #[derive(Debug, PartialEq, Eq, Hash)]
5031 pub enum EspTokenErrors {
5032 #[allow(missing_docs)]
5033 AddressEmptyCode(AddressEmptyCode),
5034 #[allow(missing_docs)]
5035 ERC1967InvalidImplementation(ERC1967InvalidImplementation),
5036 #[allow(missing_docs)]
5037 ERC1967NonPayable(ERC1967NonPayable),
5038 #[allow(missing_docs)]
5039 ERC20InsufficientAllowance(ERC20InsufficientAllowance),
5040 #[allow(missing_docs)]
5041 ERC20InsufficientBalance(ERC20InsufficientBalance),
5042 #[allow(missing_docs)]
5043 ERC20InvalidApprover(ERC20InvalidApprover),
5044 #[allow(missing_docs)]
5045 ERC20InvalidReceiver(ERC20InvalidReceiver),
5046 #[allow(missing_docs)]
5047 ERC20InvalidSender(ERC20InvalidSender),
5048 #[allow(missing_docs)]
5049 ERC20InvalidSpender(ERC20InvalidSpender),
5050 #[allow(missing_docs)]
5051 FailedInnerCall(FailedInnerCall),
5052 #[allow(missing_docs)]
5053 InvalidInitialization(InvalidInitialization),
5054 #[allow(missing_docs)]
5055 NotInitializing(NotInitializing),
5056 #[allow(missing_docs)]
5057 OwnableInvalidOwner(OwnableInvalidOwner),
5058 #[allow(missing_docs)]
5059 OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
5060 #[allow(missing_docs)]
5061 UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext),
5062 #[allow(missing_docs)]
5063 UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID),
5064 }
5065 #[automatically_derived]
5066 impl EspTokenErrors {
5067 pub const SELECTORS: &'static [[u8; 4usize]] = &[
5074 [17u8, 140u8, 218u8, 167u8],
5075 [20u8, 37u8, 234u8, 66u8],
5076 [30u8, 79u8, 189u8, 247u8],
5077 [76u8, 156u8, 140u8, 227u8],
5078 [148u8, 40u8, 13u8, 98u8],
5079 [150u8, 198u8, 253u8, 30u8],
5080 [153u8, 150u8, 179u8, 21u8],
5081 [170u8, 29u8, 73u8, 164u8],
5082 [179u8, 152u8, 151u8, 159u8],
5083 [215u8, 230u8, 188u8, 248u8],
5084 [224u8, 124u8, 141u8, 186u8],
5085 [228u8, 80u8, 211u8, 140u8],
5086 [230u8, 2u8, 223u8, 5u8],
5087 [236u8, 68u8, 47u8, 5u8],
5088 [249u8, 46u8, 232u8, 169u8],
5089 [251u8, 143u8, 65u8, 178u8],
5090 ];
5091 }
5092 #[automatically_derived]
5093 impl alloy_sol_types::SolInterface for EspTokenErrors {
5094 const NAME: &'static str = "EspTokenErrors";
5095 const MIN_DATA_LENGTH: usize = 0usize;
5096 const COUNT: usize = 16usize;
5097 #[inline]
5098 fn selector(&self) -> [u8; 4] {
5099 match self {
5100 Self::AddressEmptyCode(_) => {
5101 <AddressEmptyCode as alloy_sol_types::SolError>::SELECTOR
5102 },
5103 Self::ERC1967InvalidImplementation(_) => {
5104 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SELECTOR
5105 },
5106 Self::ERC1967NonPayable(_) => {
5107 <ERC1967NonPayable as alloy_sol_types::SolError>::SELECTOR
5108 },
5109 Self::ERC20InsufficientAllowance(_) => {
5110 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::SELECTOR
5111 },
5112 Self::ERC20InsufficientBalance(_) => {
5113 <ERC20InsufficientBalance as alloy_sol_types::SolError>::SELECTOR
5114 },
5115 Self::ERC20InvalidApprover(_) => {
5116 <ERC20InvalidApprover as alloy_sol_types::SolError>::SELECTOR
5117 },
5118 Self::ERC20InvalidReceiver(_) => {
5119 <ERC20InvalidReceiver as alloy_sol_types::SolError>::SELECTOR
5120 },
5121 Self::ERC20InvalidSender(_) => {
5122 <ERC20InvalidSender as alloy_sol_types::SolError>::SELECTOR
5123 },
5124 Self::ERC20InvalidSpender(_) => {
5125 <ERC20InvalidSpender as alloy_sol_types::SolError>::SELECTOR
5126 },
5127 Self::FailedInnerCall(_) => {
5128 <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
5129 },
5130 Self::InvalidInitialization(_) => {
5131 <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
5132 },
5133 Self::NotInitializing(_) => {
5134 <NotInitializing as alloy_sol_types::SolError>::SELECTOR
5135 },
5136 Self::OwnableInvalidOwner(_) => {
5137 <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
5138 },
5139 Self::OwnableUnauthorizedAccount(_) => {
5140 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
5141 },
5142 Self::UUPSUnauthorizedCallContext(_) => {
5143 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SELECTOR
5144 },
5145 Self::UUPSUnsupportedProxiableUUID(_) => {
5146 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SELECTOR
5147 },
5148 }
5149 }
5150 #[inline]
5151 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5152 Self::SELECTORS.get(i).copied()
5153 }
5154 #[inline]
5155 fn valid_selector(selector: [u8; 4]) -> bool {
5156 Self::SELECTORS.binary_search(&selector).is_ok()
5157 }
5158 #[inline]
5159 #[allow(non_snake_case)]
5160 fn abi_decode_raw(
5161 selector: [u8; 4],
5162 data: &[u8],
5163 validate: bool,
5164 ) -> alloy_sol_types::Result<Self> {
5165 static DECODE_SHIMS: &[fn(&[u8], bool) -> alloy_sol_types::Result<EspTokenErrors>] = &[
5166 {
5167 fn OwnableUnauthorizedAccount(
5168 data: &[u8],
5169 validate: bool,
5170 ) -> alloy_sol_types::Result<EspTokenErrors> {
5171 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
5172 data, validate,
5173 )
5174 .map(EspTokenErrors::OwnableUnauthorizedAccount)
5175 }
5176 OwnableUnauthorizedAccount
5177 },
5178 {
5179 fn FailedInnerCall(
5180 data: &[u8],
5181 validate: bool,
5182 ) -> alloy_sol_types::Result<EspTokenErrors> {
5183 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(
5184 data, validate,
5185 )
5186 .map(EspTokenErrors::FailedInnerCall)
5187 }
5188 FailedInnerCall
5189 },
5190 {
5191 fn OwnableInvalidOwner(
5192 data: &[u8],
5193 validate: bool,
5194 ) -> alloy_sol_types::Result<EspTokenErrors> {
5195 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
5196 data, validate,
5197 )
5198 .map(EspTokenErrors::OwnableInvalidOwner)
5199 }
5200 OwnableInvalidOwner
5201 },
5202 {
5203 fn ERC1967InvalidImplementation(
5204 data: &[u8],
5205 validate: bool,
5206 ) -> alloy_sol_types::Result<EspTokenErrors> {
5207 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_decode_raw(
5208 data, validate,
5209 )
5210 .map(EspTokenErrors::ERC1967InvalidImplementation)
5211 }
5212 ERC1967InvalidImplementation
5213 },
5214 {
5215 fn ERC20InvalidSpender(
5216 data: &[u8],
5217 validate: bool,
5218 ) -> alloy_sol_types::Result<EspTokenErrors> {
5219 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_decode_raw(
5220 data, validate,
5221 )
5222 .map(EspTokenErrors::ERC20InvalidSpender)
5223 }
5224 ERC20InvalidSpender
5225 },
5226 {
5227 fn ERC20InvalidSender(
5228 data: &[u8],
5229 validate: bool,
5230 ) -> alloy_sol_types::Result<EspTokenErrors> {
5231 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_decode_raw(
5232 data, validate,
5233 )
5234 .map(EspTokenErrors::ERC20InvalidSender)
5235 }
5236 ERC20InvalidSender
5237 },
5238 {
5239 fn AddressEmptyCode(
5240 data: &[u8],
5241 validate: bool,
5242 ) -> alloy_sol_types::Result<EspTokenErrors> {
5243 <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw(
5244 data, validate,
5245 )
5246 .map(EspTokenErrors::AddressEmptyCode)
5247 }
5248 AddressEmptyCode
5249 },
5250 {
5251 fn UUPSUnsupportedProxiableUUID(
5252 data: &[u8],
5253 validate: bool,
5254 ) -> alloy_sol_types::Result<EspTokenErrors> {
5255 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_decode_raw(
5256 data, validate,
5257 )
5258 .map(EspTokenErrors::UUPSUnsupportedProxiableUUID)
5259 }
5260 UUPSUnsupportedProxiableUUID
5261 },
5262 {
5263 fn ERC1967NonPayable(
5264 data: &[u8],
5265 validate: bool,
5266 ) -> alloy_sol_types::Result<EspTokenErrors> {
5267 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_decode_raw(
5268 data, validate,
5269 )
5270 .map(EspTokenErrors::ERC1967NonPayable)
5271 }
5272 ERC1967NonPayable
5273 },
5274 {
5275 fn NotInitializing(
5276 data: &[u8],
5277 validate: bool,
5278 ) -> alloy_sol_types::Result<EspTokenErrors> {
5279 <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw(
5280 data, validate,
5281 )
5282 .map(EspTokenErrors::NotInitializing)
5283 }
5284 NotInitializing
5285 },
5286 {
5287 fn UUPSUnauthorizedCallContext(
5288 data: &[u8],
5289 validate: bool,
5290 ) -> alloy_sol_types::Result<EspTokenErrors> {
5291 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_decode_raw(
5292 data, validate,
5293 )
5294 .map(EspTokenErrors::UUPSUnauthorizedCallContext)
5295 }
5296 UUPSUnauthorizedCallContext
5297 },
5298 {
5299 fn ERC20InsufficientBalance(
5300 data: &[u8],
5301 validate: bool,
5302 ) -> alloy_sol_types::Result<EspTokenErrors> {
5303 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw(
5304 data, validate,
5305 )
5306 .map(EspTokenErrors::ERC20InsufficientBalance)
5307 }
5308 ERC20InsufficientBalance
5309 },
5310 {
5311 fn ERC20InvalidApprover(
5312 data: &[u8],
5313 validate: bool,
5314 ) -> alloy_sol_types::Result<EspTokenErrors> {
5315 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_decode_raw(
5316 data, validate,
5317 )
5318 .map(EspTokenErrors::ERC20InvalidApprover)
5319 }
5320 ERC20InvalidApprover
5321 },
5322 {
5323 fn ERC20InvalidReceiver(
5324 data: &[u8],
5325 validate: bool,
5326 ) -> alloy_sol_types::Result<EspTokenErrors> {
5327 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_decode_raw(
5328 data, validate,
5329 )
5330 .map(EspTokenErrors::ERC20InvalidReceiver)
5331 }
5332 ERC20InvalidReceiver
5333 },
5334 {
5335 fn InvalidInitialization(
5336 data: &[u8],
5337 validate: bool,
5338 ) -> alloy_sol_types::Result<EspTokenErrors> {
5339 <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw(
5340 data, validate,
5341 )
5342 .map(EspTokenErrors::InvalidInitialization)
5343 }
5344 InvalidInitialization
5345 },
5346 {
5347 fn ERC20InsufficientAllowance(
5348 data: &[u8],
5349 validate: bool,
5350 ) -> alloy_sol_types::Result<EspTokenErrors> {
5351 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_decode_raw(
5352 data, validate,
5353 )
5354 .map(EspTokenErrors::ERC20InsufficientAllowance)
5355 }
5356 ERC20InsufficientAllowance
5357 },
5358 ];
5359 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5360 return Err(alloy_sol_types::Error::unknown_selector(
5361 <Self as alloy_sol_types::SolInterface>::NAME,
5362 selector,
5363 ));
5364 };
5365 DECODE_SHIMS[idx](data, validate)
5366 }
5367 #[inline]
5368 fn abi_encoded_size(&self) -> usize {
5369 match self {
5370 Self::AddressEmptyCode(inner) => {
5371 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encoded_size(inner)
5372 },
5373 Self::ERC1967InvalidImplementation(inner) => {
5374 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encoded_size(
5375 inner,
5376 )
5377 },
5378 Self::ERC1967NonPayable(inner) => {
5379 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encoded_size(inner)
5380 },
5381 Self::ERC20InsufficientAllowance(inner) => {
5382 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_encoded_size(
5383 inner,
5384 )
5385 },
5386 Self::ERC20InsufficientBalance(inner) => {
5387 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_encoded_size(inner)
5388 },
5389 Self::ERC20InvalidApprover(inner) => {
5390 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_encoded_size(inner)
5391 },
5392 Self::ERC20InvalidReceiver(inner) => {
5393 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_encoded_size(inner)
5394 },
5395 Self::ERC20InvalidSender(inner) => {
5396 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_encoded_size(inner)
5397 },
5398 Self::ERC20InvalidSpender(inner) => {
5399 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_encoded_size(inner)
5400 },
5401 Self::FailedInnerCall(inner) => {
5402 <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(inner)
5403 },
5404 Self::InvalidInitialization(inner) => {
5405 <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(inner)
5406 },
5407 Self::NotInitializing(inner) => {
5408 <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(inner)
5409 },
5410 Self::OwnableInvalidOwner(inner) => {
5411 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(inner)
5412 },
5413 Self::OwnableUnauthorizedAccount(inner) => {
5414 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
5415 inner,
5416 )
5417 },
5418 Self::UUPSUnauthorizedCallContext(inner) => {
5419 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encoded_size(
5420 inner,
5421 )
5422 },
5423 Self::UUPSUnsupportedProxiableUUID(inner) => {
5424 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encoded_size(
5425 inner,
5426 )
5427 },
5428 }
5429 }
5430 #[inline]
5431 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5432 match self {
5433 Self::AddressEmptyCode(inner) => {
5434 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5435 },
5436 Self::ERC1967InvalidImplementation(inner) => {
5437 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encode_raw(
5438 inner, out,
5439 )
5440 },
5441 Self::ERC1967NonPayable(inner) => {
5442 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5443 },
5444 Self::ERC20InsufficientAllowance(inner) => {
5445 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_encode_raw(
5446 inner, out,
5447 )
5448 },
5449 Self::ERC20InsufficientBalance(inner) => {
5450 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_encode_raw(
5451 inner, out,
5452 )
5453 },
5454 Self::ERC20InvalidApprover(inner) => {
5455 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5456 },
5457 Self::ERC20InvalidReceiver(inner) => {
5458 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5459 },
5460 Self::ERC20InvalidSender(inner) => {
5461 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5462 },
5463 Self::ERC20InvalidSpender(inner) => {
5464 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5465 },
5466 Self::FailedInnerCall(inner) => {
5467 <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5468 },
5469 Self::InvalidInitialization(inner) => {
5470 <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5471 },
5472 Self::NotInitializing(inner) => {
5473 <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5474 },
5475 Self::OwnableInvalidOwner(inner) => {
5476 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5477 },
5478 Self::OwnableUnauthorizedAccount(inner) => {
5479 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
5480 inner, out,
5481 )
5482 },
5483 Self::UUPSUnauthorizedCallContext(inner) => {
5484 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encode_raw(
5485 inner, out,
5486 )
5487 },
5488 Self::UUPSUnsupportedProxiableUUID(inner) => {
5489 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encode_raw(
5490 inner, out,
5491 )
5492 },
5493 }
5494 }
5495 }
5496 #[derive(Debug, PartialEq, Eq, Hash)]
5498 pub enum EspTokenEvents {
5499 #[allow(missing_docs)]
5500 Approval(Approval),
5501 #[allow(missing_docs)]
5502 Initialized(Initialized),
5503 #[allow(missing_docs)]
5504 OwnershipTransferred(OwnershipTransferred),
5505 #[allow(missing_docs)]
5506 Transfer(Transfer),
5507 #[allow(missing_docs)]
5508 Upgrade(Upgrade),
5509 #[allow(missing_docs)]
5510 Upgraded(Upgraded),
5511 }
5512 #[automatically_derived]
5513 impl EspTokenEvents {
5514 pub const SELECTORS: &'static [[u8; 32usize]] = &[
5521 [
5522 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8,
5523 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8,
5524 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
5525 ],
5526 [
5527 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
5528 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
5529 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
5530 ],
5531 [
5532 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, 179u8,
5533 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, 192u8, 34u8,
5534 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
5535 ],
5536 [
5537 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8,
5538 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8,
5539 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
5540 ],
5541 [
5542 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
5543 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
5544 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
5545 ],
5546 [
5547 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8,
5548 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, 237u8,
5549 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
5550 ],
5551 ];
5552 }
5553 #[automatically_derived]
5554 impl alloy_sol_types::SolEventInterface for EspTokenEvents {
5555 const NAME: &'static str = "EspTokenEvents";
5556 const COUNT: usize = 6usize;
5557 fn decode_raw_log(
5558 topics: &[alloy_sol_types::Word],
5559 data: &[u8],
5560 validate: bool,
5561 ) -> alloy_sol_types::Result<Self> {
5562 match topics.first().copied() {
5563 Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5564 <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
5565 .map(Self::Approval)
5566 },
5567 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5568 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
5569 topics, data, validate,
5570 )
5571 .map(Self::Initialized)
5572 },
5573 Some(<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5574 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
5575 topics, data, validate,
5576 )
5577 .map(Self::OwnershipTransferred)
5578 },
5579 Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5580 <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
5581 .map(Self::Transfer)
5582 },
5583 Some(<Upgrade as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5584 <Upgrade as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
5585 .map(Self::Upgrade)
5586 },
5587 Some(<Upgraded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5588 <Upgraded as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
5589 .map(Self::Upgraded)
5590 },
5591 _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
5592 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
5593 log: alloy_sol_types::private::Box::new(
5594 alloy_sol_types::private::LogData::new_unchecked(
5595 topics.to_vec(),
5596 data.to_vec().into(),
5597 ),
5598 ),
5599 }),
5600 }
5601 }
5602 }
5603 #[automatically_derived]
5604 impl alloy_sol_types::private::IntoLogData for EspTokenEvents {
5605 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5606 match self {
5607 Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
5608 Self::Initialized(inner) => {
5609 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5610 },
5611 Self::OwnershipTransferred(inner) => {
5612 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5613 },
5614 Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
5615 Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
5616 Self::Upgraded(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
5617 }
5618 }
5619 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5620 match self {
5621 Self::Approval(inner) => {
5622 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5623 },
5624 Self::Initialized(inner) => {
5625 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5626 },
5627 Self::OwnershipTransferred(inner) => {
5628 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5629 },
5630 Self::Transfer(inner) => {
5631 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5632 },
5633 Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
5634 Self::Upgraded(inner) => {
5635 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5636 },
5637 }
5638 }
5639 }
5640 use alloy::contract as alloy_contract;
5641 #[inline]
5645 pub const fn new<
5646 T: alloy_contract::private::Transport + ::core::clone::Clone,
5647 P: alloy_contract::private::Provider<T, N>,
5648 N: alloy_contract::private::Network,
5649 >(
5650 address: alloy_sol_types::private::Address,
5651 provider: P,
5652 ) -> EspTokenInstance<T, P, N> {
5653 EspTokenInstance::<T, P, N>::new(address, provider)
5654 }
5655 #[inline]
5661 pub fn deploy<
5662 T: alloy_contract::private::Transport + ::core::clone::Clone,
5663 P: alloy_contract::private::Provider<T, N>,
5664 N: alloy_contract::private::Network,
5665 >(
5666 provider: P,
5667 ) -> impl ::core::future::Future<Output = alloy_contract::Result<EspTokenInstance<T, P, N>>>
5668 {
5669 EspTokenInstance::<T, P, N>::deploy(provider)
5670 }
5671 #[inline]
5677 pub fn deploy_builder<
5678 T: alloy_contract::private::Transport + ::core::clone::Clone,
5679 P: alloy_contract::private::Provider<T, N>,
5680 N: alloy_contract::private::Network,
5681 >(
5682 provider: P,
5683 ) -> alloy_contract::RawCallBuilder<T, P, N> {
5684 EspTokenInstance::<T, P, N>::deploy_builder(provider)
5685 }
5686 #[derive(Clone)]
5698 pub struct EspTokenInstance<T, P, N = alloy_contract::private::Ethereum> {
5699 address: alloy_sol_types::private::Address,
5700 provider: P,
5701 _network_transport: ::core::marker::PhantomData<(N, T)>,
5702 }
5703 #[automatically_derived]
5704 impl<T, P, N> ::core::fmt::Debug for EspTokenInstance<T, P, N> {
5705 #[inline]
5706 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5707 f.debug_tuple("EspTokenInstance")
5708 .field(&self.address)
5709 .finish()
5710 }
5711 }
5712 #[automatically_derived]
5714 impl<
5715 T: alloy_contract::private::Transport + ::core::clone::Clone,
5716 P: alloy_contract::private::Provider<T, N>,
5717 N: alloy_contract::private::Network,
5718 > EspTokenInstance<T, P, N>
5719 {
5720 #[inline]
5724 pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
5725 Self {
5726 address,
5727 provider,
5728 _network_transport: ::core::marker::PhantomData,
5729 }
5730 }
5731 #[inline]
5737 pub async fn deploy(provider: P) -> alloy_contract::Result<EspTokenInstance<T, P, N>> {
5738 let call_builder = Self::deploy_builder(provider);
5739 let contract_address = call_builder.deploy().await?;
5740 Ok(Self::new(contract_address, call_builder.provider))
5741 }
5742 #[inline]
5748 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
5749 alloy_contract::RawCallBuilder::new_raw_deploy(
5750 provider,
5751 ::core::clone::Clone::clone(&BYTECODE),
5752 )
5753 }
5754 #[inline]
5756 pub const fn address(&self) -> &alloy_sol_types::private::Address {
5757 &self.address
5758 }
5759 #[inline]
5761 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
5762 self.address = address;
5763 }
5764 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
5766 self.set_address(address);
5767 self
5768 }
5769 #[inline]
5771 pub const fn provider(&self) -> &P {
5772 &self.provider
5773 }
5774 }
5775 impl<T, P: ::core::clone::Clone, N> EspTokenInstance<T, &P, N> {
5776 #[inline]
5778 pub fn with_cloned_provider(self) -> EspTokenInstance<T, P, N> {
5779 EspTokenInstance {
5780 address: self.address,
5781 provider: ::core::clone::Clone::clone(&self.provider),
5782 _network_transport: ::core::marker::PhantomData,
5783 }
5784 }
5785 }
5786 #[automatically_derived]
5788 impl<
5789 T: alloy_contract::private::Transport + ::core::clone::Clone,
5790 P: alloy_contract::private::Provider<T, N>,
5791 N: alloy_contract::private::Network,
5792 > EspTokenInstance<T, P, N>
5793 {
5794 pub fn call_builder<C: alloy_sol_types::SolCall>(
5799 &self,
5800 call: &C,
5801 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
5802 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
5803 }
5804 pub fn UPGRADE_INTERFACE_VERSION(
5806 &self,
5807 ) -> alloy_contract::SolCallBuilder<T, &P, UPGRADE_INTERFACE_VERSIONCall, N> {
5808 self.call_builder(&UPGRADE_INTERFACE_VERSIONCall {})
5809 }
5810 pub fn allowance(
5812 &self,
5813 owner: alloy::sol_types::private::Address,
5814 spender: alloy::sol_types::private::Address,
5815 ) -> alloy_contract::SolCallBuilder<T, &P, allowanceCall, N> {
5816 self.call_builder(&allowanceCall { owner, spender })
5817 }
5818 pub fn approve(
5820 &self,
5821 spender: alloy::sol_types::private::Address,
5822 value: alloy::sol_types::private::primitives::aliases::U256,
5823 ) -> alloy_contract::SolCallBuilder<T, &P, approveCall, N> {
5824 self.call_builder(&approveCall { spender, value })
5825 }
5826 pub fn balanceOf(
5828 &self,
5829 account: alloy::sol_types::private::Address,
5830 ) -> alloy_contract::SolCallBuilder<T, &P, balanceOfCall, N> {
5831 self.call_builder(&balanceOfCall { account })
5832 }
5833 pub fn decimals(&self) -> alloy_contract::SolCallBuilder<T, &P, decimalsCall, N> {
5835 self.call_builder(&decimalsCall {})
5836 }
5837 pub fn getVersion(&self) -> alloy_contract::SolCallBuilder<T, &P, getVersionCall, N> {
5839 self.call_builder(&getVersionCall {})
5840 }
5841 pub fn initialize(
5843 &self,
5844 owner: alloy::sol_types::private::Address,
5845 initialRecipient: alloy::sol_types::private::Address,
5846 initialSupply: alloy::sol_types::private::primitives::aliases::U256,
5847 name: alloy::sol_types::private::String,
5848 symbol: alloy::sol_types::private::String,
5849 ) -> alloy_contract::SolCallBuilder<T, &P, initializeCall, N> {
5850 self.call_builder(&initializeCall {
5851 owner,
5852 initialRecipient,
5853 initialSupply,
5854 name,
5855 symbol,
5856 })
5857 }
5858 pub fn name(&self) -> alloy_contract::SolCallBuilder<T, &P, nameCall, N> {
5860 self.call_builder(&nameCall {})
5861 }
5862 pub fn owner(&self) -> alloy_contract::SolCallBuilder<T, &P, ownerCall, N> {
5864 self.call_builder(&ownerCall {})
5865 }
5866 pub fn proxiableUUID(&self) -> alloy_contract::SolCallBuilder<T, &P, proxiableUUIDCall, N> {
5868 self.call_builder(&proxiableUUIDCall {})
5869 }
5870 pub fn renounceOwnership(
5872 &self,
5873 ) -> alloy_contract::SolCallBuilder<T, &P, renounceOwnershipCall, N> {
5874 self.call_builder(&renounceOwnershipCall {})
5875 }
5876 pub fn symbol(&self) -> alloy_contract::SolCallBuilder<T, &P, symbolCall, N> {
5878 self.call_builder(&symbolCall {})
5879 }
5880 pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<T, &P, totalSupplyCall, N> {
5882 self.call_builder(&totalSupplyCall {})
5883 }
5884 pub fn transfer(
5886 &self,
5887 to: alloy::sol_types::private::Address,
5888 value: alloy::sol_types::private::primitives::aliases::U256,
5889 ) -> alloy_contract::SolCallBuilder<T, &P, transferCall, N> {
5890 self.call_builder(&transferCall { to, value })
5891 }
5892 pub fn transferFrom(
5894 &self,
5895 from: alloy::sol_types::private::Address,
5896 to: alloy::sol_types::private::Address,
5897 value: alloy::sol_types::private::primitives::aliases::U256,
5898 ) -> alloy_contract::SolCallBuilder<T, &P, transferFromCall, N> {
5899 self.call_builder(&transferFromCall { from, to, value })
5900 }
5901 pub fn transferOwnership(
5903 &self,
5904 newOwner: alloy::sol_types::private::Address,
5905 ) -> alloy_contract::SolCallBuilder<T, &P, transferOwnershipCall, N> {
5906 self.call_builder(&transferOwnershipCall { newOwner })
5907 }
5908 pub fn upgradeToAndCall(
5910 &self,
5911 newImplementation: alloy::sol_types::private::Address,
5912 data: alloy::sol_types::private::Bytes,
5913 ) -> alloy_contract::SolCallBuilder<T, &P, upgradeToAndCallCall, N> {
5914 self.call_builder(&upgradeToAndCallCall {
5915 newImplementation,
5916 data,
5917 })
5918 }
5919 }
5920 #[automatically_derived]
5922 impl<
5923 T: alloy_contract::private::Transport + ::core::clone::Clone,
5924 P: alloy_contract::private::Provider<T, N>,
5925 N: alloy_contract::private::Network,
5926 > EspTokenInstance<T, P, N>
5927 {
5928 pub fn event_filter<E: alloy_sol_types::SolEvent>(
5933 &self,
5934 ) -> alloy_contract::Event<T, &P, E, N> {
5935 alloy_contract::Event::new_sol(&self.provider, &self.address)
5936 }
5937 pub fn Approval_filter(&self) -> alloy_contract::Event<T, &P, Approval, N> {
5939 self.event_filter::<Approval>()
5940 }
5941 pub fn Initialized_filter(&self) -> alloy_contract::Event<T, &P, Initialized, N> {
5943 self.event_filter::<Initialized>()
5944 }
5945 pub fn OwnershipTransferred_filter(
5947 &self,
5948 ) -> alloy_contract::Event<T, &P, OwnershipTransferred, N> {
5949 self.event_filter::<OwnershipTransferred>()
5950 }
5951 pub fn Transfer_filter(&self) -> alloy_contract::Event<T, &P, Transfer, N> {
5953 self.event_filter::<Transfer>()
5954 }
5955 pub fn Upgrade_filter(&self) -> alloy_contract::Event<T, &P, Upgrade, N> {
5957 self.event_filter::<Upgrade>()
5958 }
5959 pub fn Upgraded_filter(&self) -> alloy_contract::Event<T, &P, Upgraded, N> {
5961 self.event_filter::<Upgraded>()
5962 }
5963 }
5964}