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