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