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