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