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