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