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 super::*;
650 use alloy::sol_types as alloy_sol_types;
651 #[rustfmt::skip]
657 #[allow(clippy::all)]
658 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
659 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",
660 );
661 #[rustfmt::skip]
667 #[allow(clippy::all)]
668 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
669 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",
670 );
671 #[derive(Default, Debug, PartialEq, Eq, Hash)]
672 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
677 #[derive(Clone)]
678 pub struct AddressEmptyCode {
679 #[allow(missing_docs)]
680 pub target: alloy::sol_types::private::Address,
681 }
682 #[allow(
683 non_camel_case_types,
684 non_snake_case,
685 clippy::pub_underscore_fields,
686 clippy::style
687 )]
688 const _: () = {
689 use alloy::sol_types as alloy_sol_types;
690 #[doc(hidden)]
691 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
692 #[doc(hidden)]
693 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
694 #[cfg(test)]
695 #[allow(dead_code, unreachable_patterns)]
696 fn _type_assertion(
697 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
698 ) {
699 match _t {
700 alloy_sol_types::private::AssertTypeEq::<
701 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
702 >(_) => {}
703 }
704 }
705 #[automatically_derived]
706 #[doc(hidden)]
707 impl ::core::convert::From<AddressEmptyCode> for UnderlyingRustTuple<'_> {
708 fn from(value: AddressEmptyCode) -> Self {
709 (value.target,)
710 }
711 }
712 #[automatically_derived]
713 #[doc(hidden)]
714 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressEmptyCode {
715 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
716 Self { target: tuple.0 }
717 }
718 }
719 #[automatically_derived]
720 impl alloy_sol_types::SolError for AddressEmptyCode {
721 type Parameters<'a> = UnderlyingSolTuple<'a>;
722 type Token<'a> = <Self::Parameters<
723 'a,
724 > as alloy_sol_types::SolType>::Token<'a>;
725 const SIGNATURE: &'static str = "AddressEmptyCode(address)";
726 const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8];
727 #[inline]
728 fn new<'a>(
729 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
730 ) -> Self {
731 tuple.into()
732 }
733 #[inline]
734 fn tokenize(&self) -> Self::Token<'_> {
735 (
736 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
737 &self.target,
738 ),
739 )
740 }
741 }
742 };
743 #[derive(Default, Debug, PartialEq, Eq, Hash)]
744 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
749 #[derive(Clone)]
750 pub struct ERC1967InvalidImplementation {
751 #[allow(missing_docs)]
752 pub implementation: alloy::sol_types::private::Address,
753 }
754 #[allow(
755 non_camel_case_types,
756 non_snake_case,
757 clippy::pub_underscore_fields,
758 clippy::style
759 )]
760 const _: () = {
761 use alloy::sol_types as alloy_sol_types;
762 #[doc(hidden)]
763 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
764 #[doc(hidden)]
765 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
766 #[cfg(test)]
767 #[allow(dead_code, unreachable_patterns)]
768 fn _type_assertion(
769 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
770 ) {
771 match _t {
772 alloy_sol_types::private::AssertTypeEq::<
773 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
774 >(_) => {}
775 }
776 }
777 #[automatically_derived]
778 #[doc(hidden)]
779 impl ::core::convert::From<ERC1967InvalidImplementation>
780 for UnderlyingRustTuple<'_> {
781 fn from(value: ERC1967InvalidImplementation) -> Self {
782 (value.implementation,)
783 }
784 }
785 #[automatically_derived]
786 #[doc(hidden)]
787 impl ::core::convert::From<UnderlyingRustTuple<'_>>
788 for ERC1967InvalidImplementation {
789 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
790 Self { implementation: tuple.0 }
791 }
792 }
793 #[automatically_derived]
794 impl alloy_sol_types::SolError for ERC1967InvalidImplementation {
795 type Parameters<'a> = UnderlyingSolTuple<'a>;
796 type Token<'a> = <Self::Parameters<
797 'a,
798 > as alloy_sol_types::SolType>::Token<'a>;
799 const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)";
800 const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8];
801 #[inline]
802 fn new<'a>(
803 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
804 ) -> Self {
805 tuple.into()
806 }
807 #[inline]
808 fn tokenize(&self) -> Self::Token<'_> {
809 (
810 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
811 &self.implementation,
812 ),
813 )
814 }
815 }
816 };
817 #[derive(Default, Debug, PartialEq, Eq, Hash)]
818 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
823 #[derive(Clone)]
824 pub struct ERC1967NonPayable {}
825 #[allow(
826 non_camel_case_types,
827 non_snake_case,
828 clippy::pub_underscore_fields,
829 clippy::style
830 )]
831 const _: () = {
832 use alloy::sol_types as alloy_sol_types;
833 #[doc(hidden)]
834 type UnderlyingSolTuple<'a> = ();
835 #[doc(hidden)]
836 type UnderlyingRustTuple<'a> = ();
837 #[cfg(test)]
838 #[allow(dead_code, unreachable_patterns)]
839 fn _type_assertion(
840 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
841 ) {
842 match _t {
843 alloy_sol_types::private::AssertTypeEq::<
844 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
845 >(_) => {}
846 }
847 }
848 #[automatically_derived]
849 #[doc(hidden)]
850 impl ::core::convert::From<ERC1967NonPayable> for UnderlyingRustTuple<'_> {
851 fn from(value: ERC1967NonPayable) -> Self {
852 ()
853 }
854 }
855 #[automatically_derived]
856 #[doc(hidden)]
857 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1967NonPayable {
858 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
859 Self {}
860 }
861 }
862 #[automatically_derived]
863 impl alloy_sol_types::SolError for ERC1967NonPayable {
864 type Parameters<'a> = UnderlyingSolTuple<'a>;
865 type Token<'a> = <Self::Parameters<
866 'a,
867 > as alloy_sol_types::SolType>::Token<'a>;
868 const SIGNATURE: &'static str = "ERC1967NonPayable()";
869 const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8];
870 #[inline]
871 fn new<'a>(
872 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
873 ) -> Self {
874 tuple.into()
875 }
876 #[inline]
877 fn tokenize(&self) -> Self::Token<'_> {
878 ()
879 }
880 }
881 };
882 #[derive(Default, Debug, PartialEq, Eq, Hash)]
883 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
888 #[derive(Clone)]
889 pub struct ERC20InsufficientAllowance {
890 #[allow(missing_docs)]
891 pub spender: alloy::sol_types::private::Address,
892 #[allow(missing_docs)]
893 pub allowance: alloy::sol_types::private::primitives::aliases::U256,
894 #[allow(missing_docs)]
895 pub needed: alloy::sol_types::private::primitives::aliases::U256,
896 }
897 #[allow(
898 non_camel_case_types,
899 non_snake_case,
900 clippy::pub_underscore_fields,
901 clippy::style
902 )]
903 const _: () = {
904 use alloy::sol_types as alloy_sol_types;
905 #[doc(hidden)]
906 type UnderlyingSolTuple<'a> = (
907 alloy::sol_types::sol_data::Address,
908 alloy::sol_types::sol_data::Uint<256>,
909 alloy::sol_types::sol_data::Uint<256>,
910 );
911 #[doc(hidden)]
912 type UnderlyingRustTuple<'a> = (
913 alloy::sol_types::private::Address,
914 alloy::sol_types::private::primitives::aliases::U256,
915 alloy::sol_types::private::primitives::aliases::U256,
916 );
917 #[cfg(test)]
918 #[allow(dead_code, unreachable_patterns)]
919 fn _type_assertion(
920 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
921 ) {
922 match _t {
923 alloy_sol_types::private::AssertTypeEq::<
924 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
925 >(_) => {}
926 }
927 }
928 #[automatically_derived]
929 #[doc(hidden)]
930 impl ::core::convert::From<ERC20InsufficientAllowance>
931 for UnderlyingRustTuple<'_> {
932 fn from(value: ERC20InsufficientAllowance) -> Self {
933 (value.spender, value.allowance, value.needed)
934 }
935 }
936 #[automatically_derived]
937 #[doc(hidden)]
938 impl ::core::convert::From<UnderlyingRustTuple<'_>>
939 for ERC20InsufficientAllowance {
940 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
941 Self {
942 spender: tuple.0,
943 allowance: tuple.1,
944 needed: tuple.2,
945 }
946 }
947 }
948 #[automatically_derived]
949 impl alloy_sol_types::SolError for ERC20InsufficientAllowance {
950 type Parameters<'a> = UnderlyingSolTuple<'a>;
951 type Token<'a> = <Self::Parameters<
952 'a,
953 > as alloy_sol_types::SolType>::Token<'a>;
954 const SIGNATURE: &'static str = "ERC20InsufficientAllowance(address,uint256,uint256)";
955 const SELECTOR: [u8; 4] = [251u8, 143u8, 65u8, 178u8];
956 #[inline]
957 fn new<'a>(
958 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
959 ) -> Self {
960 tuple.into()
961 }
962 #[inline]
963 fn tokenize(&self) -> Self::Token<'_> {
964 (
965 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
966 &self.spender,
967 ),
968 <alloy::sol_types::sol_data::Uint<
969 256,
970 > as alloy_sol_types::SolType>::tokenize(&self.allowance),
971 <alloy::sol_types::sol_data::Uint<
972 256,
973 > as alloy_sol_types::SolType>::tokenize(&self.needed),
974 )
975 }
976 }
977 };
978 #[derive(Default, Debug, PartialEq, Eq, Hash)]
979 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
984 #[derive(Clone)]
985 pub struct ERC20InsufficientBalance {
986 #[allow(missing_docs)]
987 pub sender: alloy::sol_types::private::Address,
988 #[allow(missing_docs)]
989 pub balance: alloy::sol_types::private::primitives::aliases::U256,
990 #[allow(missing_docs)]
991 pub needed: alloy::sol_types::private::primitives::aliases::U256,
992 }
993 #[allow(
994 non_camel_case_types,
995 non_snake_case,
996 clippy::pub_underscore_fields,
997 clippy::style
998 )]
999 const _: () = {
1000 use alloy::sol_types as alloy_sol_types;
1001 #[doc(hidden)]
1002 type UnderlyingSolTuple<'a> = (
1003 alloy::sol_types::sol_data::Address,
1004 alloy::sol_types::sol_data::Uint<256>,
1005 alloy::sol_types::sol_data::Uint<256>,
1006 );
1007 #[doc(hidden)]
1008 type UnderlyingRustTuple<'a> = (
1009 alloy::sol_types::private::Address,
1010 alloy::sol_types::private::primitives::aliases::U256,
1011 alloy::sol_types::private::primitives::aliases::U256,
1012 );
1013 #[cfg(test)]
1014 #[allow(dead_code, unreachable_patterns)]
1015 fn _type_assertion(
1016 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1017 ) {
1018 match _t {
1019 alloy_sol_types::private::AssertTypeEq::<
1020 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1021 >(_) => {}
1022 }
1023 }
1024 #[automatically_derived]
1025 #[doc(hidden)]
1026 impl ::core::convert::From<ERC20InsufficientBalance>
1027 for UnderlyingRustTuple<'_> {
1028 fn from(value: ERC20InsufficientBalance) -> Self {
1029 (value.sender, value.balance, value.needed)
1030 }
1031 }
1032 #[automatically_derived]
1033 #[doc(hidden)]
1034 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1035 for ERC20InsufficientBalance {
1036 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1037 Self {
1038 sender: tuple.0,
1039 balance: tuple.1,
1040 needed: tuple.2,
1041 }
1042 }
1043 }
1044 #[automatically_derived]
1045 impl alloy_sol_types::SolError for ERC20InsufficientBalance {
1046 type Parameters<'a> = UnderlyingSolTuple<'a>;
1047 type Token<'a> = <Self::Parameters<
1048 'a,
1049 > as alloy_sol_types::SolType>::Token<'a>;
1050 const SIGNATURE: &'static str = "ERC20InsufficientBalance(address,uint256,uint256)";
1051 const SELECTOR: [u8; 4] = [228u8, 80u8, 211u8, 140u8];
1052 #[inline]
1053 fn new<'a>(
1054 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1055 ) -> Self {
1056 tuple.into()
1057 }
1058 #[inline]
1059 fn tokenize(&self) -> Self::Token<'_> {
1060 (
1061 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1062 &self.sender,
1063 ),
1064 <alloy::sol_types::sol_data::Uint<
1065 256,
1066 > as alloy_sol_types::SolType>::tokenize(&self.balance),
1067 <alloy::sol_types::sol_data::Uint<
1068 256,
1069 > as alloy_sol_types::SolType>::tokenize(&self.needed),
1070 )
1071 }
1072 }
1073 };
1074 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1075 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1080 #[derive(Clone)]
1081 pub struct ERC20InvalidApprover {
1082 #[allow(missing_docs)]
1083 pub approver: alloy::sol_types::private::Address,
1084 }
1085 #[allow(
1086 non_camel_case_types,
1087 non_snake_case,
1088 clippy::pub_underscore_fields,
1089 clippy::style
1090 )]
1091 const _: () = {
1092 use alloy::sol_types as alloy_sol_types;
1093 #[doc(hidden)]
1094 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1095 #[doc(hidden)]
1096 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1097 #[cfg(test)]
1098 #[allow(dead_code, unreachable_patterns)]
1099 fn _type_assertion(
1100 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1101 ) {
1102 match _t {
1103 alloy_sol_types::private::AssertTypeEq::<
1104 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1105 >(_) => {}
1106 }
1107 }
1108 #[automatically_derived]
1109 #[doc(hidden)]
1110 impl ::core::convert::From<ERC20InvalidApprover> for UnderlyingRustTuple<'_> {
1111 fn from(value: ERC20InvalidApprover) -> Self {
1112 (value.approver,)
1113 }
1114 }
1115 #[automatically_derived]
1116 #[doc(hidden)]
1117 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidApprover {
1118 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1119 Self { approver: tuple.0 }
1120 }
1121 }
1122 #[automatically_derived]
1123 impl alloy_sol_types::SolError for ERC20InvalidApprover {
1124 type Parameters<'a> = UnderlyingSolTuple<'a>;
1125 type Token<'a> = <Self::Parameters<
1126 'a,
1127 > as alloy_sol_types::SolType>::Token<'a>;
1128 const SIGNATURE: &'static str = "ERC20InvalidApprover(address)";
1129 const SELECTOR: [u8; 4] = [230u8, 2u8, 223u8, 5u8];
1130 #[inline]
1131 fn new<'a>(
1132 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1133 ) -> Self {
1134 tuple.into()
1135 }
1136 #[inline]
1137 fn tokenize(&self) -> Self::Token<'_> {
1138 (
1139 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1140 &self.approver,
1141 ),
1142 )
1143 }
1144 }
1145 };
1146 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1147 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1152 #[derive(Clone)]
1153 pub struct ERC20InvalidReceiver {
1154 #[allow(missing_docs)]
1155 pub receiver: alloy::sol_types::private::Address,
1156 }
1157 #[allow(
1158 non_camel_case_types,
1159 non_snake_case,
1160 clippy::pub_underscore_fields,
1161 clippy::style
1162 )]
1163 const _: () = {
1164 use alloy::sol_types as alloy_sol_types;
1165 #[doc(hidden)]
1166 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1167 #[doc(hidden)]
1168 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1169 #[cfg(test)]
1170 #[allow(dead_code, unreachable_patterns)]
1171 fn _type_assertion(
1172 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1173 ) {
1174 match _t {
1175 alloy_sol_types::private::AssertTypeEq::<
1176 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1177 >(_) => {}
1178 }
1179 }
1180 #[automatically_derived]
1181 #[doc(hidden)]
1182 impl ::core::convert::From<ERC20InvalidReceiver> for UnderlyingRustTuple<'_> {
1183 fn from(value: ERC20InvalidReceiver) -> Self {
1184 (value.receiver,)
1185 }
1186 }
1187 #[automatically_derived]
1188 #[doc(hidden)]
1189 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidReceiver {
1190 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1191 Self { receiver: tuple.0 }
1192 }
1193 }
1194 #[automatically_derived]
1195 impl alloy_sol_types::SolError for ERC20InvalidReceiver {
1196 type Parameters<'a> = UnderlyingSolTuple<'a>;
1197 type Token<'a> = <Self::Parameters<
1198 'a,
1199 > as alloy_sol_types::SolType>::Token<'a>;
1200 const SIGNATURE: &'static str = "ERC20InvalidReceiver(address)";
1201 const SELECTOR: [u8; 4] = [236u8, 68u8, 47u8, 5u8];
1202 #[inline]
1203 fn new<'a>(
1204 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1205 ) -> Self {
1206 tuple.into()
1207 }
1208 #[inline]
1209 fn tokenize(&self) -> Self::Token<'_> {
1210 (
1211 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1212 &self.receiver,
1213 ),
1214 )
1215 }
1216 }
1217 };
1218 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1219 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1224 #[derive(Clone)]
1225 pub struct ERC20InvalidSender {
1226 #[allow(missing_docs)]
1227 pub sender: alloy::sol_types::private::Address,
1228 }
1229 #[allow(
1230 non_camel_case_types,
1231 non_snake_case,
1232 clippy::pub_underscore_fields,
1233 clippy::style
1234 )]
1235 const _: () = {
1236 use alloy::sol_types as alloy_sol_types;
1237 #[doc(hidden)]
1238 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1239 #[doc(hidden)]
1240 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1241 #[cfg(test)]
1242 #[allow(dead_code, unreachable_patterns)]
1243 fn _type_assertion(
1244 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1245 ) {
1246 match _t {
1247 alloy_sol_types::private::AssertTypeEq::<
1248 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1249 >(_) => {}
1250 }
1251 }
1252 #[automatically_derived]
1253 #[doc(hidden)]
1254 impl ::core::convert::From<ERC20InvalidSender> for UnderlyingRustTuple<'_> {
1255 fn from(value: ERC20InvalidSender) -> Self {
1256 (value.sender,)
1257 }
1258 }
1259 #[automatically_derived]
1260 #[doc(hidden)]
1261 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidSender {
1262 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1263 Self { sender: tuple.0 }
1264 }
1265 }
1266 #[automatically_derived]
1267 impl alloy_sol_types::SolError for ERC20InvalidSender {
1268 type Parameters<'a> = UnderlyingSolTuple<'a>;
1269 type Token<'a> = <Self::Parameters<
1270 'a,
1271 > as alloy_sol_types::SolType>::Token<'a>;
1272 const SIGNATURE: &'static str = "ERC20InvalidSender(address)";
1273 const SELECTOR: [u8; 4] = [150u8, 198u8, 253u8, 30u8];
1274 #[inline]
1275 fn new<'a>(
1276 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1277 ) -> Self {
1278 tuple.into()
1279 }
1280 #[inline]
1281 fn tokenize(&self) -> Self::Token<'_> {
1282 (
1283 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1284 &self.sender,
1285 ),
1286 )
1287 }
1288 }
1289 };
1290 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1291 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1296 #[derive(Clone)]
1297 pub struct ERC20InvalidSpender {
1298 #[allow(missing_docs)]
1299 pub spender: alloy::sol_types::private::Address,
1300 }
1301 #[allow(
1302 non_camel_case_types,
1303 non_snake_case,
1304 clippy::pub_underscore_fields,
1305 clippy::style
1306 )]
1307 const _: () = {
1308 use alloy::sol_types as alloy_sol_types;
1309 #[doc(hidden)]
1310 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1311 #[doc(hidden)]
1312 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1313 #[cfg(test)]
1314 #[allow(dead_code, unreachable_patterns)]
1315 fn _type_assertion(
1316 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1317 ) {
1318 match _t {
1319 alloy_sol_types::private::AssertTypeEq::<
1320 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1321 >(_) => {}
1322 }
1323 }
1324 #[automatically_derived]
1325 #[doc(hidden)]
1326 impl ::core::convert::From<ERC20InvalidSpender> for UnderlyingRustTuple<'_> {
1327 fn from(value: ERC20InvalidSpender) -> Self {
1328 (value.spender,)
1329 }
1330 }
1331 #[automatically_derived]
1332 #[doc(hidden)]
1333 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidSpender {
1334 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1335 Self { spender: tuple.0 }
1336 }
1337 }
1338 #[automatically_derived]
1339 impl alloy_sol_types::SolError for ERC20InvalidSpender {
1340 type Parameters<'a> = UnderlyingSolTuple<'a>;
1341 type Token<'a> = <Self::Parameters<
1342 'a,
1343 > as alloy_sol_types::SolType>::Token<'a>;
1344 const SIGNATURE: &'static str = "ERC20InvalidSpender(address)";
1345 const SELECTOR: [u8; 4] = [148u8, 40u8, 13u8, 98u8];
1346 #[inline]
1347 fn new<'a>(
1348 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1349 ) -> Self {
1350 tuple.into()
1351 }
1352 #[inline]
1353 fn tokenize(&self) -> Self::Token<'_> {
1354 (
1355 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1356 &self.spender,
1357 ),
1358 )
1359 }
1360 }
1361 };
1362 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1363 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1368 #[derive(Clone)]
1369 pub struct FailedInnerCall {}
1370 #[allow(
1371 non_camel_case_types,
1372 non_snake_case,
1373 clippy::pub_underscore_fields,
1374 clippy::style
1375 )]
1376 const _: () = {
1377 use alloy::sol_types as alloy_sol_types;
1378 #[doc(hidden)]
1379 type UnderlyingSolTuple<'a> = ();
1380 #[doc(hidden)]
1381 type UnderlyingRustTuple<'a> = ();
1382 #[cfg(test)]
1383 #[allow(dead_code, unreachable_patterns)]
1384 fn _type_assertion(
1385 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1386 ) {
1387 match _t {
1388 alloy_sol_types::private::AssertTypeEq::<
1389 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1390 >(_) => {}
1391 }
1392 }
1393 #[automatically_derived]
1394 #[doc(hidden)]
1395 impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
1396 fn from(value: FailedInnerCall) -> Self {
1397 ()
1398 }
1399 }
1400 #[automatically_derived]
1401 #[doc(hidden)]
1402 impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
1403 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1404 Self {}
1405 }
1406 }
1407 #[automatically_derived]
1408 impl alloy_sol_types::SolError for FailedInnerCall {
1409 type Parameters<'a> = UnderlyingSolTuple<'a>;
1410 type Token<'a> = <Self::Parameters<
1411 'a,
1412 > as alloy_sol_types::SolType>::Token<'a>;
1413 const SIGNATURE: &'static str = "FailedInnerCall()";
1414 const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
1415 #[inline]
1416 fn new<'a>(
1417 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1418 ) -> Self {
1419 tuple.into()
1420 }
1421 #[inline]
1422 fn tokenize(&self) -> Self::Token<'_> {
1423 ()
1424 }
1425 }
1426 };
1427 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1428 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1433 #[derive(Clone)]
1434 pub struct InvalidInitialization {}
1435 #[allow(
1436 non_camel_case_types,
1437 non_snake_case,
1438 clippy::pub_underscore_fields,
1439 clippy::style
1440 )]
1441 const _: () = {
1442 use alloy::sol_types as alloy_sol_types;
1443 #[doc(hidden)]
1444 type UnderlyingSolTuple<'a> = ();
1445 #[doc(hidden)]
1446 type UnderlyingRustTuple<'a> = ();
1447 #[cfg(test)]
1448 #[allow(dead_code, unreachable_patterns)]
1449 fn _type_assertion(
1450 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1451 ) {
1452 match _t {
1453 alloy_sol_types::private::AssertTypeEq::<
1454 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1455 >(_) => {}
1456 }
1457 }
1458 #[automatically_derived]
1459 #[doc(hidden)]
1460 impl ::core::convert::From<InvalidInitialization> for UnderlyingRustTuple<'_> {
1461 fn from(value: InvalidInitialization) -> Self {
1462 ()
1463 }
1464 }
1465 #[automatically_derived]
1466 #[doc(hidden)]
1467 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInitialization {
1468 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1469 Self {}
1470 }
1471 }
1472 #[automatically_derived]
1473 impl alloy_sol_types::SolError for InvalidInitialization {
1474 type Parameters<'a> = UnderlyingSolTuple<'a>;
1475 type Token<'a> = <Self::Parameters<
1476 'a,
1477 > as alloy_sol_types::SolType>::Token<'a>;
1478 const SIGNATURE: &'static str = "InvalidInitialization()";
1479 const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8];
1480 #[inline]
1481 fn new<'a>(
1482 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1483 ) -> Self {
1484 tuple.into()
1485 }
1486 #[inline]
1487 fn tokenize(&self) -> Self::Token<'_> {
1488 ()
1489 }
1490 }
1491 };
1492 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1493 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1498 #[derive(Clone)]
1499 pub struct NotInitializing {}
1500 #[allow(
1501 non_camel_case_types,
1502 non_snake_case,
1503 clippy::pub_underscore_fields,
1504 clippy::style
1505 )]
1506 const _: () = {
1507 use alloy::sol_types as alloy_sol_types;
1508 #[doc(hidden)]
1509 type UnderlyingSolTuple<'a> = ();
1510 #[doc(hidden)]
1511 type UnderlyingRustTuple<'a> = ();
1512 #[cfg(test)]
1513 #[allow(dead_code, unreachable_patterns)]
1514 fn _type_assertion(
1515 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1516 ) {
1517 match _t {
1518 alloy_sol_types::private::AssertTypeEq::<
1519 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1520 >(_) => {}
1521 }
1522 }
1523 #[automatically_derived]
1524 #[doc(hidden)]
1525 impl ::core::convert::From<NotInitializing> for UnderlyingRustTuple<'_> {
1526 fn from(value: NotInitializing) -> Self {
1527 ()
1528 }
1529 }
1530 #[automatically_derived]
1531 #[doc(hidden)]
1532 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotInitializing {
1533 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1534 Self {}
1535 }
1536 }
1537 #[automatically_derived]
1538 impl alloy_sol_types::SolError for NotInitializing {
1539 type Parameters<'a> = UnderlyingSolTuple<'a>;
1540 type Token<'a> = <Self::Parameters<
1541 'a,
1542 > as alloy_sol_types::SolType>::Token<'a>;
1543 const SIGNATURE: &'static str = "NotInitializing()";
1544 const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8];
1545 #[inline]
1546 fn new<'a>(
1547 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1548 ) -> Self {
1549 tuple.into()
1550 }
1551 #[inline]
1552 fn tokenize(&self) -> Self::Token<'_> {
1553 ()
1554 }
1555 }
1556 };
1557 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1558 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1563 #[derive(Clone)]
1564 pub struct OwnableInvalidOwner {
1565 #[allow(missing_docs)]
1566 pub owner: alloy::sol_types::private::Address,
1567 }
1568 #[allow(
1569 non_camel_case_types,
1570 non_snake_case,
1571 clippy::pub_underscore_fields,
1572 clippy::style
1573 )]
1574 const _: () = {
1575 use alloy::sol_types as alloy_sol_types;
1576 #[doc(hidden)]
1577 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1578 #[doc(hidden)]
1579 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1580 #[cfg(test)]
1581 #[allow(dead_code, unreachable_patterns)]
1582 fn _type_assertion(
1583 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1584 ) {
1585 match _t {
1586 alloy_sol_types::private::AssertTypeEq::<
1587 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1588 >(_) => {}
1589 }
1590 }
1591 #[automatically_derived]
1592 #[doc(hidden)]
1593 impl ::core::convert::From<OwnableInvalidOwner> for UnderlyingRustTuple<'_> {
1594 fn from(value: OwnableInvalidOwner) -> Self {
1595 (value.owner,)
1596 }
1597 }
1598 #[automatically_derived]
1599 #[doc(hidden)]
1600 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableInvalidOwner {
1601 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1602 Self { owner: tuple.0 }
1603 }
1604 }
1605 #[automatically_derived]
1606 impl alloy_sol_types::SolError for OwnableInvalidOwner {
1607 type Parameters<'a> = UnderlyingSolTuple<'a>;
1608 type Token<'a> = <Self::Parameters<
1609 'a,
1610 > as alloy_sol_types::SolType>::Token<'a>;
1611 const SIGNATURE: &'static str = "OwnableInvalidOwner(address)";
1612 const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8];
1613 #[inline]
1614 fn new<'a>(
1615 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1616 ) -> Self {
1617 tuple.into()
1618 }
1619 #[inline]
1620 fn tokenize(&self) -> Self::Token<'_> {
1621 (
1622 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1623 &self.owner,
1624 ),
1625 )
1626 }
1627 }
1628 };
1629 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1630 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1635 #[derive(Clone)]
1636 pub struct OwnableUnauthorizedAccount {
1637 #[allow(missing_docs)]
1638 pub account: alloy::sol_types::private::Address,
1639 }
1640 #[allow(
1641 non_camel_case_types,
1642 non_snake_case,
1643 clippy::pub_underscore_fields,
1644 clippy::style
1645 )]
1646 const _: () = {
1647 use alloy::sol_types as alloy_sol_types;
1648 #[doc(hidden)]
1649 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1650 #[doc(hidden)]
1651 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1652 #[cfg(test)]
1653 #[allow(dead_code, unreachable_patterns)]
1654 fn _type_assertion(
1655 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1656 ) {
1657 match _t {
1658 alloy_sol_types::private::AssertTypeEq::<
1659 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1660 >(_) => {}
1661 }
1662 }
1663 #[automatically_derived]
1664 #[doc(hidden)]
1665 impl ::core::convert::From<OwnableUnauthorizedAccount>
1666 for UnderlyingRustTuple<'_> {
1667 fn from(value: OwnableUnauthorizedAccount) -> Self {
1668 (value.account,)
1669 }
1670 }
1671 #[automatically_derived]
1672 #[doc(hidden)]
1673 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1674 for OwnableUnauthorizedAccount {
1675 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1676 Self { account: tuple.0 }
1677 }
1678 }
1679 #[automatically_derived]
1680 impl alloy_sol_types::SolError for OwnableUnauthorizedAccount {
1681 type Parameters<'a> = UnderlyingSolTuple<'a>;
1682 type Token<'a> = <Self::Parameters<
1683 'a,
1684 > as alloy_sol_types::SolType>::Token<'a>;
1685 const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)";
1686 const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8];
1687 #[inline]
1688 fn new<'a>(
1689 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1690 ) -> Self {
1691 tuple.into()
1692 }
1693 #[inline]
1694 fn tokenize(&self) -> Self::Token<'_> {
1695 (
1696 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1697 &self.account,
1698 ),
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 UUPSUnauthorizedCallContext {}
1711 #[allow(
1712 non_camel_case_types,
1713 non_snake_case,
1714 clippy::pub_underscore_fields,
1715 clippy::style
1716 )]
1717 const _: () = {
1718 use alloy::sol_types as alloy_sol_types;
1719 #[doc(hidden)]
1720 type UnderlyingSolTuple<'a> = ();
1721 #[doc(hidden)]
1722 type UnderlyingRustTuple<'a> = ();
1723 #[cfg(test)]
1724 #[allow(dead_code, unreachable_patterns)]
1725 fn _type_assertion(
1726 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1727 ) {
1728 match _t {
1729 alloy_sol_types::private::AssertTypeEq::<
1730 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1731 >(_) => {}
1732 }
1733 }
1734 #[automatically_derived]
1735 #[doc(hidden)]
1736 impl ::core::convert::From<UUPSUnauthorizedCallContext>
1737 for UnderlyingRustTuple<'_> {
1738 fn from(value: UUPSUnauthorizedCallContext) -> Self {
1739 ()
1740 }
1741 }
1742 #[automatically_derived]
1743 #[doc(hidden)]
1744 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1745 for UUPSUnauthorizedCallContext {
1746 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1747 Self {}
1748 }
1749 }
1750 #[automatically_derived]
1751 impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext {
1752 type Parameters<'a> = UnderlyingSolTuple<'a>;
1753 type Token<'a> = <Self::Parameters<
1754 'a,
1755 > as alloy_sol_types::SolType>::Token<'a>;
1756 const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()";
1757 const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8];
1758 #[inline]
1759 fn new<'a>(
1760 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1761 ) -> Self {
1762 tuple.into()
1763 }
1764 #[inline]
1765 fn tokenize(&self) -> Self::Token<'_> {
1766 ()
1767 }
1768 }
1769 };
1770 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1771 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1776 #[derive(Clone)]
1777 pub struct UUPSUnsupportedProxiableUUID {
1778 #[allow(missing_docs)]
1779 pub slot: alloy::sol_types::private::FixedBytes<32>,
1780 }
1781 #[allow(
1782 non_camel_case_types,
1783 non_snake_case,
1784 clippy::pub_underscore_fields,
1785 clippy::style
1786 )]
1787 const _: () = {
1788 use alloy::sol_types as alloy_sol_types;
1789 #[doc(hidden)]
1790 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1791 #[doc(hidden)]
1792 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1793 #[cfg(test)]
1794 #[allow(dead_code, unreachable_patterns)]
1795 fn _type_assertion(
1796 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1797 ) {
1798 match _t {
1799 alloy_sol_types::private::AssertTypeEq::<
1800 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1801 >(_) => {}
1802 }
1803 }
1804 #[automatically_derived]
1805 #[doc(hidden)]
1806 impl ::core::convert::From<UUPSUnsupportedProxiableUUID>
1807 for UnderlyingRustTuple<'_> {
1808 fn from(value: UUPSUnsupportedProxiableUUID) -> Self {
1809 (value.slot,)
1810 }
1811 }
1812 #[automatically_derived]
1813 #[doc(hidden)]
1814 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1815 for UUPSUnsupportedProxiableUUID {
1816 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1817 Self { slot: tuple.0 }
1818 }
1819 }
1820 #[automatically_derived]
1821 impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID {
1822 type Parameters<'a> = UnderlyingSolTuple<'a>;
1823 type Token<'a> = <Self::Parameters<
1824 'a,
1825 > as alloy_sol_types::SolType>::Token<'a>;
1826 const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)";
1827 const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8];
1828 #[inline]
1829 fn new<'a>(
1830 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1831 ) -> Self {
1832 tuple.into()
1833 }
1834 #[inline]
1835 fn tokenize(&self) -> Self::Token<'_> {
1836 (
1837 <alloy::sol_types::sol_data::FixedBytes<
1838 32,
1839 > as alloy_sol_types::SolType>::tokenize(&self.slot),
1840 )
1841 }
1842 }
1843 };
1844 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1845 #[allow(
1850 non_camel_case_types,
1851 non_snake_case,
1852 clippy::pub_underscore_fields,
1853 clippy::style
1854 )]
1855 #[derive(Clone)]
1856 pub struct Approval {
1857 #[allow(missing_docs)]
1858 pub owner: alloy::sol_types::private::Address,
1859 #[allow(missing_docs)]
1860 pub spender: alloy::sol_types::private::Address,
1861 #[allow(missing_docs)]
1862 pub value: alloy::sol_types::private::primitives::aliases::U256,
1863 }
1864 #[allow(
1865 non_camel_case_types,
1866 non_snake_case,
1867 clippy::pub_underscore_fields,
1868 clippy::style
1869 )]
1870 const _: () = {
1871 use alloy::sol_types as alloy_sol_types;
1872 #[automatically_derived]
1873 impl alloy_sol_types::SolEvent for Approval {
1874 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1875 type DataToken<'a> = <Self::DataTuple<
1876 'a,
1877 > as alloy_sol_types::SolType>::Token<'a>;
1878 type TopicList = (
1879 alloy_sol_types::sol_data::FixedBytes<32>,
1880 alloy::sol_types::sol_data::Address,
1881 alloy::sol_types::sol_data::Address,
1882 );
1883 const SIGNATURE: &'static str = "Approval(address,address,uint256)";
1884 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1885 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8,
1886 66u8, 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8,
1887 41u8, 30u8, 91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
1888 ]);
1889 const ANONYMOUS: bool = false;
1890 #[allow(unused_variables)]
1891 #[inline]
1892 fn new(
1893 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1894 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1895 ) -> Self {
1896 Self {
1897 owner: topics.1,
1898 spender: topics.2,
1899 value: data.0,
1900 }
1901 }
1902 #[inline]
1903 fn check_signature(
1904 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1905 ) -> alloy_sol_types::Result<()> {
1906 if topics.0 != Self::SIGNATURE_HASH {
1907 return Err(
1908 alloy_sol_types::Error::invalid_event_signature_hash(
1909 Self::SIGNATURE,
1910 topics.0,
1911 Self::SIGNATURE_HASH,
1912 ),
1913 );
1914 }
1915 Ok(())
1916 }
1917 #[inline]
1918 fn tokenize_body(&self) -> Self::DataToken<'_> {
1919 (
1920 <alloy::sol_types::sol_data::Uint<
1921 256,
1922 > as alloy_sol_types::SolType>::tokenize(&self.value),
1923 )
1924 }
1925 #[inline]
1926 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1927 (Self::SIGNATURE_HASH.into(), self.owner.clone(), self.spender.clone())
1928 }
1929 #[inline]
1930 fn encode_topics_raw(
1931 &self,
1932 out: &mut [alloy_sol_types::abi::token::WordToken],
1933 ) -> alloy_sol_types::Result<()> {
1934 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1935 return Err(alloy_sol_types::Error::Overrun);
1936 }
1937 out[0usize] = alloy_sol_types::abi::token::WordToken(
1938 Self::SIGNATURE_HASH,
1939 );
1940 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1941 &self.owner,
1942 );
1943 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1944 &self.spender,
1945 );
1946 Ok(())
1947 }
1948 }
1949 #[automatically_derived]
1950 impl alloy_sol_types::private::IntoLogData for Approval {
1951 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1952 From::from(self)
1953 }
1954 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1955 From::from(&self)
1956 }
1957 }
1958 #[automatically_derived]
1959 impl From<&Approval> for alloy_sol_types::private::LogData {
1960 #[inline]
1961 fn from(this: &Approval) -> alloy_sol_types::private::LogData {
1962 alloy_sol_types::SolEvent::encode_log_data(this)
1963 }
1964 }
1965 };
1966 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1967 #[allow(
1972 non_camel_case_types,
1973 non_snake_case,
1974 clippy::pub_underscore_fields,
1975 clippy::style
1976 )]
1977 #[derive(Clone)]
1978 pub struct Initialized {
1979 #[allow(missing_docs)]
1980 pub version: u64,
1981 }
1982 #[allow(
1983 non_camel_case_types,
1984 non_snake_case,
1985 clippy::pub_underscore_fields,
1986 clippy::style
1987 )]
1988 const _: () = {
1989 use alloy::sol_types as alloy_sol_types;
1990 #[automatically_derived]
1991 impl alloy_sol_types::SolEvent for Initialized {
1992 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
1993 type DataToken<'a> = <Self::DataTuple<
1994 'a,
1995 > as alloy_sol_types::SolType>::Token<'a>;
1996 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1997 const SIGNATURE: &'static str = "Initialized(uint64)";
1998 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1999 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
2000 19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
2001 33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
2002 ]);
2003 const ANONYMOUS: bool = false;
2004 #[allow(unused_variables)]
2005 #[inline]
2006 fn new(
2007 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2008 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2009 ) -> Self {
2010 Self { version: data.0 }
2011 }
2012 #[inline]
2013 fn check_signature(
2014 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2015 ) -> alloy_sol_types::Result<()> {
2016 if topics.0 != Self::SIGNATURE_HASH {
2017 return Err(
2018 alloy_sol_types::Error::invalid_event_signature_hash(
2019 Self::SIGNATURE,
2020 topics.0,
2021 Self::SIGNATURE_HASH,
2022 ),
2023 );
2024 }
2025 Ok(())
2026 }
2027 #[inline]
2028 fn tokenize_body(&self) -> Self::DataToken<'_> {
2029 (
2030 <alloy::sol_types::sol_data::Uint<
2031 64,
2032 > as alloy_sol_types::SolType>::tokenize(&self.version),
2033 )
2034 }
2035 #[inline]
2036 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2037 (Self::SIGNATURE_HASH.into(),)
2038 }
2039 #[inline]
2040 fn encode_topics_raw(
2041 &self,
2042 out: &mut [alloy_sol_types::abi::token::WordToken],
2043 ) -> alloy_sol_types::Result<()> {
2044 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2045 return Err(alloy_sol_types::Error::Overrun);
2046 }
2047 out[0usize] = alloy_sol_types::abi::token::WordToken(
2048 Self::SIGNATURE_HASH,
2049 );
2050 Ok(())
2051 }
2052 }
2053 #[automatically_derived]
2054 impl alloy_sol_types::private::IntoLogData for Initialized {
2055 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2056 From::from(self)
2057 }
2058 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2059 From::from(&self)
2060 }
2061 }
2062 #[automatically_derived]
2063 impl From<&Initialized> for alloy_sol_types::private::LogData {
2064 #[inline]
2065 fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
2066 alloy_sol_types::SolEvent::encode_log_data(this)
2067 }
2068 }
2069 };
2070 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2071 #[allow(
2076 non_camel_case_types,
2077 non_snake_case,
2078 clippy::pub_underscore_fields,
2079 clippy::style
2080 )]
2081 #[derive(Clone)]
2082 pub struct OwnershipTransferred {
2083 #[allow(missing_docs)]
2084 pub previousOwner: alloy::sol_types::private::Address,
2085 #[allow(missing_docs)]
2086 pub newOwner: alloy::sol_types::private::Address,
2087 }
2088 #[allow(
2089 non_camel_case_types,
2090 non_snake_case,
2091 clippy::pub_underscore_fields,
2092 clippy::style
2093 )]
2094 const _: () = {
2095 use alloy::sol_types as alloy_sol_types;
2096 #[automatically_derived]
2097 impl alloy_sol_types::SolEvent for OwnershipTransferred {
2098 type DataTuple<'a> = ();
2099 type DataToken<'a> = <Self::DataTuple<
2100 'a,
2101 > as alloy_sol_types::SolType>::Token<'a>;
2102 type TopicList = (
2103 alloy_sol_types::sol_data::FixedBytes<32>,
2104 alloy::sol_types::sol_data::Address,
2105 alloy::sol_types::sol_data::Address,
2106 );
2107 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
2108 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2109 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
2110 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
2111 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
2112 ]);
2113 const ANONYMOUS: bool = false;
2114 #[allow(unused_variables)]
2115 #[inline]
2116 fn new(
2117 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2118 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2119 ) -> Self {
2120 Self {
2121 previousOwner: topics.1,
2122 newOwner: topics.2,
2123 }
2124 }
2125 #[inline]
2126 fn check_signature(
2127 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2128 ) -> alloy_sol_types::Result<()> {
2129 if topics.0 != Self::SIGNATURE_HASH {
2130 return Err(
2131 alloy_sol_types::Error::invalid_event_signature_hash(
2132 Self::SIGNATURE,
2133 topics.0,
2134 Self::SIGNATURE_HASH,
2135 ),
2136 );
2137 }
2138 Ok(())
2139 }
2140 #[inline]
2141 fn tokenize_body(&self) -> Self::DataToken<'_> {
2142 ()
2143 }
2144 #[inline]
2145 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2146 (
2147 Self::SIGNATURE_HASH.into(),
2148 self.previousOwner.clone(),
2149 self.newOwner.clone(),
2150 )
2151 }
2152 #[inline]
2153 fn encode_topics_raw(
2154 &self,
2155 out: &mut [alloy_sol_types::abi::token::WordToken],
2156 ) -> alloy_sol_types::Result<()> {
2157 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2158 return Err(alloy_sol_types::Error::Overrun);
2159 }
2160 out[0usize] = alloy_sol_types::abi::token::WordToken(
2161 Self::SIGNATURE_HASH,
2162 );
2163 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2164 &self.previousOwner,
2165 );
2166 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2167 &self.newOwner,
2168 );
2169 Ok(())
2170 }
2171 }
2172 #[automatically_derived]
2173 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
2174 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2175 From::from(self)
2176 }
2177 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2178 From::from(&self)
2179 }
2180 }
2181 #[automatically_derived]
2182 impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
2183 #[inline]
2184 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
2185 alloy_sol_types::SolEvent::encode_log_data(this)
2186 }
2187 }
2188 };
2189 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2190 #[allow(
2195 non_camel_case_types,
2196 non_snake_case,
2197 clippy::pub_underscore_fields,
2198 clippy::style
2199 )]
2200 #[derive(Clone)]
2201 pub struct Transfer {
2202 #[allow(missing_docs)]
2203 pub from: alloy::sol_types::private::Address,
2204 #[allow(missing_docs)]
2205 pub to: alloy::sol_types::private::Address,
2206 #[allow(missing_docs)]
2207 pub value: alloy::sol_types::private::primitives::aliases::U256,
2208 }
2209 #[allow(
2210 non_camel_case_types,
2211 non_snake_case,
2212 clippy::pub_underscore_fields,
2213 clippy::style
2214 )]
2215 const _: () = {
2216 use alloy::sol_types as alloy_sol_types;
2217 #[automatically_derived]
2218 impl alloy_sol_types::SolEvent for Transfer {
2219 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2220 type DataToken<'a> = <Self::DataTuple<
2221 'a,
2222 > as alloy_sol_types::SolType>::Token<'a>;
2223 type TopicList = (
2224 alloy_sol_types::sol_data::FixedBytes<32>,
2225 alloy::sol_types::sol_data::Address,
2226 alloy::sol_types::sol_data::Address,
2227 );
2228 const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
2229 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2230 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8,
2231 176u8, 104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8,
2232 196u8, 161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
2233 ]);
2234 const ANONYMOUS: bool = false;
2235 #[allow(unused_variables)]
2236 #[inline]
2237 fn new(
2238 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2239 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2240 ) -> Self {
2241 Self {
2242 from: topics.1,
2243 to: topics.2,
2244 value: data.0,
2245 }
2246 }
2247 #[inline]
2248 fn check_signature(
2249 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2250 ) -> alloy_sol_types::Result<()> {
2251 if topics.0 != Self::SIGNATURE_HASH {
2252 return Err(
2253 alloy_sol_types::Error::invalid_event_signature_hash(
2254 Self::SIGNATURE,
2255 topics.0,
2256 Self::SIGNATURE_HASH,
2257 ),
2258 );
2259 }
2260 Ok(())
2261 }
2262 #[inline]
2263 fn tokenize_body(&self) -> Self::DataToken<'_> {
2264 (
2265 <alloy::sol_types::sol_data::Uint<
2266 256,
2267 > as alloy_sol_types::SolType>::tokenize(&self.value),
2268 )
2269 }
2270 #[inline]
2271 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2272 (Self::SIGNATURE_HASH.into(), self.from.clone(), self.to.clone())
2273 }
2274 #[inline]
2275 fn encode_topics_raw(
2276 &self,
2277 out: &mut [alloy_sol_types::abi::token::WordToken],
2278 ) -> alloy_sol_types::Result<()> {
2279 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2280 return Err(alloy_sol_types::Error::Overrun);
2281 }
2282 out[0usize] = alloy_sol_types::abi::token::WordToken(
2283 Self::SIGNATURE_HASH,
2284 );
2285 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2286 &self.from,
2287 );
2288 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2289 &self.to,
2290 );
2291 Ok(())
2292 }
2293 }
2294 #[automatically_derived]
2295 impl alloy_sol_types::private::IntoLogData for Transfer {
2296 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2297 From::from(self)
2298 }
2299 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2300 From::from(&self)
2301 }
2302 }
2303 #[automatically_derived]
2304 impl From<&Transfer> for alloy_sol_types::private::LogData {
2305 #[inline]
2306 fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
2307 alloy_sol_types::SolEvent::encode_log_data(this)
2308 }
2309 }
2310 };
2311 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2312 #[allow(
2317 non_camel_case_types,
2318 non_snake_case,
2319 clippy::pub_underscore_fields,
2320 clippy::style
2321 )]
2322 #[derive(Clone)]
2323 pub struct Upgrade {
2324 #[allow(missing_docs)]
2325 pub implementation: alloy::sol_types::private::Address,
2326 }
2327 #[allow(
2328 non_camel_case_types,
2329 non_snake_case,
2330 clippy::pub_underscore_fields,
2331 clippy::style
2332 )]
2333 const _: () = {
2334 use alloy::sol_types as alloy_sol_types;
2335 #[automatically_derived]
2336 impl alloy_sol_types::SolEvent for Upgrade {
2337 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
2338 type DataToken<'a> = <Self::DataTuple<
2339 'a,
2340 > as alloy_sol_types::SolType>::Token<'a>;
2341 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
2342 const SIGNATURE: &'static str = "Upgrade(address)";
2343 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2344 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8,
2345 154u8, 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8,
2346 185u8, 62u8, 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
2347 ]);
2348 const ANONYMOUS: bool = false;
2349 #[allow(unused_variables)]
2350 #[inline]
2351 fn new(
2352 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2353 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2354 ) -> Self {
2355 Self { implementation: data.0 }
2356 }
2357 #[inline]
2358 fn check_signature(
2359 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2360 ) -> alloy_sol_types::Result<()> {
2361 if topics.0 != Self::SIGNATURE_HASH {
2362 return Err(
2363 alloy_sol_types::Error::invalid_event_signature_hash(
2364 Self::SIGNATURE,
2365 topics.0,
2366 Self::SIGNATURE_HASH,
2367 ),
2368 );
2369 }
2370 Ok(())
2371 }
2372 #[inline]
2373 fn tokenize_body(&self) -> Self::DataToken<'_> {
2374 (
2375 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2376 &self.implementation,
2377 ),
2378 )
2379 }
2380 #[inline]
2381 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2382 (Self::SIGNATURE_HASH.into(),)
2383 }
2384 #[inline]
2385 fn encode_topics_raw(
2386 &self,
2387 out: &mut [alloy_sol_types::abi::token::WordToken],
2388 ) -> alloy_sol_types::Result<()> {
2389 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2390 return Err(alloy_sol_types::Error::Overrun);
2391 }
2392 out[0usize] = alloy_sol_types::abi::token::WordToken(
2393 Self::SIGNATURE_HASH,
2394 );
2395 Ok(())
2396 }
2397 }
2398 #[automatically_derived]
2399 impl alloy_sol_types::private::IntoLogData for Upgrade {
2400 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2401 From::from(self)
2402 }
2403 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2404 From::from(&self)
2405 }
2406 }
2407 #[automatically_derived]
2408 impl From<&Upgrade> for alloy_sol_types::private::LogData {
2409 #[inline]
2410 fn from(this: &Upgrade) -> alloy_sol_types::private::LogData {
2411 alloy_sol_types::SolEvent::encode_log_data(this)
2412 }
2413 }
2414 };
2415 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2416 #[allow(
2421 non_camel_case_types,
2422 non_snake_case,
2423 clippy::pub_underscore_fields,
2424 clippy::style
2425 )]
2426 #[derive(Clone)]
2427 pub struct Upgraded {
2428 #[allow(missing_docs)]
2429 pub implementation: alloy::sol_types::private::Address,
2430 }
2431 #[allow(
2432 non_camel_case_types,
2433 non_snake_case,
2434 clippy::pub_underscore_fields,
2435 clippy::style
2436 )]
2437 const _: () = {
2438 use alloy::sol_types as alloy_sol_types;
2439 #[automatically_derived]
2440 impl alloy_sol_types::SolEvent for Upgraded {
2441 type DataTuple<'a> = ();
2442 type DataToken<'a> = <Self::DataTuple<
2443 'a,
2444 > as alloy_sol_types::SolType>::Token<'a>;
2445 type TopicList = (
2446 alloy_sol_types::sol_data::FixedBytes<32>,
2447 alloy::sol_types::sol_data::Address,
2448 );
2449 const SIGNATURE: &'static str = "Upgraded(address)";
2450 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2451 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
2452 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8,
2453 12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
2454 ]);
2455 const ANONYMOUS: bool = false;
2456 #[allow(unused_variables)]
2457 #[inline]
2458 fn new(
2459 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2460 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2461 ) -> Self {
2462 Self { implementation: topics.1 }
2463 }
2464 #[inline]
2465 fn check_signature(
2466 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2467 ) -> alloy_sol_types::Result<()> {
2468 if topics.0 != Self::SIGNATURE_HASH {
2469 return Err(
2470 alloy_sol_types::Error::invalid_event_signature_hash(
2471 Self::SIGNATURE,
2472 topics.0,
2473 Self::SIGNATURE_HASH,
2474 ),
2475 );
2476 }
2477 Ok(())
2478 }
2479 #[inline]
2480 fn tokenize_body(&self) -> Self::DataToken<'_> {
2481 ()
2482 }
2483 #[inline]
2484 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2485 (Self::SIGNATURE_HASH.into(), self.implementation.clone())
2486 }
2487 #[inline]
2488 fn encode_topics_raw(
2489 &self,
2490 out: &mut [alloy_sol_types::abi::token::WordToken],
2491 ) -> alloy_sol_types::Result<()> {
2492 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2493 return Err(alloy_sol_types::Error::Overrun);
2494 }
2495 out[0usize] = alloy_sol_types::abi::token::WordToken(
2496 Self::SIGNATURE_HASH,
2497 );
2498 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2499 &self.implementation,
2500 );
2501 Ok(())
2502 }
2503 }
2504 #[automatically_derived]
2505 impl alloy_sol_types::private::IntoLogData for Upgraded {
2506 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2507 From::from(self)
2508 }
2509 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2510 From::from(&self)
2511 }
2512 }
2513 #[automatically_derived]
2514 impl From<&Upgraded> for alloy_sol_types::private::LogData {
2515 #[inline]
2516 fn from(this: &Upgraded) -> alloy_sol_types::private::LogData {
2517 alloy_sol_types::SolEvent::encode_log_data(this)
2518 }
2519 }
2520 };
2521 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2526 #[derive(Clone)]
2527 pub struct constructorCall {}
2528 const _: () = {
2529 use alloy::sol_types as alloy_sol_types;
2530 {
2531 #[doc(hidden)]
2532 type UnderlyingSolTuple<'a> = ();
2533 #[doc(hidden)]
2534 type UnderlyingRustTuple<'a> = ();
2535 #[cfg(test)]
2536 #[allow(dead_code, unreachable_patterns)]
2537 fn _type_assertion(
2538 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2539 ) {
2540 match _t {
2541 alloy_sol_types::private::AssertTypeEq::<
2542 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2543 >(_) => {}
2544 }
2545 }
2546 #[automatically_derived]
2547 #[doc(hidden)]
2548 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
2549 fn from(value: constructorCall) -> Self {
2550 ()
2551 }
2552 }
2553 #[automatically_derived]
2554 #[doc(hidden)]
2555 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
2556 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2557 Self {}
2558 }
2559 }
2560 }
2561 #[automatically_derived]
2562 impl alloy_sol_types::SolConstructor for constructorCall {
2563 type Parameters<'a> = ();
2564 type Token<'a> = <Self::Parameters<
2565 'a,
2566 > as alloy_sol_types::SolType>::Token<'a>;
2567 #[inline]
2568 fn new<'a>(
2569 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2570 ) -> Self {
2571 tuple.into()
2572 }
2573 #[inline]
2574 fn tokenize(&self) -> Self::Token<'_> {
2575 ()
2576 }
2577 }
2578 };
2579 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2580 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2585 #[derive(Clone)]
2586 pub struct UPGRADE_INTERFACE_VERSIONCall {}
2587 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2588 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2590 #[derive(Clone)]
2591 pub struct UPGRADE_INTERFACE_VERSIONReturn {
2592 #[allow(missing_docs)]
2593 pub _0: alloy::sol_types::private::String,
2594 }
2595 #[allow(
2596 non_camel_case_types,
2597 non_snake_case,
2598 clippy::pub_underscore_fields,
2599 clippy::style
2600 )]
2601 const _: () = {
2602 use alloy::sol_types as alloy_sol_types;
2603 {
2604 #[doc(hidden)]
2605 type UnderlyingSolTuple<'a> = ();
2606 #[doc(hidden)]
2607 type UnderlyingRustTuple<'a> = ();
2608 #[cfg(test)]
2609 #[allow(dead_code, unreachable_patterns)]
2610 fn _type_assertion(
2611 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2612 ) {
2613 match _t {
2614 alloy_sol_types::private::AssertTypeEq::<
2615 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2616 >(_) => {}
2617 }
2618 }
2619 #[automatically_derived]
2620 #[doc(hidden)]
2621 impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONCall>
2622 for UnderlyingRustTuple<'_> {
2623 fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self {
2624 ()
2625 }
2626 }
2627 #[automatically_derived]
2628 #[doc(hidden)]
2629 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2630 for UPGRADE_INTERFACE_VERSIONCall {
2631 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2632 Self {}
2633 }
2634 }
2635 }
2636 {
2637 #[doc(hidden)]
2638 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2639 #[doc(hidden)]
2640 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2641 #[cfg(test)]
2642 #[allow(dead_code, unreachable_patterns)]
2643 fn _type_assertion(
2644 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2645 ) {
2646 match _t {
2647 alloy_sol_types::private::AssertTypeEq::<
2648 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2649 >(_) => {}
2650 }
2651 }
2652 #[automatically_derived]
2653 #[doc(hidden)]
2654 impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONReturn>
2655 for UnderlyingRustTuple<'_> {
2656 fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self {
2657 (value._0,)
2658 }
2659 }
2660 #[automatically_derived]
2661 #[doc(hidden)]
2662 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2663 for UPGRADE_INTERFACE_VERSIONReturn {
2664 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2665 Self { _0: tuple.0 }
2666 }
2667 }
2668 }
2669 #[automatically_derived]
2670 impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall {
2671 type Parameters<'a> = ();
2672 type Token<'a> = <Self::Parameters<
2673 'a,
2674 > as alloy_sol_types::SolType>::Token<'a>;
2675 type Return = UPGRADE_INTERFACE_VERSIONReturn;
2676 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2677 type ReturnToken<'a> = <Self::ReturnTuple<
2678 'a,
2679 > as alloy_sol_types::SolType>::Token<'a>;
2680 const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()";
2681 const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8];
2682 #[inline]
2683 fn new<'a>(
2684 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2685 ) -> Self {
2686 tuple.into()
2687 }
2688 #[inline]
2689 fn tokenize(&self) -> Self::Token<'_> {
2690 ()
2691 }
2692 #[inline]
2693 fn abi_decode_returns(
2694 data: &[u8],
2695 validate: bool,
2696 ) -> alloy_sol_types::Result<Self::Return> {
2697 <Self::ReturnTuple<
2698 '_,
2699 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2700 .map(Into::into)
2701 }
2702 }
2703 };
2704 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2705 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2710 #[derive(Clone)]
2711 pub struct allowanceCall {
2712 #[allow(missing_docs)]
2713 pub owner: alloy::sol_types::private::Address,
2714 #[allow(missing_docs)]
2715 pub spender: alloy::sol_types::private::Address,
2716 }
2717 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2718 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2720 #[derive(Clone)]
2721 pub struct allowanceReturn {
2722 #[allow(missing_docs)]
2723 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2724 }
2725 #[allow(
2726 non_camel_case_types,
2727 non_snake_case,
2728 clippy::pub_underscore_fields,
2729 clippy::style
2730 )]
2731 const _: () = {
2732 use alloy::sol_types as alloy_sol_types;
2733 {
2734 #[doc(hidden)]
2735 type UnderlyingSolTuple<'a> = (
2736 alloy::sol_types::sol_data::Address,
2737 alloy::sol_types::sol_data::Address,
2738 );
2739 #[doc(hidden)]
2740 type UnderlyingRustTuple<'a> = (
2741 alloy::sol_types::private::Address,
2742 alloy::sol_types::private::Address,
2743 );
2744 #[cfg(test)]
2745 #[allow(dead_code, unreachable_patterns)]
2746 fn _type_assertion(
2747 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2748 ) {
2749 match _t {
2750 alloy_sol_types::private::AssertTypeEq::<
2751 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2752 >(_) => {}
2753 }
2754 }
2755 #[automatically_derived]
2756 #[doc(hidden)]
2757 impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
2758 fn from(value: allowanceCall) -> Self {
2759 (value.owner, value.spender)
2760 }
2761 }
2762 #[automatically_derived]
2763 #[doc(hidden)]
2764 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
2765 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2766 Self {
2767 owner: tuple.0,
2768 spender: tuple.1,
2769 }
2770 }
2771 }
2772 }
2773 {
2774 #[doc(hidden)]
2775 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2776 #[doc(hidden)]
2777 type UnderlyingRustTuple<'a> = (
2778 alloy::sol_types::private::primitives::aliases::U256,
2779 );
2780 #[cfg(test)]
2781 #[allow(dead_code, unreachable_patterns)]
2782 fn _type_assertion(
2783 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2784 ) {
2785 match _t {
2786 alloy_sol_types::private::AssertTypeEq::<
2787 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2788 >(_) => {}
2789 }
2790 }
2791 #[automatically_derived]
2792 #[doc(hidden)]
2793 impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
2794 fn from(value: allowanceReturn) -> Self {
2795 (value._0,)
2796 }
2797 }
2798 #[automatically_derived]
2799 #[doc(hidden)]
2800 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
2801 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2802 Self { _0: tuple.0 }
2803 }
2804 }
2805 }
2806 #[automatically_derived]
2807 impl alloy_sol_types::SolCall for allowanceCall {
2808 type Parameters<'a> = (
2809 alloy::sol_types::sol_data::Address,
2810 alloy::sol_types::sol_data::Address,
2811 );
2812 type Token<'a> = <Self::Parameters<
2813 'a,
2814 > as alloy_sol_types::SolType>::Token<'a>;
2815 type Return = allowanceReturn;
2816 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2817 type ReturnToken<'a> = <Self::ReturnTuple<
2818 'a,
2819 > as alloy_sol_types::SolType>::Token<'a>;
2820 const SIGNATURE: &'static str = "allowance(address,address)";
2821 const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
2822 #[inline]
2823 fn new<'a>(
2824 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2825 ) -> Self {
2826 tuple.into()
2827 }
2828 #[inline]
2829 fn tokenize(&self) -> Self::Token<'_> {
2830 (
2831 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2832 &self.owner,
2833 ),
2834 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2835 &self.spender,
2836 ),
2837 )
2838 }
2839 #[inline]
2840 fn abi_decode_returns(
2841 data: &[u8],
2842 validate: bool,
2843 ) -> alloy_sol_types::Result<Self::Return> {
2844 <Self::ReturnTuple<
2845 '_,
2846 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2847 .map(Into::into)
2848 }
2849 }
2850 };
2851 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2852 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2857 #[derive(Clone)]
2858 pub struct approveCall {
2859 #[allow(missing_docs)]
2860 pub spender: alloy::sol_types::private::Address,
2861 #[allow(missing_docs)]
2862 pub value: alloy::sol_types::private::primitives::aliases::U256,
2863 }
2864 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2865 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2867 #[derive(Clone)]
2868 pub struct approveReturn {
2869 #[allow(missing_docs)]
2870 pub _0: bool,
2871 }
2872 #[allow(
2873 non_camel_case_types,
2874 non_snake_case,
2875 clippy::pub_underscore_fields,
2876 clippy::style
2877 )]
2878 const _: () = {
2879 use alloy::sol_types as alloy_sol_types;
2880 {
2881 #[doc(hidden)]
2882 type UnderlyingSolTuple<'a> = (
2883 alloy::sol_types::sol_data::Address,
2884 alloy::sol_types::sol_data::Uint<256>,
2885 );
2886 #[doc(hidden)]
2887 type UnderlyingRustTuple<'a> = (
2888 alloy::sol_types::private::Address,
2889 alloy::sol_types::private::primitives::aliases::U256,
2890 );
2891 #[cfg(test)]
2892 #[allow(dead_code, unreachable_patterns)]
2893 fn _type_assertion(
2894 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2895 ) {
2896 match _t {
2897 alloy_sol_types::private::AssertTypeEq::<
2898 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2899 >(_) => {}
2900 }
2901 }
2902 #[automatically_derived]
2903 #[doc(hidden)]
2904 impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
2905 fn from(value: approveCall) -> Self {
2906 (value.spender, value.value)
2907 }
2908 }
2909 #[automatically_derived]
2910 #[doc(hidden)]
2911 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
2912 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2913 Self {
2914 spender: tuple.0,
2915 value: tuple.1,
2916 }
2917 }
2918 }
2919 }
2920 {
2921 #[doc(hidden)]
2922 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2923 #[doc(hidden)]
2924 type UnderlyingRustTuple<'a> = (bool,);
2925 #[cfg(test)]
2926 #[allow(dead_code, unreachable_patterns)]
2927 fn _type_assertion(
2928 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2929 ) {
2930 match _t {
2931 alloy_sol_types::private::AssertTypeEq::<
2932 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2933 >(_) => {}
2934 }
2935 }
2936 #[automatically_derived]
2937 #[doc(hidden)]
2938 impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
2939 fn from(value: approveReturn) -> Self {
2940 (value._0,)
2941 }
2942 }
2943 #[automatically_derived]
2944 #[doc(hidden)]
2945 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
2946 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2947 Self { _0: tuple.0 }
2948 }
2949 }
2950 }
2951 #[automatically_derived]
2952 impl alloy_sol_types::SolCall for approveCall {
2953 type Parameters<'a> = (
2954 alloy::sol_types::sol_data::Address,
2955 alloy::sol_types::sol_data::Uint<256>,
2956 );
2957 type Token<'a> = <Self::Parameters<
2958 'a,
2959 > as alloy_sol_types::SolType>::Token<'a>;
2960 type Return = approveReturn;
2961 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2962 type ReturnToken<'a> = <Self::ReturnTuple<
2963 'a,
2964 > as alloy_sol_types::SolType>::Token<'a>;
2965 const SIGNATURE: &'static str = "approve(address,uint256)";
2966 const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
2967 #[inline]
2968 fn new<'a>(
2969 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2970 ) -> Self {
2971 tuple.into()
2972 }
2973 #[inline]
2974 fn tokenize(&self) -> Self::Token<'_> {
2975 (
2976 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2977 &self.spender,
2978 ),
2979 <alloy::sol_types::sol_data::Uint<
2980 256,
2981 > as alloy_sol_types::SolType>::tokenize(&self.value),
2982 )
2983 }
2984 #[inline]
2985 fn abi_decode_returns(
2986 data: &[u8],
2987 validate: bool,
2988 ) -> alloy_sol_types::Result<Self::Return> {
2989 <Self::ReturnTuple<
2990 '_,
2991 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2992 .map(Into::into)
2993 }
2994 }
2995 };
2996 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2997 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3002 #[derive(Clone)]
3003 pub struct balanceOfCall {
3004 #[allow(missing_docs)]
3005 pub account: alloy::sol_types::private::Address,
3006 }
3007 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3008 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3010 #[derive(Clone)]
3011 pub struct balanceOfReturn {
3012 #[allow(missing_docs)]
3013 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3014 }
3015 #[allow(
3016 non_camel_case_types,
3017 non_snake_case,
3018 clippy::pub_underscore_fields,
3019 clippy::style
3020 )]
3021 const _: () = {
3022 use alloy::sol_types as alloy_sol_types;
3023 {
3024 #[doc(hidden)]
3025 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3026 #[doc(hidden)]
3027 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3028 #[cfg(test)]
3029 #[allow(dead_code, unreachable_patterns)]
3030 fn _type_assertion(
3031 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3032 ) {
3033 match _t {
3034 alloy_sol_types::private::AssertTypeEq::<
3035 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3036 >(_) => {}
3037 }
3038 }
3039 #[automatically_derived]
3040 #[doc(hidden)]
3041 impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
3042 fn from(value: balanceOfCall) -> Self {
3043 (value.account,)
3044 }
3045 }
3046 #[automatically_derived]
3047 #[doc(hidden)]
3048 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
3049 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3050 Self { account: tuple.0 }
3051 }
3052 }
3053 }
3054 {
3055 #[doc(hidden)]
3056 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3057 #[doc(hidden)]
3058 type UnderlyingRustTuple<'a> = (
3059 alloy::sol_types::private::primitives::aliases::U256,
3060 );
3061 #[cfg(test)]
3062 #[allow(dead_code, unreachable_patterns)]
3063 fn _type_assertion(
3064 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3065 ) {
3066 match _t {
3067 alloy_sol_types::private::AssertTypeEq::<
3068 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3069 >(_) => {}
3070 }
3071 }
3072 #[automatically_derived]
3073 #[doc(hidden)]
3074 impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
3075 fn from(value: balanceOfReturn) -> Self {
3076 (value._0,)
3077 }
3078 }
3079 #[automatically_derived]
3080 #[doc(hidden)]
3081 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
3082 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3083 Self { _0: tuple.0 }
3084 }
3085 }
3086 }
3087 #[automatically_derived]
3088 impl alloy_sol_types::SolCall for balanceOfCall {
3089 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3090 type Token<'a> = <Self::Parameters<
3091 'a,
3092 > as alloy_sol_types::SolType>::Token<'a>;
3093 type Return = balanceOfReturn;
3094 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3095 type ReturnToken<'a> = <Self::ReturnTuple<
3096 'a,
3097 > as alloy_sol_types::SolType>::Token<'a>;
3098 const SIGNATURE: &'static str = "balanceOf(address)";
3099 const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
3100 #[inline]
3101 fn new<'a>(
3102 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3103 ) -> Self {
3104 tuple.into()
3105 }
3106 #[inline]
3107 fn tokenize(&self) -> Self::Token<'_> {
3108 (
3109 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3110 &self.account,
3111 ),
3112 )
3113 }
3114 #[inline]
3115 fn abi_decode_returns(
3116 data: &[u8],
3117 validate: bool,
3118 ) -> alloy_sol_types::Result<Self::Return> {
3119 <Self::ReturnTuple<
3120 '_,
3121 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3122 .map(Into::into)
3123 }
3124 }
3125 };
3126 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3127 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3132 #[derive(Clone)]
3133 pub struct decimalsCall {}
3134 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3135 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3137 #[derive(Clone)]
3138 pub struct decimalsReturn {
3139 #[allow(missing_docs)]
3140 pub _0: u8,
3141 }
3142 #[allow(
3143 non_camel_case_types,
3144 non_snake_case,
3145 clippy::pub_underscore_fields,
3146 clippy::style
3147 )]
3148 const _: () = {
3149 use alloy::sol_types as alloy_sol_types;
3150 {
3151 #[doc(hidden)]
3152 type UnderlyingSolTuple<'a> = ();
3153 #[doc(hidden)]
3154 type UnderlyingRustTuple<'a> = ();
3155 #[cfg(test)]
3156 #[allow(dead_code, unreachable_patterns)]
3157 fn _type_assertion(
3158 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3159 ) {
3160 match _t {
3161 alloy_sol_types::private::AssertTypeEq::<
3162 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3163 >(_) => {}
3164 }
3165 }
3166 #[automatically_derived]
3167 #[doc(hidden)]
3168 impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
3169 fn from(value: decimalsCall) -> Self {
3170 ()
3171 }
3172 }
3173 #[automatically_derived]
3174 #[doc(hidden)]
3175 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
3176 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3177 Self {}
3178 }
3179 }
3180 }
3181 {
3182 #[doc(hidden)]
3183 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3184 #[doc(hidden)]
3185 type UnderlyingRustTuple<'a> = (u8,);
3186 #[cfg(test)]
3187 #[allow(dead_code, unreachable_patterns)]
3188 fn _type_assertion(
3189 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3190 ) {
3191 match _t {
3192 alloy_sol_types::private::AssertTypeEq::<
3193 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3194 >(_) => {}
3195 }
3196 }
3197 #[automatically_derived]
3198 #[doc(hidden)]
3199 impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
3200 fn from(value: decimalsReturn) -> Self {
3201 (value._0,)
3202 }
3203 }
3204 #[automatically_derived]
3205 #[doc(hidden)]
3206 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
3207 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3208 Self { _0: tuple.0 }
3209 }
3210 }
3211 }
3212 #[automatically_derived]
3213 impl alloy_sol_types::SolCall for decimalsCall {
3214 type Parameters<'a> = ();
3215 type Token<'a> = <Self::Parameters<
3216 'a,
3217 > as alloy_sol_types::SolType>::Token<'a>;
3218 type Return = decimalsReturn;
3219 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3220 type ReturnToken<'a> = <Self::ReturnTuple<
3221 'a,
3222 > as alloy_sol_types::SolType>::Token<'a>;
3223 const SIGNATURE: &'static str = "decimals()";
3224 const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
3225 #[inline]
3226 fn new<'a>(
3227 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3228 ) -> Self {
3229 tuple.into()
3230 }
3231 #[inline]
3232 fn tokenize(&self) -> Self::Token<'_> {
3233 ()
3234 }
3235 #[inline]
3236 fn abi_decode_returns(
3237 data: &[u8],
3238 validate: bool,
3239 ) -> alloy_sol_types::Result<Self::Return> {
3240 <Self::ReturnTuple<
3241 '_,
3242 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3243 .map(Into::into)
3244 }
3245 }
3246 };
3247 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3248 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3253 #[derive(Clone)]
3254 pub struct getVersionCall {}
3255 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3256 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3258 #[derive(Clone)]
3259 pub struct getVersionReturn {
3260 #[allow(missing_docs)]
3261 pub majorVersion: u8,
3262 #[allow(missing_docs)]
3263 pub minorVersion: u8,
3264 #[allow(missing_docs)]
3265 pub patchVersion: u8,
3266 }
3267 #[allow(
3268 non_camel_case_types,
3269 non_snake_case,
3270 clippy::pub_underscore_fields,
3271 clippy::style
3272 )]
3273 const _: () = {
3274 use alloy::sol_types as alloy_sol_types;
3275 {
3276 #[doc(hidden)]
3277 type UnderlyingSolTuple<'a> = ();
3278 #[doc(hidden)]
3279 type UnderlyingRustTuple<'a> = ();
3280 #[cfg(test)]
3281 #[allow(dead_code, unreachable_patterns)]
3282 fn _type_assertion(
3283 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3284 ) {
3285 match _t {
3286 alloy_sol_types::private::AssertTypeEq::<
3287 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3288 >(_) => {}
3289 }
3290 }
3291 #[automatically_derived]
3292 #[doc(hidden)]
3293 impl ::core::convert::From<getVersionCall> for UnderlyingRustTuple<'_> {
3294 fn from(value: getVersionCall) -> Self {
3295 ()
3296 }
3297 }
3298 #[automatically_derived]
3299 #[doc(hidden)]
3300 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionCall {
3301 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3302 Self {}
3303 }
3304 }
3305 }
3306 {
3307 #[doc(hidden)]
3308 type UnderlyingSolTuple<'a> = (
3309 alloy::sol_types::sol_data::Uint<8>,
3310 alloy::sol_types::sol_data::Uint<8>,
3311 alloy::sol_types::sol_data::Uint<8>,
3312 );
3313 #[doc(hidden)]
3314 type UnderlyingRustTuple<'a> = (u8, u8, u8);
3315 #[cfg(test)]
3316 #[allow(dead_code, unreachable_patterns)]
3317 fn _type_assertion(
3318 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3319 ) {
3320 match _t {
3321 alloy_sol_types::private::AssertTypeEq::<
3322 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3323 >(_) => {}
3324 }
3325 }
3326 #[automatically_derived]
3327 #[doc(hidden)]
3328 impl ::core::convert::From<getVersionReturn> for UnderlyingRustTuple<'_> {
3329 fn from(value: getVersionReturn) -> Self {
3330 (value.majorVersion, value.minorVersion, value.patchVersion)
3331 }
3332 }
3333 #[automatically_derived]
3334 #[doc(hidden)]
3335 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionReturn {
3336 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3337 Self {
3338 majorVersion: tuple.0,
3339 minorVersion: tuple.1,
3340 patchVersion: tuple.2,
3341 }
3342 }
3343 }
3344 }
3345 #[automatically_derived]
3346 impl alloy_sol_types::SolCall for getVersionCall {
3347 type Parameters<'a> = ();
3348 type Token<'a> = <Self::Parameters<
3349 'a,
3350 > as alloy_sol_types::SolType>::Token<'a>;
3351 type Return = getVersionReturn;
3352 type ReturnTuple<'a> = (
3353 alloy::sol_types::sol_data::Uint<8>,
3354 alloy::sol_types::sol_data::Uint<8>,
3355 alloy::sol_types::sol_data::Uint<8>,
3356 );
3357 type ReturnToken<'a> = <Self::ReturnTuple<
3358 'a,
3359 > as alloy_sol_types::SolType>::Token<'a>;
3360 const SIGNATURE: &'static str = "getVersion()";
3361 const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8];
3362 #[inline]
3363 fn new<'a>(
3364 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3365 ) -> Self {
3366 tuple.into()
3367 }
3368 #[inline]
3369 fn tokenize(&self) -> Self::Token<'_> {
3370 ()
3371 }
3372 #[inline]
3373 fn abi_decode_returns(
3374 data: &[u8],
3375 validate: bool,
3376 ) -> alloy_sol_types::Result<Self::Return> {
3377 <Self::ReturnTuple<
3378 '_,
3379 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3380 .map(Into::into)
3381 }
3382 }
3383 };
3384 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3385 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3390 #[derive(Clone)]
3391 pub struct initializeCall {
3392 #[allow(missing_docs)]
3393 pub owner: alloy::sol_types::private::Address,
3394 #[allow(missing_docs)]
3395 pub initialRecipient: alloy::sol_types::private::Address,
3396 #[allow(missing_docs)]
3397 pub initialSupply: alloy::sol_types::private::primitives::aliases::U256,
3398 #[allow(missing_docs)]
3399 pub name: alloy::sol_types::private::String,
3400 #[allow(missing_docs)]
3401 pub symbol: alloy::sol_types::private::String,
3402 }
3403 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3405 #[derive(Clone)]
3406 pub struct initializeReturn {}
3407 #[allow(
3408 non_camel_case_types,
3409 non_snake_case,
3410 clippy::pub_underscore_fields,
3411 clippy::style
3412 )]
3413 const _: () = {
3414 use alloy::sol_types as alloy_sol_types;
3415 {
3416 #[doc(hidden)]
3417 type UnderlyingSolTuple<'a> = (
3418 alloy::sol_types::sol_data::Address,
3419 alloy::sol_types::sol_data::Address,
3420 alloy::sol_types::sol_data::Uint<256>,
3421 alloy::sol_types::sol_data::String,
3422 alloy::sol_types::sol_data::String,
3423 );
3424 #[doc(hidden)]
3425 type UnderlyingRustTuple<'a> = (
3426 alloy::sol_types::private::Address,
3427 alloy::sol_types::private::Address,
3428 alloy::sol_types::private::primitives::aliases::U256,
3429 alloy::sol_types::private::String,
3430 alloy::sol_types::private::String,
3431 );
3432 #[cfg(test)]
3433 #[allow(dead_code, unreachable_patterns)]
3434 fn _type_assertion(
3435 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3436 ) {
3437 match _t {
3438 alloy_sol_types::private::AssertTypeEq::<
3439 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3440 >(_) => {}
3441 }
3442 }
3443 #[automatically_derived]
3444 #[doc(hidden)]
3445 impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
3446 fn from(value: initializeCall) -> Self {
3447 (
3448 value.owner,
3449 value.initialRecipient,
3450 value.initialSupply,
3451 value.name,
3452 value.symbol,
3453 )
3454 }
3455 }
3456 #[automatically_derived]
3457 #[doc(hidden)]
3458 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
3459 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3460 Self {
3461 owner: tuple.0,
3462 initialRecipient: tuple.1,
3463 initialSupply: tuple.2,
3464 name: tuple.3,
3465 symbol: tuple.4,
3466 }
3467 }
3468 }
3469 }
3470 {
3471 #[doc(hidden)]
3472 type UnderlyingSolTuple<'a> = ();
3473 #[doc(hidden)]
3474 type UnderlyingRustTuple<'a> = ();
3475 #[cfg(test)]
3476 #[allow(dead_code, unreachable_patterns)]
3477 fn _type_assertion(
3478 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3479 ) {
3480 match _t {
3481 alloy_sol_types::private::AssertTypeEq::<
3482 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3483 >(_) => {}
3484 }
3485 }
3486 #[automatically_derived]
3487 #[doc(hidden)]
3488 impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
3489 fn from(value: initializeReturn) -> Self {
3490 ()
3491 }
3492 }
3493 #[automatically_derived]
3494 #[doc(hidden)]
3495 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
3496 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3497 Self {}
3498 }
3499 }
3500 }
3501 #[automatically_derived]
3502 impl alloy_sol_types::SolCall for initializeCall {
3503 type Parameters<'a> = (
3504 alloy::sol_types::sol_data::Address,
3505 alloy::sol_types::sol_data::Address,
3506 alloy::sol_types::sol_data::Uint<256>,
3507 alloy::sol_types::sol_data::String,
3508 alloy::sol_types::sol_data::String,
3509 );
3510 type Token<'a> = <Self::Parameters<
3511 'a,
3512 > as alloy_sol_types::SolType>::Token<'a>;
3513 type Return = initializeReturn;
3514 type ReturnTuple<'a> = ();
3515 type ReturnToken<'a> = <Self::ReturnTuple<
3516 'a,
3517 > as alloy_sol_types::SolType>::Token<'a>;
3518 const SIGNATURE: &'static str = "initialize(address,address,uint256,string,string)";
3519 const SELECTOR: [u8; 4] = [154u8, 184u8, 54u8, 126u8];
3520 #[inline]
3521 fn new<'a>(
3522 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3523 ) -> Self {
3524 tuple.into()
3525 }
3526 #[inline]
3527 fn tokenize(&self) -> Self::Token<'_> {
3528 (
3529 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3530 &self.owner,
3531 ),
3532 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3533 &self.initialRecipient,
3534 ),
3535 <alloy::sol_types::sol_data::Uint<
3536 256,
3537 > as alloy_sol_types::SolType>::tokenize(&self.initialSupply),
3538 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
3539 &self.name,
3540 ),
3541 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
3542 &self.symbol,
3543 ),
3544 )
3545 }
3546 #[inline]
3547 fn abi_decode_returns(
3548 data: &[u8],
3549 validate: bool,
3550 ) -> alloy_sol_types::Result<Self::Return> {
3551 <Self::ReturnTuple<
3552 '_,
3553 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3554 .map(Into::into)
3555 }
3556 }
3557 };
3558 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3559 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3564 #[derive(Clone)]
3565 pub struct nameCall {}
3566 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3567 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3569 #[derive(Clone)]
3570 pub struct nameReturn {
3571 #[allow(missing_docs)]
3572 pub _0: alloy::sol_types::private::String,
3573 }
3574 #[allow(
3575 non_camel_case_types,
3576 non_snake_case,
3577 clippy::pub_underscore_fields,
3578 clippy::style
3579 )]
3580 const _: () = {
3581 use alloy::sol_types as alloy_sol_types;
3582 {
3583 #[doc(hidden)]
3584 type UnderlyingSolTuple<'a> = ();
3585 #[doc(hidden)]
3586 type UnderlyingRustTuple<'a> = ();
3587 #[cfg(test)]
3588 #[allow(dead_code, unreachable_patterns)]
3589 fn _type_assertion(
3590 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3591 ) {
3592 match _t {
3593 alloy_sol_types::private::AssertTypeEq::<
3594 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3595 >(_) => {}
3596 }
3597 }
3598 #[automatically_derived]
3599 #[doc(hidden)]
3600 impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
3601 fn from(value: nameCall) -> Self {
3602 ()
3603 }
3604 }
3605 #[automatically_derived]
3606 #[doc(hidden)]
3607 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
3608 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3609 Self {}
3610 }
3611 }
3612 }
3613 {
3614 #[doc(hidden)]
3615 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
3616 #[doc(hidden)]
3617 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
3618 #[cfg(test)]
3619 #[allow(dead_code, unreachable_patterns)]
3620 fn _type_assertion(
3621 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3622 ) {
3623 match _t {
3624 alloy_sol_types::private::AssertTypeEq::<
3625 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3626 >(_) => {}
3627 }
3628 }
3629 #[automatically_derived]
3630 #[doc(hidden)]
3631 impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
3632 fn from(value: nameReturn) -> Self {
3633 (value._0,)
3634 }
3635 }
3636 #[automatically_derived]
3637 #[doc(hidden)]
3638 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
3639 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3640 Self { _0: tuple.0 }
3641 }
3642 }
3643 }
3644 #[automatically_derived]
3645 impl alloy_sol_types::SolCall for nameCall {
3646 type Parameters<'a> = ();
3647 type Token<'a> = <Self::Parameters<
3648 'a,
3649 > as alloy_sol_types::SolType>::Token<'a>;
3650 type Return = nameReturn;
3651 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
3652 type ReturnToken<'a> = <Self::ReturnTuple<
3653 'a,
3654 > as alloy_sol_types::SolType>::Token<'a>;
3655 const SIGNATURE: &'static str = "name()";
3656 const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
3657 #[inline]
3658 fn new<'a>(
3659 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3660 ) -> Self {
3661 tuple.into()
3662 }
3663 #[inline]
3664 fn tokenize(&self) -> Self::Token<'_> {
3665 ()
3666 }
3667 #[inline]
3668 fn abi_decode_returns(
3669 data: &[u8],
3670 validate: bool,
3671 ) -> alloy_sol_types::Result<Self::Return> {
3672 <Self::ReturnTuple<
3673 '_,
3674 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3675 .map(Into::into)
3676 }
3677 }
3678 };
3679 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3680 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3685 #[derive(Clone)]
3686 pub struct ownerCall {}
3687 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3688 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3690 #[derive(Clone)]
3691 pub struct ownerReturn {
3692 #[allow(missing_docs)]
3693 pub _0: alloy::sol_types::private::Address,
3694 }
3695 #[allow(
3696 non_camel_case_types,
3697 non_snake_case,
3698 clippy::pub_underscore_fields,
3699 clippy::style
3700 )]
3701 const _: () = {
3702 use alloy::sol_types as alloy_sol_types;
3703 {
3704 #[doc(hidden)]
3705 type UnderlyingSolTuple<'a> = ();
3706 #[doc(hidden)]
3707 type UnderlyingRustTuple<'a> = ();
3708 #[cfg(test)]
3709 #[allow(dead_code, unreachable_patterns)]
3710 fn _type_assertion(
3711 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3712 ) {
3713 match _t {
3714 alloy_sol_types::private::AssertTypeEq::<
3715 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3716 >(_) => {}
3717 }
3718 }
3719 #[automatically_derived]
3720 #[doc(hidden)]
3721 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
3722 fn from(value: ownerCall) -> Self {
3723 ()
3724 }
3725 }
3726 #[automatically_derived]
3727 #[doc(hidden)]
3728 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
3729 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3730 Self {}
3731 }
3732 }
3733 }
3734 {
3735 #[doc(hidden)]
3736 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3737 #[doc(hidden)]
3738 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3739 #[cfg(test)]
3740 #[allow(dead_code, unreachable_patterns)]
3741 fn _type_assertion(
3742 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3743 ) {
3744 match _t {
3745 alloy_sol_types::private::AssertTypeEq::<
3746 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3747 >(_) => {}
3748 }
3749 }
3750 #[automatically_derived]
3751 #[doc(hidden)]
3752 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
3753 fn from(value: ownerReturn) -> Self {
3754 (value._0,)
3755 }
3756 }
3757 #[automatically_derived]
3758 #[doc(hidden)]
3759 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
3760 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3761 Self { _0: tuple.0 }
3762 }
3763 }
3764 }
3765 #[automatically_derived]
3766 impl alloy_sol_types::SolCall for ownerCall {
3767 type Parameters<'a> = ();
3768 type Token<'a> = <Self::Parameters<
3769 'a,
3770 > as alloy_sol_types::SolType>::Token<'a>;
3771 type Return = ownerReturn;
3772 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3773 type ReturnToken<'a> = <Self::ReturnTuple<
3774 'a,
3775 > as alloy_sol_types::SolType>::Token<'a>;
3776 const SIGNATURE: &'static str = "owner()";
3777 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
3778 #[inline]
3779 fn new<'a>(
3780 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3781 ) -> Self {
3782 tuple.into()
3783 }
3784 #[inline]
3785 fn tokenize(&self) -> Self::Token<'_> {
3786 ()
3787 }
3788 #[inline]
3789 fn abi_decode_returns(
3790 data: &[u8],
3791 validate: bool,
3792 ) -> alloy_sol_types::Result<Self::Return> {
3793 <Self::ReturnTuple<
3794 '_,
3795 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3796 .map(Into::into)
3797 }
3798 }
3799 };
3800 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3801 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3806 #[derive(Clone)]
3807 pub struct proxiableUUIDCall {}
3808 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3809 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3811 #[derive(Clone)]
3812 pub struct proxiableUUIDReturn {
3813 #[allow(missing_docs)]
3814 pub _0: alloy::sol_types::private::FixedBytes<32>,
3815 }
3816 #[allow(
3817 non_camel_case_types,
3818 non_snake_case,
3819 clippy::pub_underscore_fields,
3820 clippy::style
3821 )]
3822 const _: () = {
3823 use alloy::sol_types as alloy_sol_types;
3824 {
3825 #[doc(hidden)]
3826 type UnderlyingSolTuple<'a> = ();
3827 #[doc(hidden)]
3828 type UnderlyingRustTuple<'a> = ();
3829 #[cfg(test)]
3830 #[allow(dead_code, unreachable_patterns)]
3831 fn _type_assertion(
3832 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3833 ) {
3834 match _t {
3835 alloy_sol_types::private::AssertTypeEq::<
3836 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3837 >(_) => {}
3838 }
3839 }
3840 #[automatically_derived]
3841 #[doc(hidden)]
3842 impl ::core::convert::From<proxiableUUIDCall> for UnderlyingRustTuple<'_> {
3843 fn from(value: proxiableUUIDCall) -> Self {
3844 ()
3845 }
3846 }
3847 #[automatically_derived]
3848 #[doc(hidden)]
3849 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDCall {
3850 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3851 Self {}
3852 }
3853 }
3854 }
3855 {
3856 #[doc(hidden)]
3857 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3858 #[doc(hidden)]
3859 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3860 #[cfg(test)]
3861 #[allow(dead_code, unreachable_patterns)]
3862 fn _type_assertion(
3863 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3864 ) {
3865 match _t {
3866 alloy_sol_types::private::AssertTypeEq::<
3867 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3868 >(_) => {}
3869 }
3870 }
3871 #[automatically_derived]
3872 #[doc(hidden)]
3873 impl ::core::convert::From<proxiableUUIDReturn> for UnderlyingRustTuple<'_> {
3874 fn from(value: proxiableUUIDReturn) -> Self {
3875 (value._0,)
3876 }
3877 }
3878 #[automatically_derived]
3879 #[doc(hidden)]
3880 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDReturn {
3881 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3882 Self { _0: tuple.0 }
3883 }
3884 }
3885 }
3886 #[automatically_derived]
3887 impl alloy_sol_types::SolCall for proxiableUUIDCall {
3888 type Parameters<'a> = ();
3889 type Token<'a> = <Self::Parameters<
3890 'a,
3891 > as alloy_sol_types::SolType>::Token<'a>;
3892 type Return = proxiableUUIDReturn;
3893 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3894 type ReturnToken<'a> = <Self::ReturnTuple<
3895 'a,
3896 > as alloy_sol_types::SolType>::Token<'a>;
3897 const SIGNATURE: &'static str = "proxiableUUID()";
3898 const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8];
3899 #[inline]
3900 fn new<'a>(
3901 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3902 ) -> Self {
3903 tuple.into()
3904 }
3905 #[inline]
3906 fn tokenize(&self) -> Self::Token<'_> {
3907 ()
3908 }
3909 #[inline]
3910 fn abi_decode_returns(
3911 data: &[u8],
3912 validate: bool,
3913 ) -> alloy_sol_types::Result<Self::Return> {
3914 <Self::ReturnTuple<
3915 '_,
3916 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3917 .map(Into::into)
3918 }
3919 }
3920 };
3921 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3922 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3927 #[derive(Clone)]
3928 pub struct renounceOwnershipCall {}
3929 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3931 #[derive(Clone)]
3932 pub struct renounceOwnershipReturn {}
3933 #[allow(
3934 non_camel_case_types,
3935 non_snake_case,
3936 clippy::pub_underscore_fields,
3937 clippy::style
3938 )]
3939 const _: () = {
3940 use alloy::sol_types as alloy_sol_types;
3941 {
3942 #[doc(hidden)]
3943 type UnderlyingSolTuple<'a> = ();
3944 #[doc(hidden)]
3945 type UnderlyingRustTuple<'a> = ();
3946 #[cfg(test)]
3947 #[allow(dead_code, unreachable_patterns)]
3948 fn _type_assertion(
3949 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3950 ) {
3951 match _t {
3952 alloy_sol_types::private::AssertTypeEq::<
3953 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3954 >(_) => {}
3955 }
3956 }
3957 #[automatically_derived]
3958 #[doc(hidden)]
3959 impl ::core::convert::From<renounceOwnershipCall>
3960 for UnderlyingRustTuple<'_> {
3961 fn from(value: renounceOwnershipCall) -> Self {
3962 ()
3963 }
3964 }
3965 #[automatically_derived]
3966 #[doc(hidden)]
3967 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3968 for renounceOwnershipCall {
3969 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3970 Self {}
3971 }
3972 }
3973 }
3974 {
3975 #[doc(hidden)]
3976 type UnderlyingSolTuple<'a> = ();
3977 #[doc(hidden)]
3978 type UnderlyingRustTuple<'a> = ();
3979 #[cfg(test)]
3980 #[allow(dead_code, unreachable_patterns)]
3981 fn _type_assertion(
3982 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3983 ) {
3984 match _t {
3985 alloy_sol_types::private::AssertTypeEq::<
3986 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3987 >(_) => {}
3988 }
3989 }
3990 #[automatically_derived]
3991 #[doc(hidden)]
3992 impl ::core::convert::From<renounceOwnershipReturn>
3993 for UnderlyingRustTuple<'_> {
3994 fn from(value: renounceOwnershipReturn) -> Self {
3995 ()
3996 }
3997 }
3998 #[automatically_derived]
3999 #[doc(hidden)]
4000 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4001 for renounceOwnershipReturn {
4002 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4003 Self {}
4004 }
4005 }
4006 }
4007 #[automatically_derived]
4008 impl alloy_sol_types::SolCall for renounceOwnershipCall {
4009 type Parameters<'a> = ();
4010 type Token<'a> = <Self::Parameters<
4011 'a,
4012 > as alloy_sol_types::SolType>::Token<'a>;
4013 type Return = renounceOwnershipReturn;
4014 type ReturnTuple<'a> = ();
4015 type ReturnToken<'a> = <Self::ReturnTuple<
4016 'a,
4017 > as alloy_sol_types::SolType>::Token<'a>;
4018 const SIGNATURE: &'static str = "renounceOwnership()";
4019 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
4020 #[inline]
4021 fn new<'a>(
4022 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4023 ) -> Self {
4024 tuple.into()
4025 }
4026 #[inline]
4027 fn tokenize(&self) -> Self::Token<'_> {
4028 ()
4029 }
4030 #[inline]
4031 fn abi_decode_returns(
4032 data: &[u8],
4033 validate: bool,
4034 ) -> alloy_sol_types::Result<Self::Return> {
4035 <Self::ReturnTuple<
4036 '_,
4037 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4038 .map(Into::into)
4039 }
4040 }
4041 };
4042 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4043 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4048 #[derive(Clone)]
4049 pub struct symbolCall {}
4050 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4051 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4053 #[derive(Clone)]
4054 pub struct symbolReturn {
4055 #[allow(missing_docs)]
4056 pub _0: alloy::sol_types::private::String,
4057 }
4058 #[allow(
4059 non_camel_case_types,
4060 non_snake_case,
4061 clippy::pub_underscore_fields,
4062 clippy::style
4063 )]
4064 const _: () = {
4065 use alloy::sol_types as alloy_sol_types;
4066 {
4067 #[doc(hidden)]
4068 type UnderlyingSolTuple<'a> = ();
4069 #[doc(hidden)]
4070 type UnderlyingRustTuple<'a> = ();
4071 #[cfg(test)]
4072 #[allow(dead_code, unreachable_patterns)]
4073 fn _type_assertion(
4074 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4075 ) {
4076 match _t {
4077 alloy_sol_types::private::AssertTypeEq::<
4078 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4079 >(_) => {}
4080 }
4081 }
4082 #[automatically_derived]
4083 #[doc(hidden)]
4084 impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
4085 fn from(value: symbolCall) -> Self {
4086 ()
4087 }
4088 }
4089 #[automatically_derived]
4090 #[doc(hidden)]
4091 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
4092 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4093 Self {}
4094 }
4095 }
4096 }
4097 {
4098 #[doc(hidden)]
4099 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
4100 #[doc(hidden)]
4101 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
4102 #[cfg(test)]
4103 #[allow(dead_code, unreachable_patterns)]
4104 fn _type_assertion(
4105 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4106 ) {
4107 match _t {
4108 alloy_sol_types::private::AssertTypeEq::<
4109 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4110 >(_) => {}
4111 }
4112 }
4113 #[automatically_derived]
4114 #[doc(hidden)]
4115 impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
4116 fn from(value: symbolReturn) -> Self {
4117 (value._0,)
4118 }
4119 }
4120 #[automatically_derived]
4121 #[doc(hidden)]
4122 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
4123 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4124 Self { _0: tuple.0 }
4125 }
4126 }
4127 }
4128 #[automatically_derived]
4129 impl alloy_sol_types::SolCall for symbolCall {
4130 type Parameters<'a> = ();
4131 type Token<'a> = <Self::Parameters<
4132 'a,
4133 > as alloy_sol_types::SolType>::Token<'a>;
4134 type Return = symbolReturn;
4135 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
4136 type ReturnToken<'a> = <Self::ReturnTuple<
4137 'a,
4138 > as alloy_sol_types::SolType>::Token<'a>;
4139 const SIGNATURE: &'static str = "symbol()";
4140 const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
4141 #[inline]
4142 fn new<'a>(
4143 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4144 ) -> Self {
4145 tuple.into()
4146 }
4147 #[inline]
4148 fn tokenize(&self) -> Self::Token<'_> {
4149 ()
4150 }
4151 #[inline]
4152 fn abi_decode_returns(
4153 data: &[u8],
4154 validate: bool,
4155 ) -> alloy_sol_types::Result<Self::Return> {
4156 <Self::ReturnTuple<
4157 '_,
4158 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4159 .map(Into::into)
4160 }
4161 }
4162 };
4163 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4164 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4169 #[derive(Clone)]
4170 pub struct totalSupplyCall {}
4171 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4172 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4174 #[derive(Clone)]
4175 pub struct totalSupplyReturn {
4176 #[allow(missing_docs)]
4177 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4178 }
4179 #[allow(
4180 non_camel_case_types,
4181 non_snake_case,
4182 clippy::pub_underscore_fields,
4183 clippy::style
4184 )]
4185 const _: () = {
4186 use alloy::sol_types as alloy_sol_types;
4187 {
4188 #[doc(hidden)]
4189 type UnderlyingSolTuple<'a> = ();
4190 #[doc(hidden)]
4191 type UnderlyingRustTuple<'a> = ();
4192 #[cfg(test)]
4193 #[allow(dead_code, unreachable_patterns)]
4194 fn _type_assertion(
4195 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4196 ) {
4197 match _t {
4198 alloy_sol_types::private::AssertTypeEq::<
4199 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4200 >(_) => {}
4201 }
4202 }
4203 #[automatically_derived]
4204 #[doc(hidden)]
4205 impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
4206 fn from(value: totalSupplyCall) -> Self {
4207 ()
4208 }
4209 }
4210 #[automatically_derived]
4211 #[doc(hidden)]
4212 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
4213 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4214 Self {}
4215 }
4216 }
4217 }
4218 {
4219 #[doc(hidden)]
4220 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4221 #[doc(hidden)]
4222 type UnderlyingRustTuple<'a> = (
4223 alloy::sol_types::private::primitives::aliases::U256,
4224 );
4225 #[cfg(test)]
4226 #[allow(dead_code, unreachable_patterns)]
4227 fn _type_assertion(
4228 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4229 ) {
4230 match _t {
4231 alloy_sol_types::private::AssertTypeEq::<
4232 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4233 >(_) => {}
4234 }
4235 }
4236 #[automatically_derived]
4237 #[doc(hidden)]
4238 impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
4239 fn from(value: totalSupplyReturn) -> Self {
4240 (value._0,)
4241 }
4242 }
4243 #[automatically_derived]
4244 #[doc(hidden)]
4245 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
4246 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4247 Self { _0: tuple.0 }
4248 }
4249 }
4250 }
4251 #[automatically_derived]
4252 impl alloy_sol_types::SolCall for totalSupplyCall {
4253 type Parameters<'a> = ();
4254 type Token<'a> = <Self::Parameters<
4255 'a,
4256 > as alloy_sol_types::SolType>::Token<'a>;
4257 type Return = totalSupplyReturn;
4258 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4259 type ReturnToken<'a> = <Self::ReturnTuple<
4260 'a,
4261 > as alloy_sol_types::SolType>::Token<'a>;
4262 const SIGNATURE: &'static str = "totalSupply()";
4263 const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
4264 #[inline]
4265 fn new<'a>(
4266 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4267 ) -> Self {
4268 tuple.into()
4269 }
4270 #[inline]
4271 fn tokenize(&self) -> Self::Token<'_> {
4272 ()
4273 }
4274 #[inline]
4275 fn abi_decode_returns(
4276 data: &[u8],
4277 validate: bool,
4278 ) -> alloy_sol_types::Result<Self::Return> {
4279 <Self::ReturnTuple<
4280 '_,
4281 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4282 .map(Into::into)
4283 }
4284 }
4285 };
4286 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4287 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4292 #[derive(Clone)]
4293 pub struct transferCall {
4294 #[allow(missing_docs)]
4295 pub to: alloy::sol_types::private::Address,
4296 #[allow(missing_docs)]
4297 pub value: alloy::sol_types::private::primitives::aliases::U256,
4298 }
4299 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4300 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4302 #[derive(Clone)]
4303 pub struct transferReturn {
4304 #[allow(missing_docs)]
4305 pub _0: bool,
4306 }
4307 #[allow(
4308 non_camel_case_types,
4309 non_snake_case,
4310 clippy::pub_underscore_fields,
4311 clippy::style
4312 )]
4313 const _: () = {
4314 use alloy::sol_types as alloy_sol_types;
4315 {
4316 #[doc(hidden)]
4317 type UnderlyingSolTuple<'a> = (
4318 alloy::sol_types::sol_data::Address,
4319 alloy::sol_types::sol_data::Uint<256>,
4320 );
4321 #[doc(hidden)]
4322 type UnderlyingRustTuple<'a> = (
4323 alloy::sol_types::private::Address,
4324 alloy::sol_types::private::primitives::aliases::U256,
4325 );
4326 #[cfg(test)]
4327 #[allow(dead_code, unreachable_patterns)]
4328 fn _type_assertion(
4329 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4330 ) {
4331 match _t {
4332 alloy_sol_types::private::AssertTypeEq::<
4333 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4334 >(_) => {}
4335 }
4336 }
4337 #[automatically_derived]
4338 #[doc(hidden)]
4339 impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
4340 fn from(value: transferCall) -> Self {
4341 (value.to, value.value)
4342 }
4343 }
4344 #[automatically_derived]
4345 #[doc(hidden)]
4346 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
4347 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4348 Self {
4349 to: tuple.0,
4350 value: tuple.1,
4351 }
4352 }
4353 }
4354 }
4355 {
4356 #[doc(hidden)]
4357 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4358 #[doc(hidden)]
4359 type UnderlyingRustTuple<'a> = (bool,);
4360 #[cfg(test)]
4361 #[allow(dead_code, unreachable_patterns)]
4362 fn _type_assertion(
4363 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4364 ) {
4365 match _t {
4366 alloy_sol_types::private::AssertTypeEq::<
4367 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4368 >(_) => {}
4369 }
4370 }
4371 #[automatically_derived]
4372 #[doc(hidden)]
4373 impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
4374 fn from(value: transferReturn) -> Self {
4375 (value._0,)
4376 }
4377 }
4378 #[automatically_derived]
4379 #[doc(hidden)]
4380 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
4381 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4382 Self { _0: tuple.0 }
4383 }
4384 }
4385 }
4386 #[automatically_derived]
4387 impl alloy_sol_types::SolCall for transferCall {
4388 type Parameters<'a> = (
4389 alloy::sol_types::sol_data::Address,
4390 alloy::sol_types::sol_data::Uint<256>,
4391 );
4392 type Token<'a> = <Self::Parameters<
4393 'a,
4394 > as alloy_sol_types::SolType>::Token<'a>;
4395 type Return = transferReturn;
4396 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4397 type ReturnToken<'a> = <Self::ReturnTuple<
4398 'a,
4399 > as alloy_sol_types::SolType>::Token<'a>;
4400 const SIGNATURE: &'static str = "transfer(address,uint256)";
4401 const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
4402 #[inline]
4403 fn new<'a>(
4404 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4405 ) -> Self {
4406 tuple.into()
4407 }
4408 #[inline]
4409 fn tokenize(&self) -> Self::Token<'_> {
4410 (
4411 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4412 &self.to,
4413 ),
4414 <alloy::sol_types::sol_data::Uint<
4415 256,
4416 > as alloy_sol_types::SolType>::tokenize(&self.value),
4417 )
4418 }
4419 #[inline]
4420 fn abi_decode_returns(
4421 data: &[u8],
4422 validate: bool,
4423 ) -> alloy_sol_types::Result<Self::Return> {
4424 <Self::ReturnTuple<
4425 '_,
4426 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4427 .map(Into::into)
4428 }
4429 }
4430 };
4431 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4432 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4437 #[derive(Clone)]
4438 pub struct transferFromCall {
4439 #[allow(missing_docs)]
4440 pub from: alloy::sol_types::private::Address,
4441 #[allow(missing_docs)]
4442 pub to: alloy::sol_types::private::Address,
4443 #[allow(missing_docs)]
4444 pub value: alloy::sol_types::private::primitives::aliases::U256,
4445 }
4446 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4447 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4449 #[derive(Clone)]
4450 pub struct transferFromReturn {
4451 #[allow(missing_docs)]
4452 pub _0: bool,
4453 }
4454 #[allow(
4455 non_camel_case_types,
4456 non_snake_case,
4457 clippy::pub_underscore_fields,
4458 clippy::style
4459 )]
4460 const _: () = {
4461 use alloy::sol_types as alloy_sol_types;
4462 {
4463 #[doc(hidden)]
4464 type UnderlyingSolTuple<'a> = (
4465 alloy::sol_types::sol_data::Address,
4466 alloy::sol_types::sol_data::Address,
4467 alloy::sol_types::sol_data::Uint<256>,
4468 );
4469 #[doc(hidden)]
4470 type UnderlyingRustTuple<'a> = (
4471 alloy::sol_types::private::Address,
4472 alloy::sol_types::private::Address,
4473 alloy::sol_types::private::primitives::aliases::U256,
4474 );
4475 #[cfg(test)]
4476 #[allow(dead_code, unreachable_patterns)]
4477 fn _type_assertion(
4478 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4479 ) {
4480 match _t {
4481 alloy_sol_types::private::AssertTypeEq::<
4482 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4483 >(_) => {}
4484 }
4485 }
4486 #[automatically_derived]
4487 #[doc(hidden)]
4488 impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
4489 fn from(value: transferFromCall) -> Self {
4490 (value.from, value.to, value.value)
4491 }
4492 }
4493 #[automatically_derived]
4494 #[doc(hidden)]
4495 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
4496 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4497 Self {
4498 from: tuple.0,
4499 to: tuple.1,
4500 value: tuple.2,
4501 }
4502 }
4503 }
4504 }
4505 {
4506 #[doc(hidden)]
4507 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4508 #[doc(hidden)]
4509 type UnderlyingRustTuple<'a> = (bool,);
4510 #[cfg(test)]
4511 #[allow(dead_code, unreachable_patterns)]
4512 fn _type_assertion(
4513 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4514 ) {
4515 match _t {
4516 alloy_sol_types::private::AssertTypeEq::<
4517 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4518 >(_) => {}
4519 }
4520 }
4521 #[automatically_derived]
4522 #[doc(hidden)]
4523 impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
4524 fn from(value: transferFromReturn) -> Self {
4525 (value._0,)
4526 }
4527 }
4528 #[automatically_derived]
4529 #[doc(hidden)]
4530 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
4531 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4532 Self { _0: tuple.0 }
4533 }
4534 }
4535 }
4536 #[automatically_derived]
4537 impl alloy_sol_types::SolCall for transferFromCall {
4538 type Parameters<'a> = (
4539 alloy::sol_types::sol_data::Address,
4540 alloy::sol_types::sol_data::Address,
4541 alloy::sol_types::sol_data::Uint<256>,
4542 );
4543 type Token<'a> = <Self::Parameters<
4544 'a,
4545 > as alloy_sol_types::SolType>::Token<'a>;
4546 type Return = transferFromReturn;
4547 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4548 type ReturnToken<'a> = <Self::ReturnTuple<
4549 'a,
4550 > as alloy_sol_types::SolType>::Token<'a>;
4551 const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
4552 const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
4553 #[inline]
4554 fn new<'a>(
4555 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4556 ) -> Self {
4557 tuple.into()
4558 }
4559 #[inline]
4560 fn tokenize(&self) -> Self::Token<'_> {
4561 (
4562 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4563 &self.from,
4564 ),
4565 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4566 &self.to,
4567 ),
4568 <alloy::sol_types::sol_data::Uint<
4569 256,
4570 > as alloy_sol_types::SolType>::tokenize(&self.value),
4571 )
4572 }
4573 #[inline]
4574 fn abi_decode_returns(
4575 data: &[u8],
4576 validate: bool,
4577 ) -> alloy_sol_types::Result<Self::Return> {
4578 <Self::ReturnTuple<
4579 '_,
4580 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4581 .map(Into::into)
4582 }
4583 }
4584 };
4585 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4586 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4591 #[derive(Clone)]
4592 pub struct transferOwnershipCall {
4593 #[allow(missing_docs)]
4594 pub newOwner: alloy::sol_types::private::Address,
4595 }
4596 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4598 #[derive(Clone)]
4599 pub struct transferOwnershipReturn {}
4600 #[allow(
4601 non_camel_case_types,
4602 non_snake_case,
4603 clippy::pub_underscore_fields,
4604 clippy::style
4605 )]
4606 const _: () = {
4607 use alloy::sol_types as alloy_sol_types;
4608 {
4609 #[doc(hidden)]
4610 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4611 #[doc(hidden)]
4612 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4613 #[cfg(test)]
4614 #[allow(dead_code, unreachable_patterns)]
4615 fn _type_assertion(
4616 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4617 ) {
4618 match _t {
4619 alloy_sol_types::private::AssertTypeEq::<
4620 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4621 >(_) => {}
4622 }
4623 }
4624 #[automatically_derived]
4625 #[doc(hidden)]
4626 impl ::core::convert::From<transferOwnershipCall>
4627 for UnderlyingRustTuple<'_> {
4628 fn from(value: transferOwnershipCall) -> Self {
4629 (value.newOwner,)
4630 }
4631 }
4632 #[automatically_derived]
4633 #[doc(hidden)]
4634 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4635 for transferOwnershipCall {
4636 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4637 Self { newOwner: tuple.0 }
4638 }
4639 }
4640 }
4641 {
4642 #[doc(hidden)]
4643 type UnderlyingSolTuple<'a> = ();
4644 #[doc(hidden)]
4645 type UnderlyingRustTuple<'a> = ();
4646 #[cfg(test)]
4647 #[allow(dead_code, unreachable_patterns)]
4648 fn _type_assertion(
4649 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4650 ) {
4651 match _t {
4652 alloy_sol_types::private::AssertTypeEq::<
4653 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4654 >(_) => {}
4655 }
4656 }
4657 #[automatically_derived]
4658 #[doc(hidden)]
4659 impl ::core::convert::From<transferOwnershipReturn>
4660 for UnderlyingRustTuple<'_> {
4661 fn from(value: transferOwnershipReturn) -> Self {
4662 ()
4663 }
4664 }
4665 #[automatically_derived]
4666 #[doc(hidden)]
4667 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4668 for transferOwnershipReturn {
4669 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4670 Self {}
4671 }
4672 }
4673 }
4674 #[automatically_derived]
4675 impl alloy_sol_types::SolCall for transferOwnershipCall {
4676 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4677 type Token<'a> = <Self::Parameters<
4678 'a,
4679 > as alloy_sol_types::SolType>::Token<'a>;
4680 type Return = transferOwnershipReturn;
4681 type ReturnTuple<'a> = ();
4682 type ReturnToken<'a> = <Self::ReturnTuple<
4683 'a,
4684 > as alloy_sol_types::SolType>::Token<'a>;
4685 const SIGNATURE: &'static str = "transferOwnership(address)";
4686 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
4687 #[inline]
4688 fn new<'a>(
4689 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4690 ) -> Self {
4691 tuple.into()
4692 }
4693 #[inline]
4694 fn tokenize(&self) -> Self::Token<'_> {
4695 (
4696 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4697 &self.newOwner,
4698 ),
4699 )
4700 }
4701 #[inline]
4702 fn abi_decode_returns(
4703 data: &[u8],
4704 validate: bool,
4705 ) -> alloy_sol_types::Result<Self::Return> {
4706 <Self::ReturnTuple<
4707 '_,
4708 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4709 .map(Into::into)
4710 }
4711 }
4712 };
4713 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4714 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4719 #[derive(Clone)]
4720 pub struct upgradeToAndCallCall {
4721 #[allow(missing_docs)]
4722 pub newImplementation: alloy::sol_types::private::Address,
4723 #[allow(missing_docs)]
4724 pub data: alloy::sol_types::private::Bytes,
4725 }
4726 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4728 #[derive(Clone)]
4729 pub struct upgradeToAndCallReturn {}
4730 #[allow(
4731 non_camel_case_types,
4732 non_snake_case,
4733 clippy::pub_underscore_fields,
4734 clippy::style
4735 )]
4736 const _: () = {
4737 use alloy::sol_types as alloy_sol_types;
4738 {
4739 #[doc(hidden)]
4740 type UnderlyingSolTuple<'a> = (
4741 alloy::sol_types::sol_data::Address,
4742 alloy::sol_types::sol_data::Bytes,
4743 );
4744 #[doc(hidden)]
4745 type UnderlyingRustTuple<'a> = (
4746 alloy::sol_types::private::Address,
4747 alloy::sol_types::private::Bytes,
4748 );
4749 #[cfg(test)]
4750 #[allow(dead_code, unreachable_patterns)]
4751 fn _type_assertion(
4752 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4753 ) {
4754 match _t {
4755 alloy_sol_types::private::AssertTypeEq::<
4756 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4757 >(_) => {}
4758 }
4759 }
4760 #[automatically_derived]
4761 #[doc(hidden)]
4762 impl ::core::convert::From<upgradeToAndCallCall>
4763 for UnderlyingRustTuple<'_> {
4764 fn from(value: upgradeToAndCallCall) -> Self {
4765 (value.newImplementation, value.data)
4766 }
4767 }
4768 #[automatically_derived]
4769 #[doc(hidden)]
4770 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4771 for upgradeToAndCallCall {
4772 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4773 Self {
4774 newImplementation: tuple.0,
4775 data: tuple.1,
4776 }
4777 }
4778 }
4779 }
4780 {
4781 #[doc(hidden)]
4782 type UnderlyingSolTuple<'a> = ();
4783 #[doc(hidden)]
4784 type UnderlyingRustTuple<'a> = ();
4785 #[cfg(test)]
4786 #[allow(dead_code, unreachable_patterns)]
4787 fn _type_assertion(
4788 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4789 ) {
4790 match _t {
4791 alloy_sol_types::private::AssertTypeEq::<
4792 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4793 >(_) => {}
4794 }
4795 }
4796 #[automatically_derived]
4797 #[doc(hidden)]
4798 impl ::core::convert::From<upgradeToAndCallReturn>
4799 for UnderlyingRustTuple<'_> {
4800 fn from(value: upgradeToAndCallReturn) -> Self {
4801 ()
4802 }
4803 }
4804 #[automatically_derived]
4805 #[doc(hidden)]
4806 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4807 for upgradeToAndCallReturn {
4808 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4809 Self {}
4810 }
4811 }
4812 }
4813 #[automatically_derived]
4814 impl alloy_sol_types::SolCall for upgradeToAndCallCall {
4815 type Parameters<'a> = (
4816 alloy::sol_types::sol_data::Address,
4817 alloy::sol_types::sol_data::Bytes,
4818 );
4819 type Token<'a> = <Self::Parameters<
4820 'a,
4821 > as alloy_sol_types::SolType>::Token<'a>;
4822 type Return = upgradeToAndCallReturn;
4823 type ReturnTuple<'a> = ();
4824 type ReturnToken<'a> = <Self::ReturnTuple<
4825 'a,
4826 > as alloy_sol_types::SolType>::Token<'a>;
4827 const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)";
4828 const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8];
4829 #[inline]
4830 fn new<'a>(
4831 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4832 ) -> Self {
4833 tuple.into()
4834 }
4835 #[inline]
4836 fn tokenize(&self) -> Self::Token<'_> {
4837 (
4838 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4839 &self.newImplementation,
4840 ),
4841 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
4842 &self.data,
4843 ),
4844 )
4845 }
4846 #[inline]
4847 fn abi_decode_returns(
4848 data: &[u8],
4849 validate: bool,
4850 ) -> alloy_sol_types::Result<Self::Return> {
4851 <Self::ReturnTuple<
4852 '_,
4853 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4854 .map(Into::into)
4855 }
4856 }
4857 };
4858 #[derive()]
4860 pub enum EspTokenCalls {
4861 #[allow(missing_docs)]
4862 UPGRADE_INTERFACE_VERSION(UPGRADE_INTERFACE_VERSIONCall),
4863 #[allow(missing_docs)]
4864 allowance(allowanceCall),
4865 #[allow(missing_docs)]
4866 approve(approveCall),
4867 #[allow(missing_docs)]
4868 balanceOf(balanceOfCall),
4869 #[allow(missing_docs)]
4870 decimals(decimalsCall),
4871 #[allow(missing_docs)]
4872 getVersion(getVersionCall),
4873 #[allow(missing_docs)]
4874 initialize(initializeCall),
4875 #[allow(missing_docs)]
4876 name(nameCall),
4877 #[allow(missing_docs)]
4878 owner(ownerCall),
4879 #[allow(missing_docs)]
4880 proxiableUUID(proxiableUUIDCall),
4881 #[allow(missing_docs)]
4882 renounceOwnership(renounceOwnershipCall),
4883 #[allow(missing_docs)]
4884 symbol(symbolCall),
4885 #[allow(missing_docs)]
4886 totalSupply(totalSupplyCall),
4887 #[allow(missing_docs)]
4888 transfer(transferCall),
4889 #[allow(missing_docs)]
4890 transferFrom(transferFromCall),
4891 #[allow(missing_docs)]
4892 transferOwnership(transferOwnershipCall),
4893 #[allow(missing_docs)]
4894 upgradeToAndCall(upgradeToAndCallCall),
4895 }
4896 #[automatically_derived]
4897 impl EspTokenCalls {
4898 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4905 [6u8, 253u8, 222u8, 3u8],
4906 [9u8, 94u8, 167u8, 179u8],
4907 [13u8, 142u8, 110u8, 44u8],
4908 [24u8, 22u8, 13u8, 221u8],
4909 [35u8, 184u8, 114u8, 221u8],
4910 [49u8, 60u8, 229u8, 103u8],
4911 [79u8, 30u8, 242u8, 134u8],
4912 [82u8, 209u8, 144u8, 45u8],
4913 [112u8, 160u8, 130u8, 49u8],
4914 [113u8, 80u8, 24u8, 166u8],
4915 [141u8, 165u8, 203u8, 91u8],
4916 [149u8, 216u8, 155u8, 65u8],
4917 [154u8, 184u8, 54u8, 126u8],
4918 [169u8, 5u8, 156u8, 187u8],
4919 [173u8, 60u8, 177u8, 204u8],
4920 [221u8, 98u8, 237u8, 62u8],
4921 [242u8, 253u8, 227u8, 139u8],
4922 ];
4923 }
4924 #[automatically_derived]
4925 impl alloy_sol_types::SolInterface for EspTokenCalls {
4926 const NAME: &'static str = "EspTokenCalls";
4927 const MIN_DATA_LENGTH: usize = 0usize;
4928 const COUNT: usize = 17usize;
4929 #[inline]
4930 fn selector(&self) -> [u8; 4] {
4931 match self {
4932 Self::UPGRADE_INTERFACE_VERSION(_) => {
4933 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SELECTOR
4934 }
4935 Self::allowance(_) => {
4936 <allowanceCall as alloy_sol_types::SolCall>::SELECTOR
4937 }
4938 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
4939 Self::balanceOf(_) => {
4940 <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR
4941 }
4942 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
4943 Self::getVersion(_) => {
4944 <getVersionCall as alloy_sol_types::SolCall>::SELECTOR
4945 }
4946 Self::initialize(_) => {
4947 <initializeCall as alloy_sol_types::SolCall>::SELECTOR
4948 }
4949 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
4950 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
4951 Self::proxiableUUID(_) => {
4952 <proxiableUUIDCall as alloy_sol_types::SolCall>::SELECTOR
4953 }
4954 Self::renounceOwnership(_) => {
4955 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4956 }
4957 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
4958 Self::totalSupply(_) => {
4959 <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR
4960 }
4961 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
4962 Self::transferFrom(_) => {
4963 <transferFromCall as alloy_sol_types::SolCall>::SELECTOR
4964 }
4965 Self::transferOwnership(_) => {
4966 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4967 }
4968 Self::upgradeToAndCall(_) => {
4969 <upgradeToAndCallCall as alloy_sol_types::SolCall>::SELECTOR
4970 }
4971 }
4972 }
4973 #[inline]
4974 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4975 Self::SELECTORS.get(i).copied()
4976 }
4977 #[inline]
4978 fn valid_selector(selector: [u8; 4]) -> bool {
4979 Self::SELECTORS.binary_search(&selector).is_ok()
4980 }
4981 #[inline]
4982 #[allow(non_snake_case)]
4983 fn abi_decode_raw(
4984 selector: [u8; 4],
4985 data: &[u8],
4986 validate: bool,
4987 ) -> alloy_sol_types::Result<Self> {
4988 static DECODE_SHIMS: &[fn(
4989 &[u8],
4990 bool,
4991 ) -> alloy_sol_types::Result<EspTokenCalls>] = &[
4992 {
4993 fn name(
4994 data: &[u8],
4995 validate: bool,
4996 ) -> alloy_sol_types::Result<EspTokenCalls> {
4997 <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(
4998 data,
4999 validate,
5000 )
5001 .map(EspTokenCalls::name)
5002 }
5003 name
5004 },
5005 {
5006 fn approve(
5007 data: &[u8],
5008 validate: bool,
5009 ) -> alloy_sol_types::Result<EspTokenCalls> {
5010 <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(
5011 data,
5012 validate,
5013 )
5014 .map(EspTokenCalls::approve)
5015 }
5016 approve
5017 },
5018 {
5019 fn getVersion(
5020 data: &[u8],
5021 validate: bool,
5022 ) -> alloy_sol_types::Result<EspTokenCalls> {
5023 <getVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(
5024 data,
5025 validate,
5026 )
5027 .map(EspTokenCalls::getVersion)
5028 }
5029 getVersion
5030 },
5031 {
5032 fn totalSupply(
5033 data: &[u8],
5034 validate: bool,
5035 ) -> alloy_sol_types::Result<EspTokenCalls> {
5036 <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(
5037 data,
5038 validate,
5039 )
5040 .map(EspTokenCalls::totalSupply)
5041 }
5042 totalSupply
5043 },
5044 {
5045 fn transferFrom(
5046 data: &[u8],
5047 validate: bool,
5048 ) -> alloy_sol_types::Result<EspTokenCalls> {
5049 <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(
5050 data,
5051 validate,
5052 )
5053 .map(EspTokenCalls::transferFrom)
5054 }
5055 transferFrom
5056 },
5057 {
5058 fn decimals(
5059 data: &[u8],
5060 validate: bool,
5061 ) -> alloy_sol_types::Result<EspTokenCalls> {
5062 <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(
5063 data,
5064 validate,
5065 )
5066 .map(EspTokenCalls::decimals)
5067 }
5068 decimals
5069 },
5070 {
5071 fn upgradeToAndCall(
5072 data: &[u8],
5073 validate: bool,
5074 ) -> alloy_sol_types::Result<EspTokenCalls> {
5075 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(
5076 data,
5077 validate,
5078 )
5079 .map(EspTokenCalls::upgradeToAndCall)
5080 }
5081 upgradeToAndCall
5082 },
5083 {
5084 fn proxiableUUID(
5085 data: &[u8],
5086 validate: bool,
5087 ) -> alloy_sol_types::Result<EspTokenCalls> {
5088 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
5089 data,
5090 validate,
5091 )
5092 .map(EspTokenCalls::proxiableUUID)
5093 }
5094 proxiableUUID
5095 },
5096 {
5097 fn balanceOf(
5098 data: &[u8],
5099 validate: bool,
5100 ) -> alloy_sol_types::Result<EspTokenCalls> {
5101 <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(
5102 data,
5103 validate,
5104 )
5105 .map(EspTokenCalls::balanceOf)
5106 }
5107 balanceOf
5108 },
5109 {
5110 fn renounceOwnership(
5111 data: &[u8],
5112 validate: bool,
5113 ) -> alloy_sol_types::Result<EspTokenCalls> {
5114 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
5115 data,
5116 validate,
5117 )
5118 .map(EspTokenCalls::renounceOwnership)
5119 }
5120 renounceOwnership
5121 },
5122 {
5123 fn owner(
5124 data: &[u8],
5125 validate: bool,
5126 ) -> alloy_sol_types::Result<EspTokenCalls> {
5127 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(
5128 data,
5129 validate,
5130 )
5131 .map(EspTokenCalls::owner)
5132 }
5133 owner
5134 },
5135 {
5136 fn symbol(
5137 data: &[u8],
5138 validate: bool,
5139 ) -> alloy_sol_types::Result<EspTokenCalls> {
5140 <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(
5141 data,
5142 validate,
5143 )
5144 .map(EspTokenCalls::symbol)
5145 }
5146 symbol
5147 },
5148 {
5149 fn initialize(
5150 data: &[u8],
5151 validate: bool,
5152 ) -> alloy_sol_types::Result<EspTokenCalls> {
5153 <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
5154 data,
5155 validate,
5156 )
5157 .map(EspTokenCalls::initialize)
5158 }
5159 initialize
5160 },
5161 {
5162 fn transfer(
5163 data: &[u8],
5164 validate: bool,
5165 ) -> alloy_sol_types::Result<EspTokenCalls> {
5166 <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(
5167 data,
5168 validate,
5169 )
5170 .map(EspTokenCalls::transfer)
5171 }
5172 transfer
5173 },
5174 {
5175 fn UPGRADE_INTERFACE_VERSION(
5176 data: &[u8],
5177 validate: bool,
5178 ) -> alloy_sol_types::Result<EspTokenCalls> {
5179 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(
5180 data,
5181 validate,
5182 )
5183 .map(EspTokenCalls::UPGRADE_INTERFACE_VERSION)
5184 }
5185 UPGRADE_INTERFACE_VERSION
5186 },
5187 {
5188 fn allowance(
5189 data: &[u8],
5190 validate: bool,
5191 ) -> alloy_sol_types::Result<EspTokenCalls> {
5192 <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(
5193 data,
5194 validate,
5195 )
5196 .map(EspTokenCalls::allowance)
5197 }
5198 allowance
5199 },
5200 {
5201 fn transferOwnership(
5202 data: &[u8],
5203 validate: bool,
5204 ) -> alloy_sol_types::Result<EspTokenCalls> {
5205 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
5206 data,
5207 validate,
5208 )
5209 .map(EspTokenCalls::transferOwnership)
5210 }
5211 transferOwnership
5212 },
5213 ];
5214 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5215 return Err(
5216 alloy_sol_types::Error::unknown_selector(
5217 <Self as alloy_sol_types::SolInterface>::NAME,
5218 selector,
5219 ),
5220 );
5221 };
5222 DECODE_SHIMS[idx](data, validate)
5223 }
5224 #[inline]
5225 fn abi_encoded_size(&self) -> usize {
5226 match self {
5227 Self::UPGRADE_INTERFACE_VERSION(inner) => {
5228 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
5229 inner,
5230 )
5231 }
5232 Self::allowance(inner) => {
5233 <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5234 }
5235 Self::approve(inner) => {
5236 <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5237 }
5238 Self::balanceOf(inner) => {
5239 <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5240 }
5241 Self::decimals(inner) => {
5242 <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5243 }
5244 Self::getVersion(inner) => {
5245 <getVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5246 }
5247 Self::initialize(inner) => {
5248 <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5249 }
5250 Self::name(inner) => {
5251 <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5252 }
5253 Self::owner(inner) => {
5254 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5255 }
5256 Self::proxiableUUID(inner) => {
5257 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encoded_size(
5258 inner,
5259 )
5260 }
5261 Self::renounceOwnership(inner) => {
5262 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
5263 inner,
5264 )
5265 }
5266 Self::symbol(inner) => {
5267 <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5268 }
5269 Self::totalSupply(inner) => {
5270 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(
5271 inner,
5272 )
5273 }
5274 Self::transfer(inner) => {
5275 <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5276 }
5277 Self::transferFrom(inner) => {
5278 <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
5279 inner,
5280 )
5281 }
5282 Self::transferOwnership(inner) => {
5283 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
5284 inner,
5285 )
5286 }
5287 Self::upgradeToAndCall(inner) => {
5288 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(
5289 inner,
5290 )
5291 }
5292 }
5293 }
5294 #[inline]
5295 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5296 match self {
5297 Self::UPGRADE_INTERFACE_VERSION(inner) => {
5298 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
5299 inner,
5300 out,
5301 )
5302 }
5303 Self::allowance(inner) => {
5304 <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
5305 inner,
5306 out,
5307 )
5308 }
5309 Self::approve(inner) => {
5310 <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5311 }
5312 Self::balanceOf(inner) => {
5313 <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(
5314 inner,
5315 out,
5316 )
5317 }
5318 Self::decimals(inner) => {
5319 <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(
5320 inner,
5321 out,
5322 )
5323 }
5324 Self::getVersion(inner) => {
5325 <getVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
5326 inner,
5327 out,
5328 )
5329 }
5330 Self::initialize(inner) => {
5331 <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
5332 inner,
5333 out,
5334 )
5335 }
5336 Self::name(inner) => {
5337 <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5338 }
5339 Self::owner(inner) => {
5340 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5341 }
5342 Self::proxiableUUID(inner) => {
5343 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encode_raw(
5344 inner,
5345 out,
5346 )
5347 }
5348 Self::renounceOwnership(inner) => {
5349 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
5350 inner,
5351 out,
5352 )
5353 }
5354 Self::symbol(inner) => {
5355 <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5356 }
5357 Self::totalSupply(inner) => {
5358 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(
5359 inner,
5360 out,
5361 )
5362 }
5363 Self::transfer(inner) => {
5364 <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(
5365 inner,
5366 out,
5367 )
5368 }
5369 Self::transferFrom(inner) => {
5370 <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
5371 inner,
5372 out,
5373 )
5374 }
5375 Self::transferOwnership(inner) => {
5376 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
5377 inner,
5378 out,
5379 )
5380 }
5381 Self::upgradeToAndCall(inner) => {
5382 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(
5383 inner,
5384 out,
5385 )
5386 }
5387 }
5388 }
5389 }
5390 #[derive(Debug, PartialEq, Eq, Hash)]
5392 pub enum EspTokenErrors {
5393 #[allow(missing_docs)]
5394 AddressEmptyCode(AddressEmptyCode),
5395 #[allow(missing_docs)]
5396 ERC1967InvalidImplementation(ERC1967InvalidImplementation),
5397 #[allow(missing_docs)]
5398 ERC1967NonPayable(ERC1967NonPayable),
5399 #[allow(missing_docs)]
5400 ERC20InsufficientAllowance(ERC20InsufficientAllowance),
5401 #[allow(missing_docs)]
5402 ERC20InsufficientBalance(ERC20InsufficientBalance),
5403 #[allow(missing_docs)]
5404 ERC20InvalidApprover(ERC20InvalidApprover),
5405 #[allow(missing_docs)]
5406 ERC20InvalidReceiver(ERC20InvalidReceiver),
5407 #[allow(missing_docs)]
5408 ERC20InvalidSender(ERC20InvalidSender),
5409 #[allow(missing_docs)]
5410 ERC20InvalidSpender(ERC20InvalidSpender),
5411 #[allow(missing_docs)]
5412 FailedInnerCall(FailedInnerCall),
5413 #[allow(missing_docs)]
5414 InvalidInitialization(InvalidInitialization),
5415 #[allow(missing_docs)]
5416 NotInitializing(NotInitializing),
5417 #[allow(missing_docs)]
5418 OwnableInvalidOwner(OwnableInvalidOwner),
5419 #[allow(missing_docs)]
5420 OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
5421 #[allow(missing_docs)]
5422 UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext),
5423 #[allow(missing_docs)]
5424 UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID),
5425 }
5426 #[automatically_derived]
5427 impl EspTokenErrors {
5428 pub const SELECTORS: &'static [[u8; 4usize]] = &[
5435 [17u8, 140u8, 218u8, 167u8],
5436 [20u8, 37u8, 234u8, 66u8],
5437 [30u8, 79u8, 189u8, 247u8],
5438 [76u8, 156u8, 140u8, 227u8],
5439 [148u8, 40u8, 13u8, 98u8],
5440 [150u8, 198u8, 253u8, 30u8],
5441 [153u8, 150u8, 179u8, 21u8],
5442 [170u8, 29u8, 73u8, 164u8],
5443 [179u8, 152u8, 151u8, 159u8],
5444 [215u8, 230u8, 188u8, 248u8],
5445 [224u8, 124u8, 141u8, 186u8],
5446 [228u8, 80u8, 211u8, 140u8],
5447 [230u8, 2u8, 223u8, 5u8],
5448 [236u8, 68u8, 47u8, 5u8],
5449 [249u8, 46u8, 232u8, 169u8],
5450 [251u8, 143u8, 65u8, 178u8],
5451 ];
5452 }
5453 #[automatically_derived]
5454 impl alloy_sol_types::SolInterface for EspTokenErrors {
5455 const NAME: &'static str = "EspTokenErrors";
5456 const MIN_DATA_LENGTH: usize = 0usize;
5457 const COUNT: usize = 16usize;
5458 #[inline]
5459 fn selector(&self) -> [u8; 4] {
5460 match self {
5461 Self::AddressEmptyCode(_) => {
5462 <AddressEmptyCode as alloy_sol_types::SolError>::SELECTOR
5463 }
5464 Self::ERC1967InvalidImplementation(_) => {
5465 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SELECTOR
5466 }
5467 Self::ERC1967NonPayable(_) => {
5468 <ERC1967NonPayable as alloy_sol_types::SolError>::SELECTOR
5469 }
5470 Self::ERC20InsufficientAllowance(_) => {
5471 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::SELECTOR
5472 }
5473 Self::ERC20InsufficientBalance(_) => {
5474 <ERC20InsufficientBalance as alloy_sol_types::SolError>::SELECTOR
5475 }
5476 Self::ERC20InvalidApprover(_) => {
5477 <ERC20InvalidApprover as alloy_sol_types::SolError>::SELECTOR
5478 }
5479 Self::ERC20InvalidReceiver(_) => {
5480 <ERC20InvalidReceiver as alloy_sol_types::SolError>::SELECTOR
5481 }
5482 Self::ERC20InvalidSender(_) => {
5483 <ERC20InvalidSender as alloy_sol_types::SolError>::SELECTOR
5484 }
5485 Self::ERC20InvalidSpender(_) => {
5486 <ERC20InvalidSpender as alloy_sol_types::SolError>::SELECTOR
5487 }
5488 Self::FailedInnerCall(_) => {
5489 <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
5490 }
5491 Self::InvalidInitialization(_) => {
5492 <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
5493 }
5494 Self::NotInitializing(_) => {
5495 <NotInitializing as alloy_sol_types::SolError>::SELECTOR
5496 }
5497 Self::OwnableInvalidOwner(_) => {
5498 <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
5499 }
5500 Self::OwnableUnauthorizedAccount(_) => {
5501 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
5502 }
5503 Self::UUPSUnauthorizedCallContext(_) => {
5504 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SELECTOR
5505 }
5506 Self::UUPSUnsupportedProxiableUUID(_) => {
5507 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SELECTOR
5508 }
5509 }
5510 }
5511 #[inline]
5512 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5513 Self::SELECTORS.get(i).copied()
5514 }
5515 #[inline]
5516 fn valid_selector(selector: [u8; 4]) -> bool {
5517 Self::SELECTORS.binary_search(&selector).is_ok()
5518 }
5519 #[inline]
5520 #[allow(non_snake_case)]
5521 fn abi_decode_raw(
5522 selector: [u8; 4],
5523 data: &[u8],
5524 validate: bool,
5525 ) -> alloy_sol_types::Result<Self> {
5526 static DECODE_SHIMS: &[fn(
5527 &[u8],
5528 bool,
5529 ) -> alloy_sol_types::Result<EspTokenErrors>] = &[
5530 {
5531 fn OwnableUnauthorizedAccount(
5532 data: &[u8],
5533 validate: bool,
5534 ) -> alloy_sol_types::Result<EspTokenErrors> {
5535 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
5536 data,
5537 validate,
5538 )
5539 .map(EspTokenErrors::OwnableUnauthorizedAccount)
5540 }
5541 OwnableUnauthorizedAccount
5542 },
5543 {
5544 fn FailedInnerCall(
5545 data: &[u8],
5546 validate: bool,
5547 ) -> alloy_sol_types::Result<EspTokenErrors> {
5548 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(
5549 data,
5550 validate,
5551 )
5552 .map(EspTokenErrors::FailedInnerCall)
5553 }
5554 FailedInnerCall
5555 },
5556 {
5557 fn OwnableInvalidOwner(
5558 data: &[u8],
5559 validate: bool,
5560 ) -> alloy_sol_types::Result<EspTokenErrors> {
5561 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
5562 data,
5563 validate,
5564 )
5565 .map(EspTokenErrors::OwnableInvalidOwner)
5566 }
5567 OwnableInvalidOwner
5568 },
5569 {
5570 fn ERC1967InvalidImplementation(
5571 data: &[u8],
5572 validate: bool,
5573 ) -> alloy_sol_types::Result<EspTokenErrors> {
5574 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_decode_raw(
5575 data,
5576 validate,
5577 )
5578 .map(EspTokenErrors::ERC1967InvalidImplementation)
5579 }
5580 ERC1967InvalidImplementation
5581 },
5582 {
5583 fn ERC20InvalidSpender(
5584 data: &[u8],
5585 validate: bool,
5586 ) -> alloy_sol_types::Result<EspTokenErrors> {
5587 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_decode_raw(
5588 data,
5589 validate,
5590 )
5591 .map(EspTokenErrors::ERC20InvalidSpender)
5592 }
5593 ERC20InvalidSpender
5594 },
5595 {
5596 fn ERC20InvalidSender(
5597 data: &[u8],
5598 validate: bool,
5599 ) -> alloy_sol_types::Result<EspTokenErrors> {
5600 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_decode_raw(
5601 data,
5602 validate,
5603 )
5604 .map(EspTokenErrors::ERC20InvalidSender)
5605 }
5606 ERC20InvalidSender
5607 },
5608 {
5609 fn AddressEmptyCode(
5610 data: &[u8],
5611 validate: bool,
5612 ) -> alloy_sol_types::Result<EspTokenErrors> {
5613 <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw(
5614 data,
5615 validate,
5616 )
5617 .map(EspTokenErrors::AddressEmptyCode)
5618 }
5619 AddressEmptyCode
5620 },
5621 {
5622 fn UUPSUnsupportedProxiableUUID(
5623 data: &[u8],
5624 validate: bool,
5625 ) -> alloy_sol_types::Result<EspTokenErrors> {
5626 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_decode_raw(
5627 data,
5628 validate,
5629 )
5630 .map(EspTokenErrors::UUPSUnsupportedProxiableUUID)
5631 }
5632 UUPSUnsupportedProxiableUUID
5633 },
5634 {
5635 fn ERC1967NonPayable(
5636 data: &[u8],
5637 validate: bool,
5638 ) -> alloy_sol_types::Result<EspTokenErrors> {
5639 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_decode_raw(
5640 data,
5641 validate,
5642 )
5643 .map(EspTokenErrors::ERC1967NonPayable)
5644 }
5645 ERC1967NonPayable
5646 },
5647 {
5648 fn NotInitializing(
5649 data: &[u8],
5650 validate: bool,
5651 ) -> alloy_sol_types::Result<EspTokenErrors> {
5652 <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw(
5653 data,
5654 validate,
5655 )
5656 .map(EspTokenErrors::NotInitializing)
5657 }
5658 NotInitializing
5659 },
5660 {
5661 fn UUPSUnauthorizedCallContext(
5662 data: &[u8],
5663 validate: bool,
5664 ) -> alloy_sol_types::Result<EspTokenErrors> {
5665 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_decode_raw(
5666 data,
5667 validate,
5668 )
5669 .map(EspTokenErrors::UUPSUnauthorizedCallContext)
5670 }
5671 UUPSUnauthorizedCallContext
5672 },
5673 {
5674 fn ERC20InsufficientBalance(
5675 data: &[u8],
5676 validate: bool,
5677 ) -> alloy_sol_types::Result<EspTokenErrors> {
5678 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw(
5679 data,
5680 validate,
5681 )
5682 .map(EspTokenErrors::ERC20InsufficientBalance)
5683 }
5684 ERC20InsufficientBalance
5685 },
5686 {
5687 fn ERC20InvalidApprover(
5688 data: &[u8],
5689 validate: bool,
5690 ) -> alloy_sol_types::Result<EspTokenErrors> {
5691 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_decode_raw(
5692 data,
5693 validate,
5694 )
5695 .map(EspTokenErrors::ERC20InvalidApprover)
5696 }
5697 ERC20InvalidApprover
5698 },
5699 {
5700 fn ERC20InvalidReceiver(
5701 data: &[u8],
5702 validate: bool,
5703 ) -> alloy_sol_types::Result<EspTokenErrors> {
5704 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_decode_raw(
5705 data,
5706 validate,
5707 )
5708 .map(EspTokenErrors::ERC20InvalidReceiver)
5709 }
5710 ERC20InvalidReceiver
5711 },
5712 {
5713 fn InvalidInitialization(
5714 data: &[u8],
5715 validate: bool,
5716 ) -> alloy_sol_types::Result<EspTokenErrors> {
5717 <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw(
5718 data,
5719 validate,
5720 )
5721 .map(EspTokenErrors::InvalidInitialization)
5722 }
5723 InvalidInitialization
5724 },
5725 {
5726 fn ERC20InsufficientAllowance(
5727 data: &[u8],
5728 validate: bool,
5729 ) -> alloy_sol_types::Result<EspTokenErrors> {
5730 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_decode_raw(
5731 data,
5732 validate,
5733 )
5734 .map(EspTokenErrors::ERC20InsufficientAllowance)
5735 }
5736 ERC20InsufficientAllowance
5737 },
5738 ];
5739 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5740 return Err(
5741 alloy_sol_types::Error::unknown_selector(
5742 <Self as alloy_sol_types::SolInterface>::NAME,
5743 selector,
5744 ),
5745 );
5746 };
5747 DECODE_SHIMS[idx](data, validate)
5748 }
5749 #[inline]
5750 fn abi_encoded_size(&self) -> usize {
5751 match self {
5752 Self::AddressEmptyCode(inner) => {
5753 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encoded_size(
5754 inner,
5755 )
5756 }
5757 Self::ERC1967InvalidImplementation(inner) => {
5758 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encoded_size(
5759 inner,
5760 )
5761 }
5762 Self::ERC1967NonPayable(inner) => {
5763 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encoded_size(
5764 inner,
5765 )
5766 }
5767 Self::ERC20InsufficientAllowance(inner) => {
5768 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_encoded_size(
5769 inner,
5770 )
5771 }
5772 Self::ERC20InsufficientBalance(inner) => {
5773 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_encoded_size(
5774 inner,
5775 )
5776 }
5777 Self::ERC20InvalidApprover(inner) => {
5778 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_encoded_size(
5779 inner,
5780 )
5781 }
5782 Self::ERC20InvalidReceiver(inner) => {
5783 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_encoded_size(
5784 inner,
5785 )
5786 }
5787 Self::ERC20InvalidSender(inner) => {
5788 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_encoded_size(
5789 inner,
5790 )
5791 }
5792 Self::ERC20InvalidSpender(inner) => {
5793 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_encoded_size(
5794 inner,
5795 )
5796 }
5797 Self::FailedInnerCall(inner) => {
5798 <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(
5799 inner,
5800 )
5801 }
5802 Self::InvalidInitialization(inner) => {
5803 <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(
5804 inner,
5805 )
5806 }
5807 Self::NotInitializing(inner) => {
5808 <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(
5809 inner,
5810 )
5811 }
5812 Self::OwnableInvalidOwner(inner) => {
5813 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
5814 inner,
5815 )
5816 }
5817 Self::OwnableUnauthorizedAccount(inner) => {
5818 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
5819 inner,
5820 )
5821 }
5822 Self::UUPSUnauthorizedCallContext(inner) => {
5823 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encoded_size(
5824 inner,
5825 )
5826 }
5827 Self::UUPSUnsupportedProxiableUUID(inner) => {
5828 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encoded_size(
5829 inner,
5830 )
5831 }
5832 }
5833 }
5834 #[inline]
5835 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5836 match self {
5837 Self::AddressEmptyCode(inner) => {
5838 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encode_raw(
5839 inner,
5840 out,
5841 )
5842 }
5843 Self::ERC1967InvalidImplementation(inner) => {
5844 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encode_raw(
5845 inner,
5846 out,
5847 )
5848 }
5849 Self::ERC1967NonPayable(inner) => {
5850 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encode_raw(
5851 inner,
5852 out,
5853 )
5854 }
5855 Self::ERC20InsufficientAllowance(inner) => {
5856 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_encode_raw(
5857 inner,
5858 out,
5859 )
5860 }
5861 Self::ERC20InsufficientBalance(inner) => {
5862 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_encode_raw(
5863 inner,
5864 out,
5865 )
5866 }
5867 Self::ERC20InvalidApprover(inner) => {
5868 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_encode_raw(
5869 inner,
5870 out,
5871 )
5872 }
5873 Self::ERC20InvalidReceiver(inner) => {
5874 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_encode_raw(
5875 inner,
5876 out,
5877 )
5878 }
5879 Self::ERC20InvalidSender(inner) => {
5880 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_encode_raw(
5881 inner,
5882 out,
5883 )
5884 }
5885 Self::ERC20InvalidSpender(inner) => {
5886 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_encode_raw(
5887 inner,
5888 out,
5889 )
5890 }
5891 Self::FailedInnerCall(inner) => {
5892 <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(
5893 inner,
5894 out,
5895 )
5896 }
5897 Self::InvalidInitialization(inner) => {
5898 <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(
5899 inner,
5900 out,
5901 )
5902 }
5903 Self::NotInitializing(inner) => {
5904 <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(
5905 inner,
5906 out,
5907 )
5908 }
5909 Self::OwnableInvalidOwner(inner) => {
5910 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
5911 inner,
5912 out,
5913 )
5914 }
5915 Self::OwnableUnauthorizedAccount(inner) => {
5916 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
5917 inner,
5918 out,
5919 )
5920 }
5921 Self::UUPSUnauthorizedCallContext(inner) => {
5922 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encode_raw(
5923 inner,
5924 out,
5925 )
5926 }
5927 Self::UUPSUnsupportedProxiableUUID(inner) => {
5928 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encode_raw(
5929 inner,
5930 out,
5931 )
5932 }
5933 }
5934 }
5935 }
5936 #[derive(Debug, PartialEq, Eq, Hash)]
5938 pub enum EspTokenEvents {
5939 #[allow(missing_docs)]
5940 Approval(Approval),
5941 #[allow(missing_docs)]
5942 Initialized(Initialized),
5943 #[allow(missing_docs)]
5944 OwnershipTransferred(OwnershipTransferred),
5945 #[allow(missing_docs)]
5946 Transfer(Transfer),
5947 #[allow(missing_docs)]
5948 Upgrade(Upgrade),
5949 #[allow(missing_docs)]
5950 Upgraded(Upgraded),
5951 }
5952 #[automatically_derived]
5953 impl EspTokenEvents {
5954 pub const SELECTORS: &'static [[u8; 32usize]] = &[
5961 [
5962 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
5963 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
5964 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
5965 ],
5966 [
5967 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8,
5968 66u8, 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8,
5969 41u8, 30u8, 91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
5970 ],
5971 [
5972 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
5973 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8,
5974 12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
5975 ],
5976 [
5977 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
5978 19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
5979 33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
5980 ],
5981 [
5982 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8,
5983 176u8, 104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8,
5984 196u8, 161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
5985 ],
5986 [
5987 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8,
5988 154u8, 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8,
5989 185u8, 62u8, 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
5990 ],
5991 ];
5992 }
5993 #[automatically_derived]
5994 impl alloy_sol_types::SolEventInterface for EspTokenEvents {
5995 const NAME: &'static str = "EspTokenEvents";
5996 const COUNT: usize = 6usize;
5997 fn decode_raw_log(
5998 topics: &[alloy_sol_types::Word],
5999 data: &[u8],
6000 validate: bool,
6001 ) -> alloy_sol_types::Result<Self> {
6002 match topics.first().copied() {
6003 Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6004 <Approval as alloy_sol_types::SolEvent>::decode_raw_log(
6005 topics,
6006 data,
6007 validate,
6008 )
6009 .map(Self::Approval)
6010 }
6011 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6012 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
6013 topics,
6014 data,
6015 validate,
6016 )
6017 .map(Self::Initialized)
6018 }
6019 Some(
6020 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
6021 ) => {
6022 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
6023 topics,
6024 data,
6025 validate,
6026 )
6027 .map(Self::OwnershipTransferred)
6028 }
6029 Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6030 <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(
6031 topics,
6032 data,
6033 validate,
6034 )
6035 .map(Self::Transfer)
6036 }
6037 Some(<Upgrade as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6038 <Upgrade as alloy_sol_types::SolEvent>::decode_raw_log(
6039 topics,
6040 data,
6041 validate,
6042 )
6043 .map(Self::Upgrade)
6044 }
6045 Some(<Upgraded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6046 <Upgraded as alloy_sol_types::SolEvent>::decode_raw_log(
6047 topics,
6048 data,
6049 validate,
6050 )
6051 .map(Self::Upgraded)
6052 }
6053 _ => {
6054 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
6055 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
6056 log: alloy_sol_types::private::Box::new(
6057 alloy_sol_types::private::LogData::new_unchecked(
6058 topics.to_vec(),
6059 data.to_vec().into(),
6060 ),
6061 ),
6062 })
6063 }
6064 }
6065 }
6066 }
6067 #[automatically_derived]
6068 impl alloy_sol_types::private::IntoLogData for EspTokenEvents {
6069 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6070 match self {
6071 Self::Approval(inner) => {
6072 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6073 }
6074 Self::Initialized(inner) => {
6075 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6076 }
6077 Self::OwnershipTransferred(inner) => {
6078 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6079 }
6080 Self::Transfer(inner) => {
6081 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6082 }
6083 Self::Upgrade(inner) => {
6084 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6085 }
6086 Self::Upgraded(inner) => {
6087 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6088 }
6089 }
6090 }
6091 fn into_log_data(self) -> alloy_sol_types::private::LogData {
6092 match self {
6093 Self::Approval(inner) => {
6094 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6095 }
6096 Self::Initialized(inner) => {
6097 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6098 }
6099 Self::OwnershipTransferred(inner) => {
6100 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6101 }
6102 Self::Transfer(inner) => {
6103 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6104 }
6105 Self::Upgrade(inner) => {
6106 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6107 }
6108 Self::Upgraded(inner) => {
6109 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6110 }
6111 }
6112 }
6113 }
6114 use alloy::contract as alloy_contract;
6115 #[inline]
6119 pub const fn new<
6120 T: alloy_contract::private::Transport + ::core::clone::Clone,
6121 P: alloy_contract::private::Provider<T, N>,
6122 N: alloy_contract::private::Network,
6123 >(
6124 address: alloy_sol_types::private::Address,
6125 provider: P,
6126 ) -> EspTokenInstance<T, P, N> {
6127 EspTokenInstance::<T, P, N>::new(address, provider)
6128 }
6129 #[inline]
6135 pub fn deploy<
6136 T: alloy_contract::private::Transport + ::core::clone::Clone,
6137 P: alloy_contract::private::Provider<T, N>,
6138 N: alloy_contract::private::Network,
6139 >(
6140 provider: P,
6141 ) -> impl ::core::future::Future<
6142 Output = alloy_contract::Result<EspTokenInstance<T, P, N>>,
6143 > {
6144 EspTokenInstance::<T, P, N>::deploy(provider)
6145 }
6146 #[inline]
6152 pub fn deploy_builder<
6153 T: alloy_contract::private::Transport + ::core::clone::Clone,
6154 P: alloy_contract::private::Provider<T, N>,
6155 N: alloy_contract::private::Network,
6156 >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
6157 EspTokenInstance::<T, P, N>::deploy_builder(provider)
6158 }
6159 #[derive(Clone)]
6171 pub struct EspTokenInstance<T, P, N = alloy_contract::private::Ethereum> {
6172 address: alloy_sol_types::private::Address,
6173 provider: P,
6174 _network_transport: ::core::marker::PhantomData<(N, T)>,
6175 }
6176 #[automatically_derived]
6177 impl<T, P, N> ::core::fmt::Debug for EspTokenInstance<T, P, N> {
6178 #[inline]
6179 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6180 f.debug_tuple("EspTokenInstance").field(&self.address).finish()
6181 }
6182 }
6183 #[automatically_derived]
6185 impl<
6186 T: alloy_contract::private::Transport + ::core::clone::Clone,
6187 P: alloy_contract::private::Provider<T, N>,
6188 N: alloy_contract::private::Network,
6189 > EspTokenInstance<T, P, N> {
6190 #[inline]
6194 pub const fn new(
6195 address: alloy_sol_types::private::Address,
6196 provider: P,
6197 ) -> Self {
6198 Self {
6199 address,
6200 provider,
6201 _network_transport: ::core::marker::PhantomData,
6202 }
6203 }
6204 #[inline]
6210 pub async fn deploy(
6211 provider: P,
6212 ) -> alloy_contract::Result<EspTokenInstance<T, P, N>> {
6213 let call_builder = Self::deploy_builder(provider);
6214 let contract_address = call_builder.deploy().await?;
6215 Ok(Self::new(contract_address, call_builder.provider))
6216 }
6217 #[inline]
6223 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
6224 alloy_contract::RawCallBuilder::new_raw_deploy(
6225 provider,
6226 ::core::clone::Clone::clone(&BYTECODE),
6227 )
6228 }
6229 #[inline]
6231 pub const fn address(&self) -> &alloy_sol_types::private::Address {
6232 &self.address
6233 }
6234 #[inline]
6236 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
6237 self.address = address;
6238 }
6239 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
6241 self.set_address(address);
6242 self
6243 }
6244 #[inline]
6246 pub const fn provider(&self) -> &P {
6247 &self.provider
6248 }
6249 }
6250 impl<T, P: ::core::clone::Clone, N> EspTokenInstance<T, &P, N> {
6251 #[inline]
6253 pub fn with_cloned_provider(self) -> EspTokenInstance<T, P, N> {
6254 EspTokenInstance {
6255 address: self.address,
6256 provider: ::core::clone::Clone::clone(&self.provider),
6257 _network_transport: ::core::marker::PhantomData,
6258 }
6259 }
6260 }
6261 #[automatically_derived]
6263 impl<
6264 T: alloy_contract::private::Transport + ::core::clone::Clone,
6265 P: alloy_contract::private::Provider<T, N>,
6266 N: alloy_contract::private::Network,
6267 > EspTokenInstance<T, P, N> {
6268 pub fn call_builder<C: alloy_sol_types::SolCall>(
6273 &self,
6274 call: &C,
6275 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
6276 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
6277 }
6278 pub fn UPGRADE_INTERFACE_VERSION(
6280 &self,
6281 ) -> alloy_contract::SolCallBuilder<T, &P, UPGRADE_INTERFACE_VERSIONCall, N> {
6282 self.call_builder(&UPGRADE_INTERFACE_VERSIONCall {})
6283 }
6284 pub fn allowance(
6286 &self,
6287 owner: alloy::sol_types::private::Address,
6288 spender: alloy::sol_types::private::Address,
6289 ) -> alloy_contract::SolCallBuilder<T, &P, allowanceCall, N> {
6290 self.call_builder(&allowanceCall { owner, spender })
6291 }
6292 pub fn approve(
6294 &self,
6295 spender: alloy::sol_types::private::Address,
6296 value: alloy::sol_types::private::primitives::aliases::U256,
6297 ) -> alloy_contract::SolCallBuilder<T, &P, approveCall, N> {
6298 self.call_builder(&approveCall { spender, value })
6299 }
6300 pub fn balanceOf(
6302 &self,
6303 account: alloy::sol_types::private::Address,
6304 ) -> alloy_contract::SolCallBuilder<T, &P, balanceOfCall, N> {
6305 self.call_builder(&balanceOfCall { account })
6306 }
6307 pub fn decimals(
6309 &self,
6310 ) -> alloy_contract::SolCallBuilder<T, &P, decimalsCall, N> {
6311 self.call_builder(&decimalsCall {})
6312 }
6313 pub fn getVersion(
6315 &self,
6316 ) -> alloy_contract::SolCallBuilder<T, &P, getVersionCall, N> {
6317 self.call_builder(&getVersionCall {})
6318 }
6319 pub fn initialize(
6321 &self,
6322 owner: alloy::sol_types::private::Address,
6323 initialRecipient: alloy::sol_types::private::Address,
6324 initialSupply: alloy::sol_types::private::primitives::aliases::U256,
6325 name: alloy::sol_types::private::String,
6326 symbol: alloy::sol_types::private::String,
6327 ) -> alloy_contract::SolCallBuilder<T, &P, initializeCall, N> {
6328 self.call_builder(
6329 &initializeCall {
6330 owner,
6331 initialRecipient,
6332 initialSupply,
6333 name,
6334 symbol,
6335 },
6336 )
6337 }
6338 pub fn name(&self) -> alloy_contract::SolCallBuilder<T, &P, nameCall, N> {
6340 self.call_builder(&nameCall {})
6341 }
6342 pub fn owner(&self) -> alloy_contract::SolCallBuilder<T, &P, ownerCall, N> {
6344 self.call_builder(&ownerCall {})
6345 }
6346 pub fn proxiableUUID(
6348 &self,
6349 ) -> alloy_contract::SolCallBuilder<T, &P, proxiableUUIDCall, N> {
6350 self.call_builder(&proxiableUUIDCall {})
6351 }
6352 pub fn renounceOwnership(
6354 &self,
6355 ) -> alloy_contract::SolCallBuilder<T, &P, renounceOwnershipCall, N> {
6356 self.call_builder(&renounceOwnershipCall {})
6357 }
6358 pub fn symbol(&self) -> alloy_contract::SolCallBuilder<T, &P, symbolCall, N> {
6360 self.call_builder(&symbolCall {})
6361 }
6362 pub fn totalSupply(
6364 &self,
6365 ) -> alloy_contract::SolCallBuilder<T, &P, totalSupplyCall, N> {
6366 self.call_builder(&totalSupplyCall {})
6367 }
6368 pub fn transfer(
6370 &self,
6371 to: alloy::sol_types::private::Address,
6372 value: alloy::sol_types::private::primitives::aliases::U256,
6373 ) -> alloy_contract::SolCallBuilder<T, &P, transferCall, N> {
6374 self.call_builder(&transferCall { to, value })
6375 }
6376 pub fn transferFrom(
6378 &self,
6379 from: alloy::sol_types::private::Address,
6380 to: alloy::sol_types::private::Address,
6381 value: alloy::sol_types::private::primitives::aliases::U256,
6382 ) -> alloy_contract::SolCallBuilder<T, &P, transferFromCall, N> {
6383 self.call_builder(
6384 &transferFromCall {
6385 from,
6386 to,
6387 value,
6388 },
6389 )
6390 }
6391 pub fn transferOwnership(
6393 &self,
6394 newOwner: alloy::sol_types::private::Address,
6395 ) -> alloy_contract::SolCallBuilder<T, &P, transferOwnershipCall, N> {
6396 self.call_builder(&transferOwnershipCall { newOwner })
6397 }
6398 pub fn upgradeToAndCall(
6400 &self,
6401 newImplementation: alloy::sol_types::private::Address,
6402 data: alloy::sol_types::private::Bytes,
6403 ) -> alloy_contract::SolCallBuilder<T, &P, upgradeToAndCallCall, N> {
6404 self.call_builder(
6405 &upgradeToAndCallCall {
6406 newImplementation,
6407 data,
6408 },
6409 )
6410 }
6411 }
6412 #[automatically_derived]
6414 impl<
6415 T: alloy_contract::private::Transport + ::core::clone::Clone,
6416 P: alloy_contract::private::Provider<T, N>,
6417 N: alloy_contract::private::Network,
6418 > EspTokenInstance<T, P, N> {
6419 pub fn event_filter<E: alloy_sol_types::SolEvent>(
6424 &self,
6425 ) -> alloy_contract::Event<T, &P, E, N> {
6426 alloy_contract::Event::new_sol(&self.provider, &self.address)
6427 }
6428 pub fn Approval_filter(&self) -> alloy_contract::Event<T, &P, Approval, N> {
6430 self.event_filter::<Approval>()
6431 }
6432 pub fn Initialized_filter(
6434 &self,
6435 ) -> alloy_contract::Event<T, &P, Initialized, N> {
6436 self.event_filter::<Initialized>()
6437 }
6438 pub fn OwnershipTransferred_filter(
6440 &self,
6441 ) -> alloy_contract::Event<T, &P, OwnershipTransferred, N> {
6442 self.event_filter::<OwnershipTransferred>()
6443 }
6444 pub fn Transfer_filter(&self) -> alloy_contract::Event<T, &P, Transfer, N> {
6446 self.event_filter::<Transfer>()
6447 }
6448 pub fn Upgrade_filter(&self) -> alloy_contract::Event<T, &P, Upgrade, N> {
6450 self.event_filter::<Upgrade>()
6451 }
6452 pub fn Upgraded_filter(&self) -> alloy_contract::Event<T, &P, Upgraded, N> {
6454 self.event_filter::<Upgraded>()
6455 }
6456 }
6457}