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