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\x8Ea\x01\x01_9_\x81\x81a\n>\x01R\x81\x81a\ng\x01Ra\x0B\xA6\x01Ra\x16\x8E_\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\x16B_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\x16B_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\x16b_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\x16B_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\x16b_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\x16b_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\x16B_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\x16B_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\x16B_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\x15pV[P`\x04\x81\x01a\t?\x83\x82a\x15pV[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\x16b_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+V[_`@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\x82\x82\x11\x15a\x08\xDDW\x80_R` _ `\x1F\x84\x01`\x05\x1C` \x85\x10\x15a\x15EWP_[\x90\x81\x01\x90`\x1F\x84\x01`\x05\x1C\x03_[\x81\x81\x10\x15a\x15hW_\x83\x82\x01U`\x01\x01a\x15SV[PPPPPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\x8AWa\x15\x8Aa\x11\xD6V[a\x15\x9E\x81a\x15\x98\x84Ta\x13\x9CV[\x84a\x15\x1AV[` `\x1F\x82\x11`\x01\x81\x14a\x15\xD0W_\x83\x15a\x15\xB9WP\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\xFFW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x15\xDFV[P\x84\x82\x10\x15a\x16\x1CW\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#\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\x16B_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\x16B_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\x16b_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\x16B_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\x16b_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\x16b_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\x16B_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\x16B_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\x16B_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\x15pV[P`\x04\x81\x01a\t?\x83\x82a\x15pV[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\x16b_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+V[_`@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\x82\x82\x11\x15a\x08\xDDW\x80_R` _ `\x1F\x84\x01`\x05\x1C` \x85\x10\x15a\x15EWP_[\x90\x81\x01\x90`\x1F\x84\x01`\x05\x1C\x03_[\x81\x81\x10\x15a\x15hW_\x83\x82\x01U`\x01\x01a\x15SV[PPPPPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\x8AWa\x15\x8Aa\x11\xD6V[a\x15\x9E\x81a\x15\x98\x84Ta\x13\x9CV[\x84a\x15\x1AV[` `\x1F\x82\x11`\x01\x81\x14a\x15\xD0W_\x83\x15a\x15\xB9WP\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\xFFW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x15\xDFV[P\x84\x82\x10\x15a\x16\x1CW\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#\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::abi_decode_raw_with_config(
797 data,
798 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
799 )
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::abi_decode_raw_with_config(
880 data,
881 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
882 )
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::abi_decode_raw_with_config(
954 data,
955 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
956 )
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::abi_decode_raw_with_config(
1059 data,
1060 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1061 )
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::abi_decode_raw_with_config(
1164 data,
1165 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1166 )
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::abi_decode_raw_with_config(
1245 data,
1246 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1247 )
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::abi_decode_raw_with_config(
1326 data,
1327 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1328 )
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::abi_decode_raw_with_config(
1407 data,
1408 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1409 )
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::abi_decode_raw_with_config(
1488 data,
1489 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1490 )
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::abi_decode_raw_with_config(
1562 data,
1563 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1564 )
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::abi_decode_raw_with_config(
1636 data,
1637 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1638 )
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::abi_decode_raw_with_config(
1710 data,
1711 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1712 )
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::abi_decode_raw_with_config(
1784 data,
1785 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1786 )
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::abi_decode_raw_with_config(
1865 data,
1866 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1867 )
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::abi_decode_raw_with_config(
1948 data,
1949 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1950 )
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::abi_decode_raw_with_config(
2024 data,
2025 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2026 )
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::abi_decode_raw_with_config(
2100 data,
2101 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2102 )
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::abi_decode_raw_with_config(
2183 data,
2184 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2185 )
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::abi_decode_raw_with_config(
2257 data,
2258 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2259 )
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_with_config(
3037 data: &[u8],
3038 config: alloy_sol_types::abi::AbiDecoderConfig,
3039 ) -> alloy_sol_types::Result<Self::Return> {
3040 <Self::ReturnTuple<
3041 '_,
3042 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3043 data,
3044 config,
3045 )
3046 .map(|r| {
3047 let r: UPGRADE_INTERFACE_VERSIONReturn = r.into();
3048 r._0
3049 })
3050 }
3051 #[inline]
3052 fn abi_decode_returns_validate(
3053 data: &[u8],
3054 ) -> alloy_sol_types::Result<Self::Return> {
3055 Self::abi_decode_returns_with_config(
3056 data,
3057 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3058 )
3059 }
3060 }
3061 };
3062 #[derive(serde::Serialize, serde::Deserialize)]
3063 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3064 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3069 #[derive(Clone)]
3070 pub struct allowanceCall {
3071 #[allow(missing_docs)]
3072 pub owner: alloy::sol_types::private::Address,
3073 #[allow(missing_docs)]
3074 pub spender: alloy::sol_types::private::Address,
3075 }
3076 #[derive(serde::Serialize, serde::Deserialize)]
3077 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3078 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3080 #[derive(Clone)]
3081 pub struct allowanceReturn {
3082 #[allow(missing_docs)]
3083 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3084 }
3085 #[allow(
3086 non_camel_case_types,
3087 non_snake_case,
3088 clippy::pub_underscore_fields,
3089 clippy::style
3090 )]
3091 const _: () = {
3092 use alloy::sol_types as alloy_sol_types;
3093 {
3094 #[doc(hidden)]
3095 #[allow(dead_code)]
3096 type UnderlyingSolTuple<'a> = (
3097 alloy::sol_types::sol_data::Address,
3098 alloy::sol_types::sol_data::Address,
3099 );
3100 #[doc(hidden)]
3101 type UnderlyingRustTuple<'a> = (
3102 alloy::sol_types::private::Address,
3103 alloy::sol_types::private::Address,
3104 );
3105 #[cfg(test)]
3106 #[allow(dead_code, unreachable_patterns)]
3107 fn _type_assertion(
3108 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3109 ) {
3110 match _t {
3111 alloy_sol_types::private::AssertTypeEq::<
3112 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3113 >(_) => {}
3114 }
3115 }
3116 #[automatically_derived]
3117 #[doc(hidden)]
3118 impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
3119 fn from(value: allowanceCall) -> Self {
3120 (value.owner, value.spender)
3121 }
3122 }
3123 #[automatically_derived]
3124 #[doc(hidden)]
3125 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
3126 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3127 Self {
3128 owner: tuple.0,
3129 spender: tuple.1,
3130 }
3131 }
3132 }
3133 }
3134 {
3135 #[doc(hidden)]
3136 #[allow(dead_code)]
3137 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3138 #[doc(hidden)]
3139 type UnderlyingRustTuple<'a> = (
3140 alloy::sol_types::private::primitives::aliases::U256,
3141 );
3142 #[cfg(test)]
3143 #[allow(dead_code, unreachable_patterns)]
3144 fn _type_assertion(
3145 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3146 ) {
3147 match _t {
3148 alloy_sol_types::private::AssertTypeEq::<
3149 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3150 >(_) => {}
3151 }
3152 }
3153 #[automatically_derived]
3154 #[doc(hidden)]
3155 impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
3156 fn from(value: allowanceReturn) -> Self {
3157 (value._0,)
3158 }
3159 }
3160 #[automatically_derived]
3161 #[doc(hidden)]
3162 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
3163 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3164 Self { _0: tuple.0 }
3165 }
3166 }
3167 }
3168 #[automatically_derived]
3169 impl alloy_sol_types::SolCall for allowanceCall {
3170 type Parameters<'a> = (
3171 alloy::sol_types::sol_data::Address,
3172 alloy::sol_types::sol_data::Address,
3173 );
3174 type Token<'a> = <Self::Parameters<
3175 'a,
3176 > as alloy_sol_types::SolType>::Token<'a>;
3177 type Return = alloy::sol_types::private::primitives::aliases::U256;
3178 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3179 type ReturnToken<'a> = <Self::ReturnTuple<
3180 'a,
3181 > as alloy_sol_types::SolType>::Token<'a>;
3182 const SIGNATURE: &'static str = "allowance(address,address)";
3183 const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
3184 #[inline]
3185 fn new<'a>(
3186 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3187 ) -> Self {
3188 tuple.into()
3189 }
3190 #[inline]
3191 fn tokenize(&self) -> Self::Token<'_> {
3192 (
3193 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3194 &self.owner,
3195 ),
3196 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3197 &self.spender,
3198 ),
3199 )
3200 }
3201 #[inline]
3202 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3203 (
3204 <alloy::sol_types::sol_data::Uint<
3205 256,
3206 > as alloy_sol_types::SolType>::tokenize(ret),
3207 )
3208 }
3209 #[inline]
3210 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3211 <Self::ReturnTuple<
3212 '_,
3213 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3214 .map(|r| {
3215 let r: allowanceReturn = r.into();
3216 r._0
3217 })
3218 }
3219 #[inline]
3220 fn abi_decode_returns_with_config(
3221 data: &[u8],
3222 config: alloy_sol_types::abi::AbiDecoderConfig,
3223 ) -> alloy_sol_types::Result<Self::Return> {
3224 <Self::ReturnTuple<
3225 '_,
3226 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3227 data,
3228 config,
3229 )
3230 .map(|r| {
3231 let r: allowanceReturn = r.into();
3232 r._0
3233 })
3234 }
3235 #[inline]
3236 fn abi_decode_returns_validate(
3237 data: &[u8],
3238 ) -> alloy_sol_types::Result<Self::Return> {
3239 Self::abi_decode_returns_with_config(
3240 data,
3241 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3242 )
3243 }
3244 }
3245 };
3246 #[derive(serde::Serialize, serde::Deserialize)]
3247 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3248 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3253 #[derive(Clone)]
3254 pub struct approveCall {
3255 #[allow(missing_docs)]
3256 pub spender: alloy::sol_types::private::Address,
3257 #[allow(missing_docs)]
3258 pub value: alloy::sol_types::private::primitives::aliases::U256,
3259 }
3260 #[derive(serde::Serialize, serde::Deserialize)]
3261 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3262 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3264 #[derive(Clone)]
3265 pub struct approveReturn {
3266 #[allow(missing_docs)]
3267 pub _0: bool,
3268 }
3269 #[allow(
3270 non_camel_case_types,
3271 non_snake_case,
3272 clippy::pub_underscore_fields,
3273 clippy::style
3274 )]
3275 const _: () = {
3276 use alloy::sol_types as alloy_sol_types;
3277 {
3278 #[doc(hidden)]
3279 #[allow(dead_code)]
3280 type UnderlyingSolTuple<'a> = (
3281 alloy::sol_types::sol_data::Address,
3282 alloy::sol_types::sol_data::Uint<256>,
3283 );
3284 #[doc(hidden)]
3285 type UnderlyingRustTuple<'a> = (
3286 alloy::sol_types::private::Address,
3287 alloy::sol_types::private::primitives::aliases::U256,
3288 );
3289 #[cfg(test)]
3290 #[allow(dead_code, unreachable_patterns)]
3291 fn _type_assertion(
3292 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3293 ) {
3294 match _t {
3295 alloy_sol_types::private::AssertTypeEq::<
3296 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3297 >(_) => {}
3298 }
3299 }
3300 #[automatically_derived]
3301 #[doc(hidden)]
3302 impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
3303 fn from(value: approveCall) -> Self {
3304 (value.spender, value.value)
3305 }
3306 }
3307 #[automatically_derived]
3308 #[doc(hidden)]
3309 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
3310 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3311 Self {
3312 spender: tuple.0,
3313 value: tuple.1,
3314 }
3315 }
3316 }
3317 }
3318 {
3319 #[doc(hidden)]
3320 #[allow(dead_code)]
3321 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3322 #[doc(hidden)]
3323 type UnderlyingRustTuple<'a> = (bool,);
3324 #[cfg(test)]
3325 #[allow(dead_code, unreachable_patterns)]
3326 fn _type_assertion(
3327 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3328 ) {
3329 match _t {
3330 alloy_sol_types::private::AssertTypeEq::<
3331 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3332 >(_) => {}
3333 }
3334 }
3335 #[automatically_derived]
3336 #[doc(hidden)]
3337 impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
3338 fn from(value: approveReturn) -> Self {
3339 (value._0,)
3340 }
3341 }
3342 #[automatically_derived]
3343 #[doc(hidden)]
3344 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
3345 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3346 Self { _0: tuple.0 }
3347 }
3348 }
3349 }
3350 #[automatically_derived]
3351 impl alloy_sol_types::SolCall for approveCall {
3352 type Parameters<'a> = (
3353 alloy::sol_types::sol_data::Address,
3354 alloy::sol_types::sol_data::Uint<256>,
3355 );
3356 type Token<'a> = <Self::Parameters<
3357 'a,
3358 > as alloy_sol_types::SolType>::Token<'a>;
3359 type Return = bool;
3360 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3361 type ReturnToken<'a> = <Self::ReturnTuple<
3362 'a,
3363 > as alloy_sol_types::SolType>::Token<'a>;
3364 const SIGNATURE: &'static str = "approve(address,uint256)";
3365 const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
3366 #[inline]
3367 fn new<'a>(
3368 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3369 ) -> Self {
3370 tuple.into()
3371 }
3372 #[inline]
3373 fn tokenize(&self) -> Self::Token<'_> {
3374 (
3375 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3376 &self.spender,
3377 ),
3378 <alloy::sol_types::sol_data::Uint<
3379 256,
3380 > as alloy_sol_types::SolType>::tokenize(&self.value),
3381 )
3382 }
3383 #[inline]
3384 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3385 (
3386 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
3387 ret,
3388 ),
3389 )
3390 }
3391 #[inline]
3392 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3393 <Self::ReturnTuple<
3394 '_,
3395 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3396 .map(|r| {
3397 let r: approveReturn = r.into();
3398 r._0
3399 })
3400 }
3401 #[inline]
3402 fn abi_decode_returns_with_config(
3403 data: &[u8],
3404 config: alloy_sol_types::abi::AbiDecoderConfig,
3405 ) -> alloy_sol_types::Result<Self::Return> {
3406 <Self::ReturnTuple<
3407 '_,
3408 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3409 data,
3410 config,
3411 )
3412 .map(|r| {
3413 let r: approveReturn = r.into();
3414 r._0
3415 })
3416 }
3417 #[inline]
3418 fn abi_decode_returns_validate(
3419 data: &[u8],
3420 ) -> alloy_sol_types::Result<Self::Return> {
3421 Self::abi_decode_returns_with_config(
3422 data,
3423 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3424 )
3425 }
3426 }
3427 };
3428 #[derive(serde::Serialize, serde::Deserialize)]
3429 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3430 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3435 #[derive(Clone)]
3436 pub struct balanceOfCall {
3437 #[allow(missing_docs)]
3438 pub account: alloy::sol_types::private::Address,
3439 }
3440 #[derive(serde::Serialize, serde::Deserialize)]
3441 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3442 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3444 #[derive(Clone)]
3445 pub struct balanceOfReturn {
3446 #[allow(missing_docs)]
3447 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3448 }
3449 #[allow(
3450 non_camel_case_types,
3451 non_snake_case,
3452 clippy::pub_underscore_fields,
3453 clippy::style
3454 )]
3455 const _: () = {
3456 use alloy::sol_types as alloy_sol_types;
3457 {
3458 #[doc(hidden)]
3459 #[allow(dead_code)]
3460 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3461 #[doc(hidden)]
3462 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3463 #[cfg(test)]
3464 #[allow(dead_code, unreachable_patterns)]
3465 fn _type_assertion(
3466 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3467 ) {
3468 match _t {
3469 alloy_sol_types::private::AssertTypeEq::<
3470 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3471 >(_) => {}
3472 }
3473 }
3474 #[automatically_derived]
3475 #[doc(hidden)]
3476 impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
3477 fn from(value: balanceOfCall) -> Self {
3478 (value.account,)
3479 }
3480 }
3481 #[automatically_derived]
3482 #[doc(hidden)]
3483 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
3484 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3485 Self { account: tuple.0 }
3486 }
3487 }
3488 }
3489 {
3490 #[doc(hidden)]
3491 #[allow(dead_code)]
3492 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3493 #[doc(hidden)]
3494 type UnderlyingRustTuple<'a> = (
3495 alloy::sol_types::private::primitives::aliases::U256,
3496 );
3497 #[cfg(test)]
3498 #[allow(dead_code, unreachable_patterns)]
3499 fn _type_assertion(
3500 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3501 ) {
3502 match _t {
3503 alloy_sol_types::private::AssertTypeEq::<
3504 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3505 >(_) => {}
3506 }
3507 }
3508 #[automatically_derived]
3509 #[doc(hidden)]
3510 impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
3511 fn from(value: balanceOfReturn) -> Self {
3512 (value._0,)
3513 }
3514 }
3515 #[automatically_derived]
3516 #[doc(hidden)]
3517 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
3518 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3519 Self { _0: tuple.0 }
3520 }
3521 }
3522 }
3523 #[automatically_derived]
3524 impl alloy_sol_types::SolCall for balanceOfCall {
3525 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3526 type Token<'a> = <Self::Parameters<
3527 'a,
3528 > as alloy_sol_types::SolType>::Token<'a>;
3529 type Return = alloy::sol_types::private::primitives::aliases::U256;
3530 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3531 type ReturnToken<'a> = <Self::ReturnTuple<
3532 'a,
3533 > as alloy_sol_types::SolType>::Token<'a>;
3534 const SIGNATURE: &'static str = "balanceOf(address)";
3535 const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
3536 #[inline]
3537 fn new<'a>(
3538 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3539 ) -> Self {
3540 tuple.into()
3541 }
3542 #[inline]
3543 fn tokenize(&self) -> Self::Token<'_> {
3544 (
3545 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3546 &self.account,
3547 ),
3548 )
3549 }
3550 #[inline]
3551 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3552 (
3553 <alloy::sol_types::sol_data::Uint<
3554 256,
3555 > as alloy_sol_types::SolType>::tokenize(ret),
3556 )
3557 }
3558 #[inline]
3559 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3560 <Self::ReturnTuple<
3561 '_,
3562 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3563 .map(|r| {
3564 let r: balanceOfReturn = r.into();
3565 r._0
3566 })
3567 }
3568 #[inline]
3569 fn abi_decode_returns_with_config(
3570 data: &[u8],
3571 config: alloy_sol_types::abi::AbiDecoderConfig,
3572 ) -> alloy_sol_types::Result<Self::Return> {
3573 <Self::ReturnTuple<
3574 '_,
3575 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3576 data,
3577 config,
3578 )
3579 .map(|r| {
3580 let r: balanceOfReturn = r.into();
3581 r._0
3582 })
3583 }
3584 #[inline]
3585 fn abi_decode_returns_validate(
3586 data: &[u8],
3587 ) -> alloy_sol_types::Result<Self::Return> {
3588 Self::abi_decode_returns_with_config(
3589 data,
3590 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3591 )
3592 }
3593 }
3594 };
3595 #[derive(serde::Serialize, serde::Deserialize)]
3596 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3597 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3602 #[derive(Clone)]
3603 pub struct decimalsCall;
3604 #[derive(serde::Serialize, serde::Deserialize)]
3605 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3606 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3608 #[derive(Clone)]
3609 pub struct decimalsReturn {
3610 #[allow(missing_docs)]
3611 pub _0: u8,
3612 }
3613 #[allow(
3614 non_camel_case_types,
3615 non_snake_case,
3616 clippy::pub_underscore_fields,
3617 clippy::style
3618 )]
3619 const _: () = {
3620 use alloy::sol_types as alloy_sol_types;
3621 {
3622 #[doc(hidden)]
3623 #[allow(dead_code)]
3624 type UnderlyingSolTuple<'a> = ();
3625 #[doc(hidden)]
3626 type UnderlyingRustTuple<'a> = ();
3627 #[cfg(test)]
3628 #[allow(dead_code, unreachable_patterns)]
3629 fn _type_assertion(
3630 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3631 ) {
3632 match _t {
3633 alloy_sol_types::private::AssertTypeEq::<
3634 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3635 >(_) => {}
3636 }
3637 }
3638 #[automatically_derived]
3639 #[doc(hidden)]
3640 impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
3641 fn from(value: decimalsCall) -> Self {
3642 ()
3643 }
3644 }
3645 #[automatically_derived]
3646 #[doc(hidden)]
3647 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
3648 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3649 Self
3650 }
3651 }
3652 }
3653 {
3654 #[doc(hidden)]
3655 #[allow(dead_code)]
3656 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3657 #[doc(hidden)]
3658 type UnderlyingRustTuple<'a> = (u8,);
3659 #[cfg(test)]
3660 #[allow(dead_code, unreachable_patterns)]
3661 fn _type_assertion(
3662 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3663 ) {
3664 match _t {
3665 alloy_sol_types::private::AssertTypeEq::<
3666 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3667 >(_) => {}
3668 }
3669 }
3670 #[automatically_derived]
3671 #[doc(hidden)]
3672 impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
3673 fn from(value: decimalsReturn) -> Self {
3674 (value._0,)
3675 }
3676 }
3677 #[automatically_derived]
3678 #[doc(hidden)]
3679 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
3680 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3681 Self { _0: tuple.0 }
3682 }
3683 }
3684 }
3685 #[automatically_derived]
3686 impl alloy_sol_types::SolCall for decimalsCall {
3687 type Parameters<'a> = ();
3688 type Token<'a> = <Self::Parameters<
3689 'a,
3690 > as alloy_sol_types::SolType>::Token<'a>;
3691 type Return = u8;
3692 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3693 type ReturnToken<'a> = <Self::ReturnTuple<
3694 'a,
3695 > as alloy_sol_types::SolType>::Token<'a>;
3696 const SIGNATURE: &'static str = "decimals()";
3697 const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
3698 #[inline]
3699 fn new<'a>(
3700 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3701 ) -> Self {
3702 tuple.into()
3703 }
3704 #[inline]
3705 fn tokenize(&self) -> Self::Token<'_> {
3706 ()
3707 }
3708 #[inline]
3709 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3710 (
3711 <alloy::sol_types::sol_data::Uint<
3712 8,
3713 > as alloy_sol_types::SolType>::tokenize(ret),
3714 )
3715 }
3716 #[inline]
3717 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3718 <Self::ReturnTuple<
3719 '_,
3720 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3721 .map(|r| {
3722 let r: decimalsReturn = r.into();
3723 r._0
3724 })
3725 }
3726 #[inline]
3727 fn abi_decode_returns_with_config(
3728 data: &[u8],
3729 config: alloy_sol_types::abi::AbiDecoderConfig,
3730 ) -> alloy_sol_types::Result<Self::Return> {
3731 <Self::ReturnTuple<
3732 '_,
3733 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3734 data,
3735 config,
3736 )
3737 .map(|r| {
3738 let r: decimalsReturn = r.into();
3739 r._0
3740 })
3741 }
3742 #[inline]
3743 fn abi_decode_returns_validate(
3744 data: &[u8],
3745 ) -> alloy_sol_types::Result<Self::Return> {
3746 Self::abi_decode_returns_with_config(
3747 data,
3748 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3749 )
3750 }
3751 }
3752 };
3753 #[derive(serde::Serialize, serde::Deserialize)]
3754 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3755 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3760 #[derive(Clone)]
3761 pub struct getVersionCall;
3762 #[derive(serde::Serialize, serde::Deserialize)]
3763 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3764 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3766 #[derive(Clone)]
3767 pub struct getVersionReturn {
3768 #[allow(missing_docs)]
3769 pub majorVersion: u8,
3770 #[allow(missing_docs)]
3771 pub minorVersion: u8,
3772 #[allow(missing_docs)]
3773 pub patchVersion: u8,
3774 }
3775 #[allow(
3776 non_camel_case_types,
3777 non_snake_case,
3778 clippy::pub_underscore_fields,
3779 clippy::style
3780 )]
3781 const _: () = {
3782 use alloy::sol_types as alloy_sol_types;
3783 {
3784 #[doc(hidden)]
3785 #[allow(dead_code)]
3786 type UnderlyingSolTuple<'a> = ();
3787 #[doc(hidden)]
3788 type UnderlyingRustTuple<'a> = ();
3789 #[cfg(test)]
3790 #[allow(dead_code, unreachable_patterns)]
3791 fn _type_assertion(
3792 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3793 ) {
3794 match _t {
3795 alloy_sol_types::private::AssertTypeEq::<
3796 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3797 >(_) => {}
3798 }
3799 }
3800 #[automatically_derived]
3801 #[doc(hidden)]
3802 impl ::core::convert::From<getVersionCall> for UnderlyingRustTuple<'_> {
3803 fn from(value: getVersionCall) -> Self {
3804 ()
3805 }
3806 }
3807 #[automatically_derived]
3808 #[doc(hidden)]
3809 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionCall {
3810 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3811 Self
3812 }
3813 }
3814 }
3815 {
3816 #[doc(hidden)]
3817 #[allow(dead_code)]
3818 type UnderlyingSolTuple<'a> = (
3819 alloy::sol_types::sol_data::Uint<8>,
3820 alloy::sol_types::sol_data::Uint<8>,
3821 alloy::sol_types::sol_data::Uint<8>,
3822 );
3823 #[doc(hidden)]
3824 type UnderlyingRustTuple<'a> = (u8, u8, u8);
3825 #[cfg(test)]
3826 #[allow(dead_code, unreachable_patterns)]
3827 fn _type_assertion(
3828 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3829 ) {
3830 match _t {
3831 alloy_sol_types::private::AssertTypeEq::<
3832 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3833 >(_) => {}
3834 }
3835 }
3836 #[automatically_derived]
3837 #[doc(hidden)]
3838 impl ::core::convert::From<getVersionReturn> for UnderlyingRustTuple<'_> {
3839 fn from(value: getVersionReturn) -> Self {
3840 (value.majorVersion, value.minorVersion, value.patchVersion)
3841 }
3842 }
3843 #[automatically_derived]
3844 #[doc(hidden)]
3845 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionReturn {
3846 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3847 Self {
3848 majorVersion: tuple.0,
3849 minorVersion: tuple.1,
3850 patchVersion: tuple.2,
3851 }
3852 }
3853 }
3854 }
3855 impl getVersionReturn {
3856 fn _tokenize(
3857 &self,
3858 ) -> <getVersionCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3859 (
3860 <alloy::sol_types::sol_data::Uint<
3861 8,
3862 > as alloy_sol_types::SolType>::tokenize(&self.majorVersion),
3863 <alloy::sol_types::sol_data::Uint<
3864 8,
3865 > as alloy_sol_types::SolType>::tokenize(&self.minorVersion),
3866 <alloy::sol_types::sol_data::Uint<
3867 8,
3868 > as alloy_sol_types::SolType>::tokenize(&self.patchVersion),
3869 )
3870 }
3871 }
3872 #[automatically_derived]
3873 impl alloy_sol_types::SolCall for getVersionCall {
3874 type Parameters<'a> = ();
3875 type Token<'a> = <Self::Parameters<
3876 'a,
3877 > as alloy_sol_types::SolType>::Token<'a>;
3878 type Return = getVersionReturn;
3879 type ReturnTuple<'a> = (
3880 alloy::sol_types::sol_data::Uint<8>,
3881 alloy::sol_types::sol_data::Uint<8>,
3882 alloy::sol_types::sol_data::Uint<8>,
3883 );
3884 type ReturnToken<'a> = <Self::ReturnTuple<
3885 'a,
3886 > as alloy_sol_types::SolType>::Token<'a>;
3887 const SIGNATURE: &'static str = "getVersion()";
3888 const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8];
3889 #[inline]
3890 fn new<'a>(
3891 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3892 ) -> Self {
3893 tuple.into()
3894 }
3895 #[inline]
3896 fn tokenize(&self) -> Self::Token<'_> {
3897 ()
3898 }
3899 #[inline]
3900 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3901 getVersionReturn::_tokenize(ret)
3902 }
3903 #[inline]
3904 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3905 <Self::ReturnTuple<
3906 '_,
3907 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3908 .map(Into::into)
3909 }
3910 #[inline]
3911 fn abi_decode_returns_with_config(
3912 data: &[u8],
3913 config: alloy_sol_types::abi::AbiDecoderConfig,
3914 ) -> alloy_sol_types::Result<Self::Return> {
3915 <Self::ReturnTuple<
3916 '_,
3917 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3918 data,
3919 config,
3920 )
3921 .map(Into::into)
3922 }
3923 #[inline]
3924 fn abi_decode_returns_validate(
3925 data: &[u8],
3926 ) -> alloy_sol_types::Result<Self::Return> {
3927 Self::abi_decode_returns_with_config(
3928 data,
3929 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3930 )
3931 }
3932 }
3933 };
3934 #[derive(serde::Serialize, serde::Deserialize)]
3935 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3936 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3941 #[derive(Clone)]
3942 pub struct initializeCall {
3943 #[allow(missing_docs)]
3944 pub owner: alloy::sol_types::private::Address,
3945 #[allow(missing_docs)]
3946 pub initialRecipient: alloy::sol_types::private::Address,
3947 #[allow(missing_docs)]
3948 pub initialSupply: alloy::sol_types::private::primitives::aliases::U256,
3949 #[allow(missing_docs)]
3950 pub name: alloy::sol_types::private::String,
3951 #[allow(missing_docs)]
3952 pub symbol: alloy::sol_types::private::String,
3953 }
3954 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3956 #[derive(Clone)]
3957 pub struct initializeReturn {}
3958 #[allow(
3959 non_camel_case_types,
3960 non_snake_case,
3961 clippy::pub_underscore_fields,
3962 clippy::style
3963 )]
3964 const _: () = {
3965 use alloy::sol_types as alloy_sol_types;
3966 {
3967 #[doc(hidden)]
3968 #[allow(dead_code)]
3969 type UnderlyingSolTuple<'a> = (
3970 alloy::sol_types::sol_data::Address,
3971 alloy::sol_types::sol_data::Address,
3972 alloy::sol_types::sol_data::Uint<256>,
3973 alloy::sol_types::sol_data::String,
3974 alloy::sol_types::sol_data::String,
3975 );
3976 #[doc(hidden)]
3977 type UnderlyingRustTuple<'a> = (
3978 alloy::sol_types::private::Address,
3979 alloy::sol_types::private::Address,
3980 alloy::sol_types::private::primitives::aliases::U256,
3981 alloy::sol_types::private::String,
3982 alloy::sol_types::private::String,
3983 );
3984 #[cfg(test)]
3985 #[allow(dead_code, unreachable_patterns)]
3986 fn _type_assertion(
3987 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3988 ) {
3989 match _t {
3990 alloy_sol_types::private::AssertTypeEq::<
3991 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3992 >(_) => {}
3993 }
3994 }
3995 #[automatically_derived]
3996 #[doc(hidden)]
3997 impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
3998 fn from(value: initializeCall) -> Self {
3999 (
4000 value.owner,
4001 value.initialRecipient,
4002 value.initialSupply,
4003 value.name,
4004 value.symbol,
4005 )
4006 }
4007 }
4008 #[automatically_derived]
4009 #[doc(hidden)]
4010 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
4011 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4012 Self {
4013 owner: tuple.0,
4014 initialRecipient: tuple.1,
4015 initialSupply: tuple.2,
4016 name: tuple.3,
4017 symbol: tuple.4,
4018 }
4019 }
4020 }
4021 }
4022 {
4023 #[doc(hidden)]
4024 #[allow(dead_code)]
4025 type UnderlyingSolTuple<'a> = ();
4026 #[doc(hidden)]
4027 type UnderlyingRustTuple<'a> = ();
4028 #[cfg(test)]
4029 #[allow(dead_code, unreachable_patterns)]
4030 fn _type_assertion(
4031 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4032 ) {
4033 match _t {
4034 alloy_sol_types::private::AssertTypeEq::<
4035 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4036 >(_) => {}
4037 }
4038 }
4039 #[automatically_derived]
4040 #[doc(hidden)]
4041 impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
4042 fn from(value: initializeReturn) -> Self {
4043 ()
4044 }
4045 }
4046 #[automatically_derived]
4047 #[doc(hidden)]
4048 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
4049 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4050 Self {}
4051 }
4052 }
4053 }
4054 impl initializeReturn {
4055 fn _tokenize(
4056 &self,
4057 ) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4058 ()
4059 }
4060 }
4061 #[automatically_derived]
4062 impl alloy_sol_types::SolCall for initializeCall {
4063 type Parameters<'a> = (
4064 alloy::sol_types::sol_data::Address,
4065 alloy::sol_types::sol_data::Address,
4066 alloy::sol_types::sol_data::Uint<256>,
4067 alloy::sol_types::sol_data::String,
4068 alloy::sol_types::sol_data::String,
4069 );
4070 type Token<'a> = <Self::Parameters<
4071 'a,
4072 > as alloy_sol_types::SolType>::Token<'a>;
4073 type Return = initializeReturn;
4074 type ReturnTuple<'a> = ();
4075 type ReturnToken<'a> = <Self::ReturnTuple<
4076 'a,
4077 > as alloy_sol_types::SolType>::Token<'a>;
4078 const SIGNATURE: &'static str = "initialize(address,address,uint256,string,string)";
4079 const SELECTOR: [u8; 4] = [154u8, 184u8, 54u8, 126u8];
4080 #[inline]
4081 fn new<'a>(
4082 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4083 ) -> Self {
4084 tuple.into()
4085 }
4086 #[inline]
4087 fn tokenize(&self) -> Self::Token<'_> {
4088 (
4089 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4090 &self.owner,
4091 ),
4092 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4093 &self.initialRecipient,
4094 ),
4095 <alloy::sol_types::sol_data::Uint<
4096 256,
4097 > as alloy_sol_types::SolType>::tokenize(&self.initialSupply),
4098 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
4099 &self.name,
4100 ),
4101 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
4102 &self.symbol,
4103 ),
4104 )
4105 }
4106 #[inline]
4107 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4108 initializeReturn::_tokenize(ret)
4109 }
4110 #[inline]
4111 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4112 <Self::ReturnTuple<
4113 '_,
4114 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4115 .map(Into::into)
4116 }
4117 #[inline]
4118 fn abi_decode_returns_with_config(
4119 data: &[u8],
4120 config: alloy_sol_types::abi::AbiDecoderConfig,
4121 ) -> alloy_sol_types::Result<Self::Return> {
4122 <Self::ReturnTuple<
4123 '_,
4124 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
4125 data,
4126 config,
4127 )
4128 .map(Into::into)
4129 }
4130 #[inline]
4131 fn abi_decode_returns_validate(
4132 data: &[u8],
4133 ) -> alloy_sol_types::Result<Self::Return> {
4134 Self::abi_decode_returns_with_config(
4135 data,
4136 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4137 )
4138 }
4139 }
4140 };
4141 #[derive(serde::Serialize, serde::Deserialize)]
4142 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4143 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4148 #[derive(Clone)]
4149 pub struct initializeV2Call {
4150 #[allow(missing_docs)]
4151 pub _rewardClaim: alloy::sol_types::private::Address,
4152 }
4153 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4155 #[derive(Clone)]
4156 pub struct initializeV2Return {}
4157 #[allow(
4158 non_camel_case_types,
4159 non_snake_case,
4160 clippy::pub_underscore_fields,
4161 clippy::style
4162 )]
4163 const _: () = {
4164 use alloy::sol_types as alloy_sol_types;
4165 {
4166 #[doc(hidden)]
4167 #[allow(dead_code)]
4168 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4169 #[doc(hidden)]
4170 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4171 #[cfg(test)]
4172 #[allow(dead_code, unreachable_patterns)]
4173 fn _type_assertion(
4174 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4175 ) {
4176 match _t {
4177 alloy_sol_types::private::AssertTypeEq::<
4178 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4179 >(_) => {}
4180 }
4181 }
4182 #[automatically_derived]
4183 #[doc(hidden)]
4184 impl ::core::convert::From<initializeV2Call> for UnderlyingRustTuple<'_> {
4185 fn from(value: initializeV2Call) -> Self {
4186 (value._rewardClaim,)
4187 }
4188 }
4189 #[automatically_derived]
4190 #[doc(hidden)]
4191 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeV2Call {
4192 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4193 Self { _rewardClaim: tuple.0 }
4194 }
4195 }
4196 }
4197 {
4198 #[doc(hidden)]
4199 #[allow(dead_code)]
4200 type UnderlyingSolTuple<'a> = ();
4201 #[doc(hidden)]
4202 type UnderlyingRustTuple<'a> = ();
4203 #[cfg(test)]
4204 #[allow(dead_code, unreachable_patterns)]
4205 fn _type_assertion(
4206 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4207 ) {
4208 match _t {
4209 alloy_sol_types::private::AssertTypeEq::<
4210 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4211 >(_) => {}
4212 }
4213 }
4214 #[automatically_derived]
4215 #[doc(hidden)]
4216 impl ::core::convert::From<initializeV2Return> for UnderlyingRustTuple<'_> {
4217 fn from(value: initializeV2Return) -> Self {
4218 ()
4219 }
4220 }
4221 #[automatically_derived]
4222 #[doc(hidden)]
4223 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeV2Return {
4224 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4225 Self {}
4226 }
4227 }
4228 }
4229 impl initializeV2Return {
4230 fn _tokenize(
4231 &self,
4232 ) -> <initializeV2Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
4233 ()
4234 }
4235 }
4236 #[automatically_derived]
4237 impl alloy_sol_types::SolCall for initializeV2Call {
4238 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4239 type Token<'a> = <Self::Parameters<
4240 'a,
4241 > as alloy_sol_types::SolType>::Token<'a>;
4242 type Return = initializeV2Return;
4243 type ReturnTuple<'a> = ();
4244 type ReturnToken<'a> = <Self::ReturnTuple<
4245 'a,
4246 > as alloy_sol_types::SolType>::Token<'a>;
4247 const SIGNATURE: &'static str = "initializeV2(address)";
4248 const SELECTOR: [u8; 4] = [41u8, 182u8, 236u8, 169u8];
4249 #[inline]
4250 fn new<'a>(
4251 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4252 ) -> Self {
4253 tuple.into()
4254 }
4255 #[inline]
4256 fn tokenize(&self) -> Self::Token<'_> {
4257 (
4258 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4259 &self._rewardClaim,
4260 ),
4261 )
4262 }
4263 #[inline]
4264 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4265 initializeV2Return::_tokenize(ret)
4266 }
4267 #[inline]
4268 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4269 <Self::ReturnTuple<
4270 '_,
4271 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4272 .map(Into::into)
4273 }
4274 #[inline]
4275 fn abi_decode_returns_with_config(
4276 data: &[u8],
4277 config: alloy_sol_types::abi::AbiDecoderConfig,
4278 ) -> alloy_sol_types::Result<Self::Return> {
4279 <Self::ReturnTuple<
4280 '_,
4281 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
4282 data,
4283 config,
4284 )
4285 .map(Into::into)
4286 }
4287 #[inline]
4288 fn abi_decode_returns_validate(
4289 data: &[u8],
4290 ) -> alloy_sol_types::Result<Self::Return> {
4291 Self::abi_decode_returns_with_config(
4292 data,
4293 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4294 )
4295 }
4296 }
4297 };
4298 #[derive(serde::Serialize, serde::Deserialize)]
4299 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4300 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4305 #[derive(Clone)]
4306 pub struct mintCall {
4307 #[allow(missing_docs)]
4308 pub to: alloy::sol_types::private::Address,
4309 #[allow(missing_docs)]
4310 pub amount: alloy::sol_types::private::primitives::aliases::U256,
4311 }
4312 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4314 #[derive(Clone)]
4315 pub struct mintReturn {}
4316 #[allow(
4317 non_camel_case_types,
4318 non_snake_case,
4319 clippy::pub_underscore_fields,
4320 clippy::style
4321 )]
4322 const _: () = {
4323 use alloy::sol_types as alloy_sol_types;
4324 {
4325 #[doc(hidden)]
4326 #[allow(dead_code)]
4327 type UnderlyingSolTuple<'a> = (
4328 alloy::sol_types::sol_data::Address,
4329 alloy::sol_types::sol_data::Uint<256>,
4330 );
4331 #[doc(hidden)]
4332 type UnderlyingRustTuple<'a> = (
4333 alloy::sol_types::private::Address,
4334 alloy::sol_types::private::primitives::aliases::U256,
4335 );
4336 #[cfg(test)]
4337 #[allow(dead_code, unreachable_patterns)]
4338 fn _type_assertion(
4339 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4340 ) {
4341 match _t {
4342 alloy_sol_types::private::AssertTypeEq::<
4343 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4344 >(_) => {}
4345 }
4346 }
4347 #[automatically_derived]
4348 #[doc(hidden)]
4349 impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
4350 fn from(value: mintCall) -> Self {
4351 (value.to, value.amount)
4352 }
4353 }
4354 #[automatically_derived]
4355 #[doc(hidden)]
4356 impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
4357 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4358 Self {
4359 to: tuple.0,
4360 amount: tuple.1,
4361 }
4362 }
4363 }
4364 }
4365 {
4366 #[doc(hidden)]
4367 #[allow(dead_code)]
4368 type UnderlyingSolTuple<'a> = ();
4369 #[doc(hidden)]
4370 type UnderlyingRustTuple<'a> = ();
4371 #[cfg(test)]
4372 #[allow(dead_code, unreachable_patterns)]
4373 fn _type_assertion(
4374 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4375 ) {
4376 match _t {
4377 alloy_sol_types::private::AssertTypeEq::<
4378 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4379 >(_) => {}
4380 }
4381 }
4382 #[automatically_derived]
4383 #[doc(hidden)]
4384 impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
4385 fn from(value: mintReturn) -> Self {
4386 ()
4387 }
4388 }
4389 #[automatically_derived]
4390 #[doc(hidden)]
4391 impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
4392 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4393 Self {}
4394 }
4395 }
4396 }
4397 impl mintReturn {
4398 fn _tokenize(
4399 &self,
4400 ) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4401 ()
4402 }
4403 }
4404 #[automatically_derived]
4405 impl alloy_sol_types::SolCall for mintCall {
4406 type Parameters<'a> = (
4407 alloy::sol_types::sol_data::Address,
4408 alloy::sol_types::sol_data::Uint<256>,
4409 );
4410 type Token<'a> = <Self::Parameters<
4411 'a,
4412 > as alloy_sol_types::SolType>::Token<'a>;
4413 type Return = mintReturn;
4414 type ReturnTuple<'a> = ();
4415 type ReturnToken<'a> = <Self::ReturnTuple<
4416 'a,
4417 > as alloy_sol_types::SolType>::Token<'a>;
4418 const SIGNATURE: &'static str = "mint(address,uint256)";
4419 const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
4420 #[inline]
4421 fn new<'a>(
4422 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4423 ) -> Self {
4424 tuple.into()
4425 }
4426 #[inline]
4427 fn tokenize(&self) -> Self::Token<'_> {
4428 (
4429 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4430 &self.to,
4431 ),
4432 <alloy::sol_types::sol_data::Uint<
4433 256,
4434 > as alloy_sol_types::SolType>::tokenize(&self.amount),
4435 )
4436 }
4437 #[inline]
4438 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4439 mintReturn::_tokenize(ret)
4440 }
4441 #[inline]
4442 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4443 <Self::ReturnTuple<
4444 '_,
4445 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4446 .map(Into::into)
4447 }
4448 #[inline]
4449 fn abi_decode_returns_with_config(
4450 data: &[u8],
4451 config: alloy_sol_types::abi::AbiDecoderConfig,
4452 ) -> alloy_sol_types::Result<Self::Return> {
4453 <Self::ReturnTuple<
4454 '_,
4455 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
4456 data,
4457 config,
4458 )
4459 .map(Into::into)
4460 }
4461 #[inline]
4462 fn abi_decode_returns_validate(
4463 data: &[u8],
4464 ) -> alloy_sol_types::Result<Self::Return> {
4465 Self::abi_decode_returns_with_config(
4466 data,
4467 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4468 )
4469 }
4470 }
4471 };
4472 #[derive(serde::Serialize, serde::Deserialize)]
4473 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4474 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4479 #[derive(Clone)]
4480 pub struct nameCall;
4481 #[derive(serde::Serialize, serde::Deserialize)]
4482 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4483 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4485 #[derive(Clone)]
4486 pub struct nameReturn {
4487 #[allow(missing_docs)]
4488 pub _0: alloy::sol_types::private::String,
4489 }
4490 #[allow(
4491 non_camel_case_types,
4492 non_snake_case,
4493 clippy::pub_underscore_fields,
4494 clippy::style
4495 )]
4496 const _: () = {
4497 use alloy::sol_types as alloy_sol_types;
4498 {
4499 #[doc(hidden)]
4500 #[allow(dead_code)]
4501 type UnderlyingSolTuple<'a> = ();
4502 #[doc(hidden)]
4503 type UnderlyingRustTuple<'a> = ();
4504 #[cfg(test)]
4505 #[allow(dead_code, unreachable_patterns)]
4506 fn _type_assertion(
4507 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4508 ) {
4509 match _t {
4510 alloy_sol_types::private::AssertTypeEq::<
4511 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4512 >(_) => {}
4513 }
4514 }
4515 #[automatically_derived]
4516 #[doc(hidden)]
4517 impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
4518 fn from(value: nameCall) -> Self {
4519 ()
4520 }
4521 }
4522 #[automatically_derived]
4523 #[doc(hidden)]
4524 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
4525 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4526 Self
4527 }
4528 }
4529 }
4530 {
4531 #[doc(hidden)]
4532 #[allow(dead_code)]
4533 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
4534 #[doc(hidden)]
4535 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
4536 #[cfg(test)]
4537 #[allow(dead_code, unreachable_patterns)]
4538 fn _type_assertion(
4539 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4540 ) {
4541 match _t {
4542 alloy_sol_types::private::AssertTypeEq::<
4543 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4544 >(_) => {}
4545 }
4546 }
4547 #[automatically_derived]
4548 #[doc(hidden)]
4549 impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
4550 fn from(value: nameReturn) -> Self {
4551 (value._0,)
4552 }
4553 }
4554 #[automatically_derived]
4555 #[doc(hidden)]
4556 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
4557 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4558 Self { _0: tuple.0 }
4559 }
4560 }
4561 }
4562 #[automatically_derived]
4563 impl alloy_sol_types::SolCall for nameCall {
4564 type Parameters<'a> = ();
4565 type Token<'a> = <Self::Parameters<
4566 'a,
4567 > as alloy_sol_types::SolType>::Token<'a>;
4568 type Return = alloy::sol_types::private::String;
4569 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
4570 type ReturnToken<'a> = <Self::ReturnTuple<
4571 'a,
4572 > as alloy_sol_types::SolType>::Token<'a>;
4573 const SIGNATURE: &'static str = "name()";
4574 const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
4575 #[inline]
4576 fn new<'a>(
4577 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4578 ) -> Self {
4579 tuple.into()
4580 }
4581 #[inline]
4582 fn tokenize(&self) -> Self::Token<'_> {
4583 ()
4584 }
4585 #[inline]
4586 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4587 (
4588 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
4589 ret,
4590 ),
4591 )
4592 }
4593 #[inline]
4594 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4595 <Self::ReturnTuple<
4596 '_,
4597 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4598 .map(|r| {
4599 let r: nameReturn = r.into();
4600 r._0
4601 })
4602 }
4603 #[inline]
4604 fn abi_decode_returns_with_config(
4605 data: &[u8],
4606 config: alloy_sol_types::abi::AbiDecoderConfig,
4607 ) -> alloy_sol_types::Result<Self::Return> {
4608 <Self::ReturnTuple<
4609 '_,
4610 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
4611 data,
4612 config,
4613 )
4614 .map(|r| {
4615 let r: nameReturn = r.into();
4616 r._0
4617 })
4618 }
4619 #[inline]
4620 fn abi_decode_returns_validate(
4621 data: &[u8],
4622 ) -> alloy_sol_types::Result<Self::Return> {
4623 Self::abi_decode_returns_with_config(
4624 data,
4625 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4626 )
4627 }
4628 }
4629 };
4630 #[derive(serde::Serialize, serde::Deserialize)]
4631 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4632 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4637 #[derive(Clone)]
4638 pub struct ownerCall;
4639 #[derive(serde::Serialize, serde::Deserialize)]
4640 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4641 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4643 #[derive(Clone)]
4644 pub struct ownerReturn {
4645 #[allow(missing_docs)]
4646 pub _0: alloy::sol_types::private::Address,
4647 }
4648 #[allow(
4649 non_camel_case_types,
4650 non_snake_case,
4651 clippy::pub_underscore_fields,
4652 clippy::style
4653 )]
4654 const _: () = {
4655 use alloy::sol_types as alloy_sol_types;
4656 {
4657 #[doc(hidden)]
4658 #[allow(dead_code)]
4659 type UnderlyingSolTuple<'a> = ();
4660 #[doc(hidden)]
4661 type UnderlyingRustTuple<'a> = ();
4662 #[cfg(test)]
4663 #[allow(dead_code, unreachable_patterns)]
4664 fn _type_assertion(
4665 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4666 ) {
4667 match _t {
4668 alloy_sol_types::private::AssertTypeEq::<
4669 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4670 >(_) => {}
4671 }
4672 }
4673 #[automatically_derived]
4674 #[doc(hidden)]
4675 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
4676 fn from(value: ownerCall) -> Self {
4677 ()
4678 }
4679 }
4680 #[automatically_derived]
4681 #[doc(hidden)]
4682 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
4683 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4684 Self
4685 }
4686 }
4687 }
4688 {
4689 #[doc(hidden)]
4690 #[allow(dead_code)]
4691 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4692 #[doc(hidden)]
4693 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4694 #[cfg(test)]
4695 #[allow(dead_code, unreachable_patterns)]
4696 fn _type_assertion(
4697 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4698 ) {
4699 match _t {
4700 alloy_sol_types::private::AssertTypeEq::<
4701 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4702 >(_) => {}
4703 }
4704 }
4705 #[automatically_derived]
4706 #[doc(hidden)]
4707 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
4708 fn from(value: ownerReturn) -> Self {
4709 (value._0,)
4710 }
4711 }
4712 #[automatically_derived]
4713 #[doc(hidden)]
4714 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
4715 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4716 Self { _0: tuple.0 }
4717 }
4718 }
4719 }
4720 #[automatically_derived]
4721 impl alloy_sol_types::SolCall for ownerCall {
4722 type Parameters<'a> = ();
4723 type Token<'a> = <Self::Parameters<
4724 'a,
4725 > as alloy_sol_types::SolType>::Token<'a>;
4726 type Return = alloy::sol_types::private::Address;
4727 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
4728 type ReturnToken<'a> = <Self::ReturnTuple<
4729 'a,
4730 > as alloy_sol_types::SolType>::Token<'a>;
4731 const SIGNATURE: &'static str = "owner()";
4732 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
4733 #[inline]
4734 fn new<'a>(
4735 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4736 ) -> Self {
4737 tuple.into()
4738 }
4739 #[inline]
4740 fn tokenize(&self) -> Self::Token<'_> {
4741 ()
4742 }
4743 #[inline]
4744 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4745 (
4746 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4747 ret,
4748 ),
4749 )
4750 }
4751 #[inline]
4752 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4753 <Self::ReturnTuple<
4754 '_,
4755 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4756 .map(|r| {
4757 let r: ownerReturn = r.into();
4758 r._0
4759 })
4760 }
4761 #[inline]
4762 fn abi_decode_returns_with_config(
4763 data: &[u8],
4764 config: alloy_sol_types::abi::AbiDecoderConfig,
4765 ) -> alloy_sol_types::Result<Self::Return> {
4766 <Self::ReturnTuple<
4767 '_,
4768 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
4769 data,
4770 config,
4771 )
4772 .map(|r| {
4773 let r: ownerReturn = r.into();
4774 r._0
4775 })
4776 }
4777 #[inline]
4778 fn abi_decode_returns_validate(
4779 data: &[u8],
4780 ) -> alloy_sol_types::Result<Self::Return> {
4781 Self::abi_decode_returns_with_config(
4782 data,
4783 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4784 )
4785 }
4786 }
4787 };
4788 #[derive(serde::Serialize, serde::Deserialize)]
4789 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4790 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4795 #[derive(Clone)]
4796 pub struct proxiableUUIDCall;
4797 #[derive(serde::Serialize, serde::Deserialize)]
4798 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4799 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4801 #[derive(Clone)]
4802 pub struct proxiableUUIDReturn {
4803 #[allow(missing_docs)]
4804 pub _0: alloy::sol_types::private::FixedBytes<32>,
4805 }
4806 #[allow(
4807 non_camel_case_types,
4808 non_snake_case,
4809 clippy::pub_underscore_fields,
4810 clippy::style
4811 )]
4812 const _: () = {
4813 use alloy::sol_types as alloy_sol_types;
4814 {
4815 #[doc(hidden)]
4816 #[allow(dead_code)]
4817 type UnderlyingSolTuple<'a> = ();
4818 #[doc(hidden)]
4819 type UnderlyingRustTuple<'a> = ();
4820 #[cfg(test)]
4821 #[allow(dead_code, unreachable_patterns)]
4822 fn _type_assertion(
4823 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4824 ) {
4825 match _t {
4826 alloy_sol_types::private::AssertTypeEq::<
4827 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4828 >(_) => {}
4829 }
4830 }
4831 #[automatically_derived]
4832 #[doc(hidden)]
4833 impl ::core::convert::From<proxiableUUIDCall> for UnderlyingRustTuple<'_> {
4834 fn from(value: proxiableUUIDCall) -> Self {
4835 ()
4836 }
4837 }
4838 #[automatically_derived]
4839 #[doc(hidden)]
4840 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDCall {
4841 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4842 Self
4843 }
4844 }
4845 }
4846 {
4847 #[doc(hidden)]
4848 #[allow(dead_code)]
4849 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4850 #[doc(hidden)]
4851 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4852 #[cfg(test)]
4853 #[allow(dead_code, unreachable_patterns)]
4854 fn _type_assertion(
4855 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4856 ) {
4857 match _t {
4858 alloy_sol_types::private::AssertTypeEq::<
4859 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4860 >(_) => {}
4861 }
4862 }
4863 #[automatically_derived]
4864 #[doc(hidden)]
4865 impl ::core::convert::From<proxiableUUIDReturn> for UnderlyingRustTuple<'_> {
4866 fn from(value: proxiableUUIDReturn) -> Self {
4867 (value._0,)
4868 }
4869 }
4870 #[automatically_derived]
4871 #[doc(hidden)]
4872 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDReturn {
4873 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4874 Self { _0: tuple.0 }
4875 }
4876 }
4877 }
4878 #[automatically_derived]
4879 impl alloy_sol_types::SolCall for proxiableUUIDCall {
4880 type Parameters<'a> = ();
4881 type Token<'a> = <Self::Parameters<
4882 'a,
4883 > as alloy_sol_types::SolType>::Token<'a>;
4884 type Return = alloy::sol_types::private::FixedBytes<32>;
4885 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4886 type ReturnToken<'a> = <Self::ReturnTuple<
4887 'a,
4888 > as alloy_sol_types::SolType>::Token<'a>;
4889 const SIGNATURE: &'static str = "proxiableUUID()";
4890 const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8];
4891 #[inline]
4892 fn new<'a>(
4893 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4894 ) -> Self {
4895 tuple.into()
4896 }
4897 #[inline]
4898 fn tokenize(&self) -> Self::Token<'_> {
4899 ()
4900 }
4901 #[inline]
4902 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4903 (
4904 <alloy::sol_types::sol_data::FixedBytes<
4905 32,
4906 > as alloy_sol_types::SolType>::tokenize(ret),
4907 )
4908 }
4909 #[inline]
4910 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4911 <Self::ReturnTuple<
4912 '_,
4913 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4914 .map(|r| {
4915 let r: proxiableUUIDReturn = r.into();
4916 r._0
4917 })
4918 }
4919 #[inline]
4920 fn abi_decode_returns_with_config(
4921 data: &[u8],
4922 config: alloy_sol_types::abi::AbiDecoderConfig,
4923 ) -> alloy_sol_types::Result<Self::Return> {
4924 <Self::ReturnTuple<
4925 '_,
4926 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
4927 data,
4928 config,
4929 )
4930 .map(|r| {
4931 let r: proxiableUUIDReturn = r.into();
4932 r._0
4933 })
4934 }
4935 #[inline]
4936 fn abi_decode_returns_validate(
4937 data: &[u8],
4938 ) -> alloy_sol_types::Result<Self::Return> {
4939 Self::abi_decode_returns_with_config(
4940 data,
4941 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4942 )
4943 }
4944 }
4945 };
4946 #[derive(serde::Serialize, serde::Deserialize)]
4947 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4948 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4953 #[derive(Clone)]
4954 pub struct renounceOwnershipCall;
4955 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4957 #[derive(Clone)]
4958 pub struct renounceOwnershipReturn {}
4959 #[allow(
4960 non_camel_case_types,
4961 non_snake_case,
4962 clippy::pub_underscore_fields,
4963 clippy::style
4964 )]
4965 const _: () = {
4966 use alloy::sol_types as alloy_sol_types;
4967 {
4968 #[doc(hidden)]
4969 #[allow(dead_code)]
4970 type UnderlyingSolTuple<'a> = ();
4971 #[doc(hidden)]
4972 type UnderlyingRustTuple<'a> = ();
4973 #[cfg(test)]
4974 #[allow(dead_code, unreachable_patterns)]
4975 fn _type_assertion(
4976 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4977 ) {
4978 match _t {
4979 alloy_sol_types::private::AssertTypeEq::<
4980 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4981 >(_) => {}
4982 }
4983 }
4984 #[automatically_derived]
4985 #[doc(hidden)]
4986 impl ::core::convert::From<renounceOwnershipCall>
4987 for UnderlyingRustTuple<'_> {
4988 fn from(value: renounceOwnershipCall) -> Self {
4989 ()
4990 }
4991 }
4992 #[automatically_derived]
4993 #[doc(hidden)]
4994 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4995 for renounceOwnershipCall {
4996 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4997 Self
4998 }
4999 }
5000 }
5001 {
5002 #[doc(hidden)]
5003 #[allow(dead_code)]
5004 type UnderlyingSolTuple<'a> = ();
5005 #[doc(hidden)]
5006 type UnderlyingRustTuple<'a> = ();
5007 #[cfg(test)]
5008 #[allow(dead_code, unreachable_patterns)]
5009 fn _type_assertion(
5010 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5011 ) {
5012 match _t {
5013 alloy_sol_types::private::AssertTypeEq::<
5014 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5015 >(_) => {}
5016 }
5017 }
5018 #[automatically_derived]
5019 #[doc(hidden)]
5020 impl ::core::convert::From<renounceOwnershipReturn>
5021 for UnderlyingRustTuple<'_> {
5022 fn from(value: renounceOwnershipReturn) -> Self {
5023 ()
5024 }
5025 }
5026 #[automatically_derived]
5027 #[doc(hidden)]
5028 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5029 for renounceOwnershipReturn {
5030 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5031 Self {}
5032 }
5033 }
5034 }
5035 impl renounceOwnershipReturn {
5036 fn _tokenize(
5037 &self,
5038 ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
5039 ()
5040 }
5041 }
5042 #[automatically_derived]
5043 impl alloy_sol_types::SolCall for renounceOwnershipCall {
5044 type Parameters<'a> = ();
5045 type Token<'a> = <Self::Parameters<
5046 'a,
5047 > as alloy_sol_types::SolType>::Token<'a>;
5048 type Return = renounceOwnershipReturn;
5049 type ReturnTuple<'a> = ();
5050 type ReturnToken<'a> = <Self::ReturnTuple<
5051 'a,
5052 > as alloy_sol_types::SolType>::Token<'a>;
5053 const SIGNATURE: &'static str = "renounceOwnership()";
5054 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
5055 #[inline]
5056 fn new<'a>(
5057 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5058 ) -> Self {
5059 tuple.into()
5060 }
5061 #[inline]
5062 fn tokenize(&self) -> Self::Token<'_> {
5063 ()
5064 }
5065 #[inline]
5066 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5067 renounceOwnershipReturn::_tokenize(ret)
5068 }
5069 #[inline]
5070 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5071 <Self::ReturnTuple<
5072 '_,
5073 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5074 .map(Into::into)
5075 }
5076 #[inline]
5077 fn abi_decode_returns_with_config(
5078 data: &[u8],
5079 config: alloy_sol_types::abi::AbiDecoderConfig,
5080 ) -> alloy_sol_types::Result<Self::Return> {
5081 <Self::ReturnTuple<
5082 '_,
5083 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
5084 data,
5085 config,
5086 )
5087 .map(Into::into)
5088 }
5089 #[inline]
5090 fn abi_decode_returns_validate(
5091 data: &[u8],
5092 ) -> alloy_sol_types::Result<Self::Return> {
5093 Self::abi_decode_returns_with_config(
5094 data,
5095 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
5096 )
5097 }
5098 }
5099 };
5100 #[derive(serde::Serialize, serde::Deserialize)]
5101 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5102 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5107 #[derive(Clone)]
5108 pub struct rewardClaimCall;
5109 #[derive(serde::Serialize, serde::Deserialize)]
5110 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5111 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5113 #[derive(Clone)]
5114 pub struct rewardClaimReturn {
5115 #[allow(missing_docs)]
5116 pub _0: alloy::sol_types::private::Address,
5117 }
5118 #[allow(
5119 non_camel_case_types,
5120 non_snake_case,
5121 clippy::pub_underscore_fields,
5122 clippy::style
5123 )]
5124 const _: () = {
5125 use alloy::sol_types as alloy_sol_types;
5126 {
5127 #[doc(hidden)]
5128 #[allow(dead_code)]
5129 type UnderlyingSolTuple<'a> = ();
5130 #[doc(hidden)]
5131 type UnderlyingRustTuple<'a> = ();
5132 #[cfg(test)]
5133 #[allow(dead_code, unreachable_patterns)]
5134 fn _type_assertion(
5135 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5136 ) {
5137 match _t {
5138 alloy_sol_types::private::AssertTypeEq::<
5139 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5140 >(_) => {}
5141 }
5142 }
5143 #[automatically_derived]
5144 #[doc(hidden)]
5145 impl ::core::convert::From<rewardClaimCall> for UnderlyingRustTuple<'_> {
5146 fn from(value: rewardClaimCall) -> Self {
5147 ()
5148 }
5149 }
5150 #[automatically_derived]
5151 #[doc(hidden)]
5152 impl ::core::convert::From<UnderlyingRustTuple<'_>> for rewardClaimCall {
5153 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5154 Self
5155 }
5156 }
5157 }
5158 {
5159 #[doc(hidden)]
5160 #[allow(dead_code)]
5161 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5162 #[doc(hidden)]
5163 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5164 #[cfg(test)]
5165 #[allow(dead_code, unreachable_patterns)]
5166 fn _type_assertion(
5167 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5168 ) {
5169 match _t {
5170 alloy_sol_types::private::AssertTypeEq::<
5171 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5172 >(_) => {}
5173 }
5174 }
5175 #[automatically_derived]
5176 #[doc(hidden)]
5177 impl ::core::convert::From<rewardClaimReturn> for UnderlyingRustTuple<'_> {
5178 fn from(value: rewardClaimReturn) -> Self {
5179 (value._0,)
5180 }
5181 }
5182 #[automatically_derived]
5183 #[doc(hidden)]
5184 impl ::core::convert::From<UnderlyingRustTuple<'_>> for rewardClaimReturn {
5185 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5186 Self { _0: tuple.0 }
5187 }
5188 }
5189 }
5190 #[automatically_derived]
5191 impl alloy_sol_types::SolCall for rewardClaimCall {
5192 type Parameters<'a> = ();
5193 type Token<'a> = <Self::Parameters<
5194 'a,
5195 > as alloy_sol_types::SolType>::Token<'a>;
5196 type Return = alloy::sol_types::private::Address;
5197 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
5198 type ReturnToken<'a> = <Self::ReturnTuple<
5199 'a,
5200 > as alloy_sol_types::SolType>::Token<'a>;
5201 const SIGNATURE: &'static str = "rewardClaim()";
5202 const SELECTOR: [u8; 4] = [100u8, 9u8, 249u8, 33u8];
5203 #[inline]
5204 fn new<'a>(
5205 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5206 ) -> Self {
5207 tuple.into()
5208 }
5209 #[inline]
5210 fn tokenize(&self) -> Self::Token<'_> {
5211 ()
5212 }
5213 #[inline]
5214 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5215 (
5216 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5217 ret,
5218 ),
5219 )
5220 }
5221 #[inline]
5222 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5223 <Self::ReturnTuple<
5224 '_,
5225 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5226 .map(|r| {
5227 let r: rewardClaimReturn = r.into();
5228 r._0
5229 })
5230 }
5231 #[inline]
5232 fn abi_decode_returns_with_config(
5233 data: &[u8],
5234 config: alloy_sol_types::abi::AbiDecoderConfig,
5235 ) -> alloy_sol_types::Result<Self::Return> {
5236 <Self::ReturnTuple<
5237 '_,
5238 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
5239 data,
5240 config,
5241 )
5242 .map(|r| {
5243 let r: rewardClaimReturn = r.into();
5244 r._0
5245 })
5246 }
5247 #[inline]
5248 fn abi_decode_returns_validate(
5249 data: &[u8],
5250 ) -> alloy_sol_types::Result<Self::Return> {
5251 Self::abi_decode_returns_with_config(
5252 data,
5253 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
5254 )
5255 }
5256 }
5257 };
5258 #[derive(serde::Serialize, serde::Deserialize)]
5259 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5260 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5265 #[derive(Clone)]
5266 pub struct symbolCall;
5267 #[derive(serde::Serialize, serde::Deserialize)]
5268 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5269 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5271 #[derive(Clone)]
5272 pub struct symbolReturn {
5273 #[allow(missing_docs)]
5274 pub _0: alloy::sol_types::private::String,
5275 }
5276 #[allow(
5277 non_camel_case_types,
5278 non_snake_case,
5279 clippy::pub_underscore_fields,
5280 clippy::style
5281 )]
5282 const _: () = {
5283 use alloy::sol_types as alloy_sol_types;
5284 {
5285 #[doc(hidden)]
5286 #[allow(dead_code)]
5287 type UnderlyingSolTuple<'a> = ();
5288 #[doc(hidden)]
5289 type UnderlyingRustTuple<'a> = ();
5290 #[cfg(test)]
5291 #[allow(dead_code, unreachable_patterns)]
5292 fn _type_assertion(
5293 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5294 ) {
5295 match _t {
5296 alloy_sol_types::private::AssertTypeEq::<
5297 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5298 >(_) => {}
5299 }
5300 }
5301 #[automatically_derived]
5302 #[doc(hidden)]
5303 impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
5304 fn from(value: symbolCall) -> Self {
5305 ()
5306 }
5307 }
5308 #[automatically_derived]
5309 #[doc(hidden)]
5310 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
5311 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5312 Self
5313 }
5314 }
5315 }
5316 {
5317 #[doc(hidden)]
5318 #[allow(dead_code)]
5319 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
5320 #[doc(hidden)]
5321 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
5322 #[cfg(test)]
5323 #[allow(dead_code, unreachable_patterns)]
5324 fn _type_assertion(
5325 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5326 ) {
5327 match _t {
5328 alloy_sol_types::private::AssertTypeEq::<
5329 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5330 >(_) => {}
5331 }
5332 }
5333 #[automatically_derived]
5334 #[doc(hidden)]
5335 impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
5336 fn from(value: symbolReturn) -> Self {
5337 (value._0,)
5338 }
5339 }
5340 #[automatically_derived]
5341 #[doc(hidden)]
5342 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
5343 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5344 Self { _0: tuple.0 }
5345 }
5346 }
5347 }
5348 #[automatically_derived]
5349 impl alloy_sol_types::SolCall for symbolCall {
5350 type Parameters<'a> = ();
5351 type Token<'a> = <Self::Parameters<
5352 'a,
5353 > as alloy_sol_types::SolType>::Token<'a>;
5354 type Return = alloy::sol_types::private::String;
5355 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
5356 type ReturnToken<'a> = <Self::ReturnTuple<
5357 'a,
5358 > as alloy_sol_types::SolType>::Token<'a>;
5359 const SIGNATURE: &'static str = "symbol()";
5360 const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
5361 #[inline]
5362 fn new<'a>(
5363 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5364 ) -> Self {
5365 tuple.into()
5366 }
5367 #[inline]
5368 fn tokenize(&self) -> Self::Token<'_> {
5369 ()
5370 }
5371 #[inline]
5372 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5373 (
5374 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
5375 ret,
5376 ),
5377 )
5378 }
5379 #[inline]
5380 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5381 <Self::ReturnTuple<
5382 '_,
5383 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5384 .map(|r| {
5385 let r: symbolReturn = r.into();
5386 r._0
5387 })
5388 }
5389 #[inline]
5390 fn abi_decode_returns_with_config(
5391 data: &[u8],
5392 config: alloy_sol_types::abi::AbiDecoderConfig,
5393 ) -> alloy_sol_types::Result<Self::Return> {
5394 <Self::ReturnTuple<
5395 '_,
5396 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
5397 data,
5398 config,
5399 )
5400 .map(|r| {
5401 let r: symbolReturn = r.into();
5402 r._0
5403 })
5404 }
5405 #[inline]
5406 fn abi_decode_returns_validate(
5407 data: &[u8],
5408 ) -> alloy_sol_types::Result<Self::Return> {
5409 Self::abi_decode_returns_with_config(
5410 data,
5411 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
5412 )
5413 }
5414 }
5415 };
5416 #[derive(serde::Serialize, serde::Deserialize)]
5417 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5418 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5423 #[derive(Clone)]
5424 pub struct totalSupplyCall;
5425 #[derive(serde::Serialize, serde::Deserialize)]
5426 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5427 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5429 #[derive(Clone)]
5430 pub struct totalSupplyReturn {
5431 #[allow(missing_docs)]
5432 pub _0: alloy::sol_types::private::primitives::aliases::U256,
5433 }
5434 #[allow(
5435 non_camel_case_types,
5436 non_snake_case,
5437 clippy::pub_underscore_fields,
5438 clippy::style
5439 )]
5440 const _: () = {
5441 use alloy::sol_types as alloy_sol_types;
5442 {
5443 #[doc(hidden)]
5444 #[allow(dead_code)]
5445 type UnderlyingSolTuple<'a> = ();
5446 #[doc(hidden)]
5447 type UnderlyingRustTuple<'a> = ();
5448 #[cfg(test)]
5449 #[allow(dead_code, unreachable_patterns)]
5450 fn _type_assertion(
5451 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5452 ) {
5453 match _t {
5454 alloy_sol_types::private::AssertTypeEq::<
5455 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5456 >(_) => {}
5457 }
5458 }
5459 #[automatically_derived]
5460 #[doc(hidden)]
5461 impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
5462 fn from(value: totalSupplyCall) -> Self {
5463 ()
5464 }
5465 }
5466 #[automatically_derived]
5467 #[doc(hidden)]
5468 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
5469 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5470 Self
5471 }
5472 }
5473 }
5474 {
5475 #[doc(hidden)]
5476 #[allow(dead_code)]
5477 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5478 #[doc(hidden)]
5479 type UnderlyingRustTuple<'a> = (
5480 alloy::sol_types::private::primitives::aliases::U256,
5481 );
5482 #[cfg(test)]
5483 #[allow(dead_code, unreachable_patterns)]
5484 fn _type_assertion(
5485 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5486 ) {
5487 match _t {
5488 alloy_sol_types::private::AssertTypeEq::<
5489 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5490 >(_) => {}
5491 }
5492 }
5493 #[automatically_derived]
5494 #[doc(hidden)]
5495 impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
5496 fn from(value: totalSupplyReturn) -> Self {
5497 (value._0,)
5498 }
5499 }
5500 #[automatically_derived]
5501 #[doc(hidden)]
5502 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
5503 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5504 Self { _0: tuple.0 }
5505 }
5506 }
5507 }
5508 #[automatically_derived]
5509 impl alloy_sol_types::SolCall for totalSupplyCall {
5510 type Parameters<'a> = ();
5511 type Token<'a> = <Self::Parameters<
5512 'a,
5513 > as alloy_sol_types::SolType>::Token<'a>;
5514 type Return = alloy::sol_types::private::primitives::aliases::U256;
5515 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5516 type ReturnToken<'a> = <Self::ReturnTuple<
5517 'a,
5518 > as alloy_sol_types::SolType>::Token<'a>;
5519 const SIGNATURE: &'static str = "totalSupply()";
5520 const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
5521 #[inline]
5522 fn new<'a>(
5523 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5524 ) -> Self {
5525 tuple.into()
5526 }
5527 #[inline]
5528 fn tokenize(&self) -> Self::Token<'_> {
5529 ()
5530 }
5531 #[inline]
5532 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5533 (
5534 <alloy::sol_types::sol_data::Uint<
5535 256,
5536 > as alloy_sol_types::SolType>::tokenize(ret),
5537 )
5538 }
5539 #[inline]
5540 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5541 <Self::ReturnTuple<
5542 '_,
5543 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5544 .map(|r| {
5545 let r: totalSupplyReturn = r.into();
5546 r._0
5547 })
5548 }
5549 #[inline]
5550 fn abi_decode_returns_with_config(
5551 data: &[u8],
5552 config: alloy_sol_types::abi::AbiDecoderConfig,
5553 ) -> alloy_sol_types::Result<Self::Return> {
5554 <Self::ReturnTuple<
5555 '_,
5556 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
5557 data,
5558 config,
5559 )
5560 .map(|r| {
5561 let r: totalSupplyReturn = r.into();
5562 r._0
5563 })
5564 }
5565 #[inline]
5566 fn abi_decode_returns_validate(
5567 data: &[u8],
5568 ) -> alloy_sol_types::Result<Self::Return> {
5569 Self::abi_decode_returns_with_config(
5570 data,
5571 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
5572 )
5573 }
5574 }
5575 };
5576 #[derive(serde::Serialize, serde::Deserialize)]
5577 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5578 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5583 #[derive(Clone)]
5584 pub struct transferCall {
5585 #[allow(missing_docs)]
5586 pub to: alloy::sol_types::private::Address,
5587 #[allow(missing_docs)]
5588 pub value: alloy::sol_types::private::primitives::aliases::U256,
5589 }
5590 #[derive(serde::Serialize, serde::Deserialize)]
5591 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5592 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5594 #[derive(Clone)]
5595 pub struct transferReturn {
5596 #[allow(missing_docs)]
5597 pub _0: bool,
5598 }
5599 #[allow(
5600 non_camel_case_types,
5601 non_snake_case,
5602 clippy::pub_underscore_fields,
5603 clippy::style
5604 )]
5605 const _: () = {
5606 use alloy::sol_types as alloy_sol_types;
5607 {
5608 #[doc(hidden)]
5609 #[allow(dead_code)]
5610 type UnderlyingSolTuple<'a> = (
5611 alloy::sol_types::sol_data::Address,
5612 alloy::sol_types::sol_data::Uint<256>,
5613 );
5614 #[doc(hidden)]
5615 type UnderlyingRustTuple<'a> = (
5616 alloy::sol_types::private::Address,
5617 alloy::sol_types::private::primitives::aliases::U256,
5618 );
5619 #[cfg(test)]
5620 #[allow(dead_code, unreachable_patterns)]
5621 fn _type_assertion(
5622 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5623 ) {
5624 match _t {
5625 alloy_sol_types::private::AssertTypeEq::<
5626 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5627 >(_) => {}
5628 }
5629 }
5630 #[automatically_derived]
5631 #[doc(hidden)]
5632 impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
5633 fn from(value: transferCall) -> Self {
5634 (value.to, value.value)
5635 }
5636 }
5637 #[automatically_derived]
5638 #[doc(hidden)]
5639 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
5640 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5641 Self {
5642 to: tuple.0,
5643 value: tuple.1,
5644 }
5645 }
5646 }
5647 }
5648 {
5649 #[doc(hidden)]
5650 #[allow(dead_code)]
5651 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5652 #[doc(hidden)]
5653 type UnderlyingRustTuple<'a> = (bool,);
5654 #[cfg(test)]
5655 #[allow(dead_code, unreachable_patterns)]
5656 fn _type_assertion(
5657 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5658 ) {
5659 match _t {
5660 alloy_sol_types::private::AssertTypeEq::<
5661 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5662 >(_) => {}
5663 }
5664 }
5665 #[automatically_derived]
5666 #[doc(hidden)]
5667 impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
5668 fn from(value: transferReturn) -> Self {
5669 (value._0,)
5670 }
5671 }
5672 #[automatically_derived]
5673 #[doc(hidden)]
5674 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
5675 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5676 Self { _0: tuple.0 }
5677 }
5678 }
5679 }
5680 #[automatically_derived]
5681 impl alloy_sol_types::SolCall for transferCall {
5682 type Parameters<'a> = (
5683 alloy::sol_types::sol_data::Address,
5684 alloy::sol_types::sol_data::Uint<256>,
5685 );
5686 type Token<'a> = <Self::Parameters<
5687 'a,
5688 > as alloy_sol_types::SolType>::Token<'a>;
5689 type Return = bool;
5690 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5691 type ReturnToken<'a> = <Self::ReturnTuple<
5692 'a,
5693 > as alloy_sol_types::SolType>::Token<'a>;
5694 const SIGNATURE: &'static str = "transfer(address,uint256)";
5695 const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
5696 #[inline]
5697 fn new<'a>(
5698 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5699 ) -> Self {
5700 tuple.into()
5701 }
5702 #[inline]
5703 fn tokenize(&self) -> Self::Token<'_> {
5704 (
5705 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5706 &self.to,
5707 ),
5708 <alloy::sol_types::sol_data::Uint<
5709 256,
5710 > as alloy_sol_types::SolType>::tokenize(&self.value),
5711 )
5712 }
5713 #[inline]
5714 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5715 (
5716 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
5717 ret,
5718 ),
5719 )
5720 }
5721 #[inline]
5722 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5723 <Self::ReturnTuple<
5724 '_,
5725 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5726 .map(|r| {
5727 let r: transferReturn = r.into();
5728 r._0
5729 })
5730 }
5731 #[inline]
5732 fn abi_decode_returns_with_config(
5733 data: &[u8],
5734 config: alloy_sol_types::abi::AbiDecoderConfig,
5735 ) -> alloy_sol_types::Result<Self::Return> {
5736 <Self::ReturnTuple<
5737 '_,
5738 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
5739 data,
5740 config,
5741 )
5742 .map(|r| {
5743 let r: transferReturn = r.into();
5744 r._0
5745 })
5746 }
5747 #[inline]
5748 fn abi_decode_returns_validate(
5749 data: &[u8],
5750 ) -> alloy_sol_types::Result<Self::Return> {
5751 Self::abi_decode_returns_with_config(
5752 data,
5753 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
5754 )
5755 }
5756 }
5757 };
5758 #[derive(serde::Serialize, serde::Deserialize)]
5759 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5760 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5765 #[derive(Clone)]
5766 pub struct transferFromCall {
5767 #[allow(missing_docs)]
5768 pub from: alloy::sol_types::private::Address,
5769 #[allow(missing_docs)]
5770 pub to: alloy::sol_types::private::Address,
5771 #[allow(missing_docs)]
5772 pub value: alloy::sol_types::private::primitives::aliases::U256,
5773 }
5774 #[derive(serde::Serialize, serde::Deserialize)]
5775 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5776 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5778 #[derive(Clone)]
5779 pub struct transferFromReturn {
5780 #[allow(missing_docs)]
5781 pub _0: bool,
5782 }
5783 #[allow(
5784 non_camel_case_types,
5785 non_snake_case,
5786 clippy::pub_underscore_fields,
5787 clippy::style
5788 )]
5789 const _: () = {
5790 use alloy::sol_types as alloy_sol_types;
5791 {
5792 #[doc(hidden)]
5793 #[allow(dead_code)]
5794 type UnderlyingSolTuple<'a> = (
5795 alloy::sol_types::sol_data::Address,
5796 alloy::sol_types::sol_data::Address,
5797 alloy::sol_types::sol_data::Uint<256>,
5798 );
5799 #[doc(hidden)]
5800 type UnderlyingRustTuple<'a> = (
5801 alloy::sol_types::private::Address,
5802 alloy::sol_types::private::Address,
5803 alloy::sol_types::private::primitives::aliases::U256,
5804 );
5805 #[cfg(test)]
5806 #[allow(dead_code, unreachable_patterns)]
5807 fn _type_assertion(
5808 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5809 ) {
5810 match _t {
5811 alloy_sol_types::private::AssertTypeEq::<
5812 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5813 >(_) => {}
5814 }
5815 }
5816 #[automatically_derived]
5817 #[doc(hidden)]
5818 impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
5819 fn from(value: transferFromCall) -> Self {
5820 (value.from, value.to, value.value)
5821 }
5822 }
5823 #[automatically_derived]
5824 #[doc(hidden)]
5825 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
5826 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5827 Self {
5828 from: tuple.0,
5829 to: tuple.1,
5830 value: tuple.2,
5831 }
5832 }
5833 }
5834 }
5835 {
5836 #[doc(hidden)]
5837 #[allow(dead_code)]
5838 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5839 #[doc(hidden)]
5840 type UnderlyingRustTuple<'a> = (bool,);
5841 #[cfg(test)]
5842 #[allow(dead_code, unreachable_patterns)]
5843 fn _type_assertion(
5844 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5845 ) {
5846 match _t {
5847 alloy_sol_types::private::AssertTypeEq::<
5848 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5849 >(_) => {}
5850 }
5851 }
5852 #[automatically_derived]
5853 #[doc(hidden)]
5854 impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
5855 fn from(value: transferFromReturn) -> Self {
5856 (value._0,)
5857 }
5858 }
5859 #[automatically_derived]
5860 #[doc(hidden)]
5861 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
5862 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5863 Self { _0: tuple.0 }
5864 }
5865 }
5866 }
5867 #[automatically_derived]
5868 impl alloy_sol_types::SolCall for transferFromCall {
5869 type Parameters<'a> = (
5870 alloy::sol_types::sol_data::Address,
5871 alloy::sol_types::sol_data::Address,
5872 alloy::sol_types::sol_data::Uint<256>,
5873 );
5874 type Token<'a> = <Self::Parameters<
5875 'a,
5876 > as alloy_sol_types::SolType>::Token<'a>;
5877 type Return = bool;
5878 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5879 type ReturnToken<'a> = <Self::ReturnTuple<
5880 'a,
5881 > as alloy_sol_types::SolType>::Token<'a>;
5882 const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
5883 const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
5884 #[inline]
5885 fn new<'a>(
5886 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5887 ) -> Self {
5888 tuple.into()
5889 }
5890 #[inline]
5891 fn tokenize(&self) -> Self::Token<'_> {
5892 (
5893 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5894 &self.from,
5895 ),
5896 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5897 &self.to,
5898 ),
5899 <alloy::sol_types::sol_data::Uint<
5900 256,
5901 > as alloy_sol_types::SolType>::tokenize(&self.value),
5902 )
5903 }
5904 #[inline]
5905 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5906 (
5907 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
5908 ret,
5909 ),
5910 )
5911 }
5912 #[inline]
5913 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5914 <Self::ReturnTuple<
5915 '_,
5916 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5917 .map(|r| {
5918 let r: transferFromReturn = r.into();
5919 r._0
5920 })
5921 }
5922 #[inline]
5923 fn abi_decode_returns_with_config(
5924 data: &[u8],
5925 config: alloy_sol_types::abi::AbiDecoderConfig,
5926 ) -> alloy_sol_types::Result<Self::Return> {
5927 <Self::ReturnTuple<
5928 '_,
5929 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
5930 data,
5931 config,
5932 )
5933 .map(|r| {
5934 let r: transferFromReturn = r.into();
5935 r._0
5936 })
5937 }
5938 #[inline]
5939 fn abi_decode_returns_validate(
5940 data: &[u8],
5941 ) -> alloy_sol_types::Result<Self::Return> {
5942 Self::abi_decode_returns_with_config(
5943 data,
5944 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
5945 )
5946 }
5947 }
5948 };
5949 #[derive(serde::Serialize, serde::Deserialize)]
5950 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5951 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5956 #[derive(Clone)]
5957 pub struct transferOwnershipCall {
5958 #[allow(missing_docs)]
5959 pub newOwner: alloy::sol_types::private::Address,
5960 }
5961 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5963 #[derive(Clone)]
5964 pub struct transferOwnershipReturn {}
5965 #[allow(
5966 non_camel_case_types,
5967 non_snake_case,
5968 clippy::pub_underscore_fields,
5969 clippy::style
5970 )]
5971 const _: () = {
5972 use alloy::sol_types as alloy_sol_types;
5973 {
5974 #[doc(hidden)]
5975 #[allow(dead_code)]
5976 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5977 #[doc(hidden)]
5978 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5979 #[cfg(test)]
5980 #[allow(dead_code, unreachable_patterns)]
5981 fn _type_assertion(
5982 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5983 ) {
5984 match _t {
5985 alloy_sol_types::private::AssertTypeEq::<
5986 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5987 >(_) => {}
5988 }
5989 }
5990 #[automatically_derived]
5991 #[doc(hidden)]
5992 impl ::core::convert::From<transferOwnershipCall>
5993 for UnderlyingRustTuple<'_> {
5994 fn from(value: transferOwnershipCall) -> Self {
5995 (value.newOwner,)
5996 }
5997 }
5998 #[automatically_derived]
5999 #[doc(hidden)]
6000 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6001 for transferOwnershipCall {
6002 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6003 Self { newOwner: tuple.0 }
6004 }
6005 }
6006 }
6007 {
6008 #[doc(hidden)]
6009 #[allow(dead_code)]
6010 type UnderlyingSolTuple<'a> = ();
6011 #[doc(hidden)]
6012 type UnderlyingRustTuple<'a> = ();
6013 #[cfg(test)]
6014 #[allow(dead_code, unreachable_patterns)]
6015 fn _type_assertion(
6016 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6017 ) {
6018 match _t {
6019 alloy_sol_types::private::AssertTypeEq::<
6020 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6021 >(_) => {}
6022 }
6023 }
6024 #[automatically_derived]
6025 #[doc(hidden)]
6026 impl ::core::convert::From<transferOwnershipReturn>
6027 for UnderlyingRustTuple<'_> {
6028 fn from(value: transferOwnershipReturn) -> Self {
6029 ()
6030 }
6031 }
6032 #[automatically_derived]
6033 #[doc(hidden)]
6034 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6035 for transferOwnershipReturn {
6036 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6037 Self {}
6038 }
6039 }
6040 }
6041 impl transferOwnershipReturn {
6042 fn _tokenize(
6043 &self,
6044 ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6045 ()
6046 }
6047 }
6048 #[automatically_derived]
6049 impl alloy_sol_types::SolCall for transferOwnershipCall {
6050 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
6051 type Token<'a> = <Self::Parameters<
6052 'a,
6053 > as alloy_sol_types::SolType>::Token<'a>;
6054 type Return = transferOwnershipReturn;
6055 type ReturnTuple<'a> = ();
6056 type ReturnToken<'a> = <Self::ReturnTuple<
6057 'a,
6058 > as alloy_sol_types::SolType>::Token<'a>;
6059 const SIGNATURE: &'static str = "transferOwnership(address)";
6060 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
6061 #[inline]
6062 fn new<'a>(
6063 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6064 ) -> Self {
6065 tuple.into()
6066 }
6067 #[inline]
6068 fn tokenize(&self) -> Self::Token<'_> {
6069 (
6070 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6071 &self.newOwner,
6072 ),
6073 )
6074 }
6075 #[inline]
6076 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6077 transferOwnershipReturn::_tokenize(ret)
6078 }
6079 #[inline]
6080 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6081 <Self::ReturnTuple<
6082 '_,
6083 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6084 .map(Into::into)
6085 }
6086 #[inline]
6087 fn abi_decode_returns_with_config(
6088 data: &[u8],
6089 config: alloy_sol_types::abi::AbiDecoderConfig,
6090 ) -> alloy_sol_types::Result<Self::Return> {
6091 <Self::ReturnTuple<
6092 '_,
6093 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
6094 data,
6095 config,
6096 )
6097 .map(Into::into)
6098 }
6099 #[inline]
6100 fn abi_decode_returns_validate(
6101 data: &[u8],
6102 ) -> alloy_sol_types::Result<Self::Return> {
6103 Self::abi_decode_returns_with_config(
6104 data,
6105 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
6106 )
6107 }
6108 }
6109 };
6110 #[derive(serde::Serialize, serde::Deserialize)]
6111 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6112 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6117 #[derive(Clone)]
6118 pub struct upgradeToAndCallCall {
6119 #[allow(missing_docs)]
6120 pub newImplementation: alloy::sol_types::private::Address,
6121 #[allow(missing_docs)]
6122 pub data: alloy::sol_types::private::Bytes,
6123 }
6124 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6126 #[derive(Clone)]
6127 pub struct upgradeToAndCallReturn {}
6128 #[allow(
6129 non_camel_case_types,
6130 non_snake_case,
6131 clippy::pub_underscore_fields,
6132 clippy::style
6133 )]
6134 const _: () = {
6135 use alloy::sol_types as alloy_sol_types;
6136 {
6137 #[doc(hidden)]
6138 #[allow(dead_code)]
6139 type UnderlyingSolTuple<'a> = (
6140 alloy::sol_types::sol_data::Address,
6141 alloy::sol_types::sol_data::Bytes,
6142 );
6143 #[doc(hidden)]
6144 type UnderlyingRustTuple<'a> = (
6145 alloy::sol_types::private::Address,
6146 alloy::sol_types::private::Bytes,
6147 );
6148 #[cfg(test)]
6149 #[allow(dead_code, unreachable_patterns)]
6150 fn _type_assertion(
6151 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6152 ) {
6153 match _t {
6154 alloy_sol_types::private::AssertTypeEq::<
6155 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6156 >(_) => {}
6157 }
6158 }
6159 #[automatically_derived]
6160 #[doc(hidden)]
6161 impl ::core::convert::From<upgradeToAndCallCall>
6162 for UnderlyingRustTuple<'_> {
6163 fn from(value: upgradeToAndCallCall) -> Self {
6164 (value.newImplementation, value.data)
6165 }
6166 }
6167 #[automatically_derived]
6168 #[doc(hidden)]
6169 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6170 for upgradeToAndCallCall {
6171 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6172 Self {
6173 newImplementation: tuple.0,
6174 data: tuple.1,
6175 }
6176 }
6177 }
6178 }
6179 {
6180 #[doc(hidden)]
6181 #[allow(dead_code)]
6182 type UnderlyingSolTuple<'a> = ();
6183 #[doc(hidden)]
6184 type UnderlyingRustTuple<'a> = ();
6185 #[cfg(test)]
6186 #[allow(dead_code, unreachable_patterns)]
6187 fn _type_assertion(
6188 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6189 ) {
6190 match _t {
6191 alloy_sol_types::private::AssertTypeEq::<
6192 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6193 >(_) => {}
6194 }
6195 }
6196 #[automatically_derived]
6197 #[doc(hidden)]
6198 impl ::core::convert::From<upgradeToAndCallReturn>
6199 for UnderlyingRustTuple<'_> {
6200 fn from(value: upgradeToAndCallReturn) -> Self {
6201 ()
6202 }
6203 }
6204 #[automatically_derived]
6205 #[doc(hidden)]
6206 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6207 for upgradeToAndCallReturn {
6208 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6209 Self {}
6210 }
6211 }
6212 }
6213 impl upgradeToAndCallReturn {
6214 fn _tokenize(
6215 &self,
6216 ) -> <upgradeToAndCallCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6217 ()
6218 }
6219 }
6220 #[automatically_derived]
6221 impl alloy_sol_types::SolCall for upgradeToAndCallCall {
6222 type Parameters<'a> = (
6223 alloy::sol_types::sol_data::Address,
6224 alloy::sol_types::sol_data::Bytes,
6225 );
6226 type Token<'a> = <Self::Parameters<
6227 'a,
6228 > as alloy_sol_types::SolType>::Token<'a>;
6229 type Return = upgradeToAndCallReturn;
6230 type ReturnTuple<'a> = ();
6231 type ReturnToken<'a> = <Self::ReturnTuple<
6232 'a,
6233 > as alloy_sol_types::SolType>::Token<'a>;
6234 const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)";
6235 const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8];
6236 #[inline]
6237 fn new<'a>(
6238 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6239 ) -> Self {
6240 tuple.into()
6241 }
6242 #[inline]
6243 fn tokenize(&self) -> Self::Token<'_> {
6244 (
6245 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6246 &self.newImplementation,
6247 ),
6248 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
6249 &self.data,
6250 ),
6251 )
6252 }
6253 #[inline]
6254 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6255 upgradeToAndCallReturn::_tokenize(ret)
6256 }
6257 #[inline]
6258 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6259 <Self::ReturnTuple<
6260 '_,
6261 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6262 .map(Into::into)
6263 }
6264 #[inline]
6265 fn abi_decode_returns_with_config(
6266 data: &[u8],
6267 config: alloy_sol_types::abi::AbiDecoderConfig,
6268 ) -> alloy_sol_types::Result<Self::Return> {
6269 <Self::ReturnTuple<
6270 '_,
6271 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
6272 data,
6273 config,
6274 )
6275 .map(Into::into)
6276 }
6277 #[inline]
6278 fn abi_decode_returns_validate(
6279 data: &[u8],
6280 ) -> alloy_sol_types::Result<Self::Return> {
6281 Self::abi_decode_returns_with_config(
6282 data,
6283 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
6284 )
6285 }
6286 }
6287 };
6288 #[derive(Clone)]
6290 #[derive(serde::Serialize, serde::Deserialize)]
6291 #[derive(Debug, PartialEq, Eq, Hash)]
6292 pub enum EspTokenV2Calls {
6293 #[allow(missing_docs)]
6294 UPGRADE_INTERFACE_VERSION(UPGRADE_INTERFACE_VERSIONCall),
6295 #[allow(missing_docs)]
6296 allowance(allowanceCall),
6297 #[allow(missing_docs)]
6298 approve(approveCall),
6299 #[allow(missing_docs)]
6300 balanceOf(balanceOfCall),
6301 #[allow(missing_docs)]
6302 decimals(decimalsCall),
6303 #[allow(missing_docs)]
6304 getVersion(getVersionCall),
6305 #[allow(missing_docs)]
6306 initialize(initializeCall),
6307 #[allow(missing_docs)]
6308 initializeV2(initializeV2Call),
6309 #[allow(missing_docs)]
6310 mint(mintCall),
6311 #[allow(missing_docs)]
6312 name(nameCall),
6313 #[allow(missing_docs)]
6314 owner(ownerCall),
6315 #[allow(missing_docs)]
6316 proxiableUUID(proxiableUUIDCall),
6317 #[allow(missing_docs)]
6318 renounceOwnership(renounceOwnershipCall),
6319 #[allow(missing_docs)]
6320 rewardClaim(rewardClaimCall),
6321 #[allow(missing_docs)]
6322 symbol(symbolCall),
6323 #[allow(missing_docs)]
6324 totalSupply(totalSupplyCall),
6325 #[allow(missing_docs)]
6326 transfer(transferCall),
6327 #[allow(missing_docs)]
6328 transferFrom(transferFromCall),
6329 #[allow(missing_docs)]
6330 transferOwnership(transferOwnershipCall),
6331 #[allow(missing_docs)]
6332 upgradeToAndCall(upgradeToAndCallCall),
6333 }
6334 impl EspTokenV2Calls {
6335 pub const SELECTORS: &'static [[u8; 4usize]] = &[
6342 [6u8, 253u8, 222u8, 3u8],
6343 [9u8, 94u8, 167u8, 179u8],
6344 [13u8, 142u8, 110u8, 44u8],
6345 [24u8, 22u8, 13u8, 221u8],
6346 [35u8, 184u8, 114u8, 221u8],
6347 [41u8, 182u8, 236u8, 169u8],
6348 [49u8, 60u8, 229u8, 103u8],
6349 [64u8, 193u8, 15u8, 25u8],
6350 [79u8, 30u8, 242u8, 134u8],
6351 [82u8, 209u8, 144u8, 45u8],
6352 [100u8, 9u8, 249u8, 33u8],
6353 [112u8, 160u8, 130u8, 49u8],
6354 [113u8, 80u8, 24u8, 166u8],
6355 [141u8, 165u8, 203u8, 91u8],
6356 [149u8, 216u8, 155u8, 65u8],
6357 [154u8, 184u8, 54u8, 126u8],
6358 [169u8, 5u8, 156u8, 187u8],
6359 [173u8, 60u8, 177u8, 204u8],
6360 [221u8, 98u8, 237u8, 62u8],
6361 [242u8, 253u8, 227u8, 139u8],
6362 ];
6363 pub const VARIANT_NAMES: &'static [&'static str] = &[
6365 ::core::stringify!(name),
6366 ::core::stringify!(approve),
6367 ::core::stringify!(getVersion),
6368 ::core::stringify!(totalSupply),
6369 ::core::stringify!(transferFrom),
6370 ::core::stringify!(initializeV2),
6371 ::core::stringify!(decimals),
6372 ::core::stringify!(mint),
6373 ::core::stringify!(upgradeToAndCall),
6374 ::core::stringify!(proxiableUUID),
6375 ::core::stringify!(rewardClaim),
6376 ::core::stringify!(balanceOf),
6377 ::core::stringify!(renounceOwnership),
6378 ::core::stringify!(owner),
6379 ::core::stringify!(symbol),
6380 ::core::stringify!(initialize),
6381 ::core::stringify!(transfer),
6382 ::core::stringify!(UPGRADE_INTERFACE_VERSION),
6383 ::core::stringify!(allowance),
6384 ::core::stringify!(transferOwnership),
6385 ];
6386 pub const SIGNATURES: &'static [&'static str] = &[
6388 <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
6389 <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
6390 <getVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
6391 <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
6392 <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
6393 <initializeV2Call as alloy_sol_types::SolCall>::SIGNATURE,
6394 <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
6395 <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
6396 <upgradeToAndCallCall as alloy_sol_types::SolCall>::SIGNATURE,
6397 <proxiableUUIDCall as alloy_sol_types::SolCall>::SIGNATURE,
6398 <rewardClaimCall as alloy_sol_types::SolCall>::SIGNATURE,
6399 <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
6400 <renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
6401 <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
6402 <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
6403 <initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
6404 <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
6405 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SIGNATURE,
6406 <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
6407 <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
6408 ];
6409 #[inline]
6411 pub fn signature_by_selector(
6412 selector: [u8; 4usize],
6413 ) -> ::core::option::Option<&'static str> {
6414 match Self::SELECTORS.binary_search(&selector) {
6415 ::core::result::Result::Ok(idx) => {
6416 ::core::option::Option::Some(Self::SIGNATURES[idx])
6417 }
6418 ::core::result::Result::Err(_) => ::core::option::Option::None,
6419 }
6420 }
6421 #[inline]
6423 pub fn name_by_selector(
6424 selector: [u8; 4usize],
6425 ) -> ::core::option::Option<&'static str> {
6426 let sig = Self::signature_by_selector(selector)?;
6427 sig.split_once('(').map(|(name, _)| name)
6428 }
6429 }
6430 #[automatically_derived]
6431 impl alloy_sol_types::SolInterface for EspTokenV2Calls {
6432 const NAME: &'static str = "EspTokenV2Calls";
6433 const MIN_DATA_LENGTH: usize = 0usize;
6434 const COUNT: usize = 20usize;
6435 #[inline]
6436 fn selector(&self) -> [u8; 4] {
6437 match self {
6438 Self::UPGRADE_INTERFACE_VERSION(_) => {
6439 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SELECTOR
6440 }
6441 Self::allowance(_) => {
6442 <allowanceCall as alloy_sol_types::SolCall>::SELECTOR
6443 }
6444 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
6445 Self::balanceOf(_) => {
6446 <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR
6447 }
6448 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
6449 Self::getVersion(_) => {
6450 <getVersionCall as alloy_sol_types::SolCall>::SELECTOR
6451 }
6452 Self::initialize(_) => {
6453 <initializeCall as alloy_sol_types::SolCall>::SELECTOR
6454 }
6455 Self::initializeV2(_) => {
6456 <initializeV2Call as alloy_sol_types::SolCall>::SELECTOR
6457 }
6458 Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
6459 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
6460 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
6461 Self::proxiableUUID(_) => {
6462 <proxiableUUIDCall as alloy_sol_types::SolCall>::SELECTOR
6463 }
6464 Self::renounceOwnership(_) => {
6465 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
6466 }
6467 Self::rewardClaim(_) => {
6468 <rewardClaimCall as alloy_sol_types::SolCall>::SELECTOR
6469 }
6470 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
6471 Self::totalSupply(_) => {
6472 <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR
6473 }
6474 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
6475 Self::transferFrom(_) => {
6476 <transferFromCall as alloy_sol_types::SolCall>::SELECTOR
6477 }
6478 Self::transferOwnership(_) => {
6479 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
6480 }
6481 Self::upgradeToAndCall(_) => {
6482 <upgradeToAndCallCall as alloy_sol_types::SolCall>::SELECTOR
6483 }
6484 }
6485 }
6486 #[inline]
6487 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
6488 Self::SELECTORS.get(i).copied()
6489 }
6490 #[inline]
6491 fn valid_selector(selector: [u8; 4]) -> bool {
6492 Self::SELECTORS.binary_search(&selector).is_ok()
6493 }
6494 #[inline]
6495 #[allow(non_snake_case)]
6496 fn abi_decode_raw(
6497 selector: [u8; 4],
6498 data: &[u8],
6499 ) -> alloy_sol_types::Result<Self> {
6500 Self::abi_decode_raw_with_config(
6501 selector,
6502 data,
6503 alloy_sol_types::abi::AbiDecoderConfig::default(),
6504 )
6505 }
6506 #[inline]
6507 #[allow(non_snake_case)]
6508 fn abi_decode_raw_with_config(
6509 selector: [u8; 4],
6510 data: &[u8],
6511 config: alloy_sol_types::abi::AbiDecoderConfig,
6512 ) -> alloy_sol_types::Result<Self> {
6513 static DECODE_SHIMS: &[fn(
6514 &[u8],
6515 alloy_sol_types::abi::AbiDecoderConfig,
6516 ) -> alloy_sol_types::Result<EspTokenV2Calls>] = &[
6517 {
6518 fn name(
6519 data: &[u8],
6520 config: alloy_sol_types::abi::AbiDecoderConfig,
6521 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6522 <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6523 data,
6524 config,
6525 )
6526 .map(EspTokenV2Calls::name)
6527 }
6528 name
6529 },
6530 {
6531 fn approve(
6532 data: &[u8],
6533 config: alloy_sol_types::abi::AbiDecoderConfig,
6534 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6535 <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6536 data,
6537 config,
6538 )
6539 .map(EspTokenV2Calls::approve)
6540 }
6541 approve
6542 },
6543 {
6544 fn getVersion(
6545 data: &[u8],
6546 config: alloy_sol_types::abi::AbiDecoderConfig,
6547 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6548 <getVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6549 data,
6550 config,
6551 )
6552 .map(EspTokenV2Calls::getVersion)
6553 }
6554 getVersion
6555 },
6556 {
6557 fn totalSupply(
6558 data: &[u8],
6559 config: alloy_sol_types::abi::AbiDecoderConfig,
6560 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6561 <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6562 data,
6563 config,
6564 )
6565 .map(EspTokenV2Calls::totalSupply)
6566 }
6567 totalSupply
6568 },
6569 {
6570 fn transferFrom(
6571 data: &[u8],
6572 config: alloy_sol_types::abi::AbiDecoderConfig,
6573 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6574 <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6575 data,
6576 config,
6577 )
6578 .map(EspTokenV2Calls::transferFrom)
6579 }
6580 transferFrom
6581 },
6582 {
6583 fn initializeV2(
6584 data: &[u8],
6585 config: alloy_sol_types::abi::AbiDecoderConfig,
6586 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6587 <initializeV2Call as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6588 data,
6589 config,
6590 )
6591 .map(EspTokenV2Calls::initializeV2)
6592 }
6593 initializeV2
6594 },
6595 {
6596 fn decimals(
6597 data: &[u8],
6598 config: alloy_sol_types::abi::AbiDecoderConfig,
6599 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6600 <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6601 data,
6602 config,
6603 )
6604 .map(EspTokenV2Calls::decimals)
6605 }
6606 decimals
6607 },
6608 {
6609 fn mint(
6610 data: &[u8],
6611 config: alloy_sol_types::abi::AbiDecoderConfig,
6612 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6613 <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6614 data,
6615 config,
6616 )
6617 .map(EspTokenV2Calls::mint)
6618 }
6619 mint
6620 },
6621 {
6622 fn upgradeToAndCall(
6623 data: &[u8],
6624 config: alloy_sol_types::abi::AbiDecoderConfig,
6625 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6626 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6627 data,
6628 config,
6629 )
6630 .map(EspTokenV2Calls::upgradeToAndCall)
6631 }
6632 upgradeToAndCall
6633 },
6634 {
6635 fn proxiableUUID(
6636 data: &[u8],
6637 config: alloy_sol_types::abi::AbiDecoderConfig,
6638 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6639 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6640 data,
6641 config,
6642 )
6643 .map(EspTokenV2Calls::proxiableUUID)
6644 }
6645 proxiableUUID
6646 },
6647 {
6648 fn rewardClaim(
6649 data: &[u8],
6650 config: alloy_sol_types::abi::AbiDecoderConfig,
6651 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6652 <rewardClaimCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6653 data,
6654 config,
6655 )
6656 .map(EspTokenV2Calls::rewardClaim)
6657 }
6658 rewardClaim
6659 },
6660 {
6661 fn balanceOf(
6662 data: &[u8],
6663 config: alloy_sol_types::abi::AbiDecoderConfig,
6664 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6665 <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6666 data,
6667 config,
6668 )
6669 .map(EspTokenV2Calls::balanceOf)
6670 }
6671 balanceOf
6672 },
6673 {
6674 fn renounceOwnership(
6675 data: &[u8],
6676 config: alloy_sol_types::abi::AbiDecoderConfig,
6677 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6678 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6679 data,
6680 config,
6681 )
6682 .map(EspTokenV2Calls::renounceOwnership)
6683 }
6684 renounceOwnership
6685 },
6686 {
6687 fn owner(
6688 data: &[u8],
6689 config: alloy_sol_types::abi::AbiDecoderConfig,
6690 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6691 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6692 data,
6693 config,
6694 )
6695 .map(EspTokenV2Calls::owner)
6696 }
6697 owner
6698 },
6699 {
6700 fn symbol(
6701 data: &[u8],
6702 config: alloy_sol_types::abi::AbiDecoderConfig,
6703 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6704 <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6705 data,
6706 config,
6707 )
6708 .map(EspTokenV2Calls::symbol)
6709 }
6710 symbol
6711 },
6712 {
6713 fn initialize(
6714 data: &[u8],
6715 config: alloy_sol_types::abi::AbiDecoderConfig,
6716 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6717 <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6718 data,
6719 config,
6720 )
6721 .map(EspTokenV2Calls::initialize)
6722 }
6723 initialize
6724 },
6725 {
6726 fn transfer(
6727 data: &[u8],
6728 config: alloy_sol_types::abi::AbiDecoderConfig,
6729 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6730 <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6731 data,
6732 config,
6733 )
6734 .map(EspTokenV2Calls::transfer)
6735 }
6736 transfer
6737 },
6738 {
6739 fn UPGRADE_INTERFACE_VERSION(
6740 data: &[u8],
6741 config: alloy_sol_types::abi::AbiDecoderConfig,
6742 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6743 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6744 data,
6745 config,
6746 )
6747 .map(EspTokenV2Calls::UPGRADE_INTERFACE_VERSION)
6748 }
6749 UPGRADE_INTERFACE_VERSION
6750 },
6751 {
6752 fn allowance(
6753 data: &[u8],
6754 config: alloy_sol_types::abi::AbiDecoderConfig,
6755 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6756 <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6757 data,
6758 config,
6759 )
6760 .map(EspTokenV2Calls::allowance)
6761 }
6762 allowance
6763 },
6764 {
6765 fn transferOwnership(
6766 data: &[u8],
6767 config: alloy_sol_types::abi::AbiDecoderConfig,
6768 ) -> alloy_sol_types::Result<EspTokenV2Calls> {
6769 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
6770 data,
6771 config,
6772 )
6773 .map(EspTokenV2Calls::transferOwnership)
6774 }
6775 transferOwnership
6776 },
6777 ];
6778 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
6779 return Err(
6780 alloy_sol_types::Error::unknown_selector(
6781 <Self as alloy_sol_types::SolInterface>::NAME,
6782 selector,
6783 ),
6784 );
6785 };
6786 DECODE_SHIMS[idx](data, config)
6787 }
6788 #[inline]
6789 #[allow(non_snake_case)]
6790 fn abi_decode_raw_validate(
6791 selector: [u8; 4],
6792 data: &[u8],
6793 ) -> alloy_sol_types::Result<Self> {
6794 Self::abi_decode_raw_with_config(
6795 selector,
6796 data,
6797 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
6798 )
6799 }
6800 #[inline]
6801 fn abi_encoded_size(&self) -> usize {
6802 match self {
6803 Self::UPGRADE_INTERFACE_VERSION(inner) => {
6804 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
6805 inner,
6806 )
6807 }
6808 Self::allowance(inner) => {
6809 <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6810 }
6811 Self::approve(inner) => {
6812 <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6813 }
6814 Self::balanceOf(inner) => {
6815 <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6816 }
6817 Self::decimals(inner) => {
6818 <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6819 }
6820 Self::getVersion(inner) => {
6821 <getVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6822 }
6823 Self::initialize(inner) => {
6824 <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6825 }
6826 Self::initializeV2(inner) => {
6827 <initializeV2Call as alloy_sol_types::SolCall>::abi_encoded_size(
6828 inner,
6829 )
6830 }
6831 Self::mint(inner) => {
6832 <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6833 }
6834 Self::name(inner) => {
6835 <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6836 }
6837 Self::owner(inner) => {
6838 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6839 }
6840 Self::proxiableUUID(inner) => {
6841 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encoded_size(
6842 inner,
6843 )
6844 }
6845 Self::renounceOwnership(inner) => {
6846 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
6847 inner,
6848 )
6849 }
6850 Self::rewardClaim(inner) => {
6851 <rewardClaimCall as alloy_sol_types::SolCall>::abi_encoded_size(
6852 inner,
6853 )
6854 }
6855 Self::symbol(inner) => {
6856 <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6857 }
6858 Self::totalSupply(inner) => {
6859 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(
6860 inner,
6861 )
6862 }
6863 Self::transfer(inner) => {
6864 <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6865 }
6866 Self::transferFrom(inner) => {
6867 <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
6868 inner,
6869 )
6870 }
6871 Self::transferOwnership(inner) => {
6872 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
6873 inner,
6874 )
6875 }
6876 Self::upgradeToAndCall(inner) => {
6877 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(
6878 inner,
6879 )
6880 }
6881 }
6882 }
6883 #[inline]
6884 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
6885 match self {
6886 Self::UPGRADE_INTERFACE_VERSION(inner) => {
6887 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
6888 inner,
6889 out,
6890 )
6891 }
6892 Self::allowance(inner) => {
6893 <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
6894 inner,
6895 out,
6896 )
6897 }
6898 Self::approve(inner) => {
6899 <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6900 }
6901 Self::balanceOf(inner) => {
6902 <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(
6903 inner,
6904 out,
6905 )
6906 }
6907 Self::decimals(inner) => {
6908 <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(
6909 inner,
6910 out,
6911 )
6912 }
6913 Self::getVersion(inner) => {
6914 <getVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
6915 inner,
6916 out,
6917 )
6918 }
6919 Self::initialize(inner) => {
6920 <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
6921 inner,
6922 out,
6923 )
6924 }
6925 Self::initializeV2(inner) => {
6926 <initializeV2Call as alloy_sol_types::SolCall>::abi_encode_raw(
6927 inner,
6928 out,
6929 )
6930 }
6931 Self::mint(inner) => {
6932 <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6933 }
6934 Self::name(inner) => {
6935 <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6936 }
6937 Self::owner(inner) => {
6938 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6939 }
6940 Self::proxiableUUID(inner) => {
6941 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encode_raw(
6942 inner,
6943 out,
6944 )
6945 }
6946 Self::renounceOwnership(inner) => {
6947 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
6948 inner,
6949 out,
6950 )
6951 }
6952 Self::rewardClaim(inner) => {
6953 <rewardClaimCall as alloy_sol_types::SolCall>::abi_encode_raw(
6954 inner,
6955 out,
6956 )
6957 }
6958 Self::symbol(inner) => {
6959 <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6960 }
6961 Self::totalSupply(inner) => {
6962 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(
6963 inner,
6964 out,
6965 )
6966 }
6967 Self::transfer(inner) => {
6968 <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(
6969 inner,
6970 out,
6971 )
6972 }
6973 Self::transferFrom(inner) => {
6974 <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
6975 inner,
6976 out,
6977 )
6978 }
6979 Self::transferOwnership(inner) => {
6980 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
6981 inner,
6982 out,
6983 )
6984 }
6985 Self::upgradeToAndCall(inner) => {
6986 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(
6987 inner,
6988 out,
6989 )
6990 }
6991 }
6992 }
6993 }
6994 #[derive(Clone)]
6996 #[derive(serde::Serialize, serde::Deserialize)]
6997 #[derive(Debug, PartialEq, Eq, Hash)]
6998 pub enum EspTokenV2Errors {
6999 #[allow(missing_docs)]
7000 AddressEmptyCode(AddressEmptyCode),
7001 #[allow(missing_docs)]
7002 ERC1967InvalidImplementation(ERC1967InvalidImplementation),
7003 #[allow(missing_docs)]
7004 ERC1967NonPayable(ERC1967NonPayable),
7005 #[allow(missing_docs)]
7006 ERC20InsufficientAllowance(ERC20InsufficientAllowance),
7007 #[allow(missing_docs)]
7008 ERC20InsufficientBalance(ERC20InsufficientBalance),
7009 #[allow(missing_docs)]
7010 ERC20InvalidApprover(ERC20InvalidApprover),
7011 #[allow(missing_docs)]
7012 ERC20InvalidReceiver(ERC20InvalidReceiver),
7013 #[allow(missing_docs)]
7014 ERC20InvalidSender(ERC20InvalidSender),
7015 #[allow(missing_docs)]
7016 ERC20InvalidSpender(ERC20InvalidSpender),
7017 #[allow(missing_docs)]
7018 FailedInnerCall(FailedInnerCall),
7019 #[allow(missing_docs)]
7020 InvalidInitialization(InvalidInitialization),
7021 #[allow(missing_docs)]
7022 NotInitializing(NotInitializing),
7023 #[allow(missing_docs)]
7024 OnlyRewardClaim(OnlyRewardClaim),
7025 #[allow(missing_docs)]
7026 OwnableInvalidOwner(OwnableInvalidOwner),
7027 #[allow(missing_docs)]
7028 OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
7029 #[allow(missing_docs)]
7030 OwnershipCannotBeRenounced(OwnershipCannotBeRenounced),
7031 #[allow(missing_docs)]
7032 UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext),
7033 #[allow(missing_docs)]
7034 UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID),
7035 #[allow(missing_docs)]
7036 ZeroRewardClaimAddress(ZeroRewardClaimAddress),
7037 }
7038 impl EspTokenV2Errors {
7039 pub const SELECTORS: &'static [[u8; 4usize]] = &[
7046 [6u8, 212u8, 204u8, 67u8],
7047 [17u8, 140u8, 218u8, 167u8],
7048 [20u8, 37u8, 234u8, 66u8],
7049 [30u8, 79u8, 189u8, 247u8],
7050 [47u8, 171u8, 146u8, 202u8],
7051 [76u8, 156u8, 140u8, 227u8],
7052 [148u8, 40u8, 13u8, 98u8],
7053 [150u8, 198u8, 253u8, 30u8],
7054 [153u8, 150u8, 179u8, 21u8],
7055 [170u8, 29u8, 73u8, 164u8],
7056 [179u8, 152u8, 151u8, 159u8],
7057 [189u8, 189u8, 238u8, 235u8],
7058 [215u8, 230u8, 188u8, 248u8],
7059 [224u8, 124u8, 141u8, 186u8],
7060 [228u8, 80u8, 211u8, 140u8],
7061 [230u8, 2u8, 223u8, 5u8],
7062 [236u8, 68u8, 47u8, 5u8],
7063 [249u8, 46u8, 232u8, 169u8],
7064 [251u8, 143u8, 65u8, 178u8],
7065 ];
7066 pub const VARIANT_NAMES: &'static [&'static str] = &[
7068 ::core::stringify!(OnlyRewardClaim),
7069 ::core::stringify!(OwnableUnauthorizedAccount),
7070 ::core::stringify!(FailedInnerCall),
7071 ::core::stringify!(OwnableInvalidOwner),
7072 ::core::stringify!(OwnershipCannotBeRenounced),
7073 ::core::stringify!(ERC1967InvalidImplementation),
7074 ::core::stringify!(ERC20InvalidSpender),
7075 ::core::stringify!(ERC20InvalidSender),
7076 ::core::stringify!(AddressEmptyCode),
7077 ::core::stringify!(UUPSUnsupportedProxiableUUID),
7078 ::core::stringify!(ERC1967NonPayable),
7079 ::core::stringify!(ZeroRewardClaimAddress),
7080 ::core::stringify!(NotInitializing),
7081 ::core::stringify!(UUPSUnauthorizedCallContext),
7082 ::core::stringify!(ERC20InsufficientBalance),
7083 ::core::stringify!(ERC20InvalidApprover),
7084 ::core::stringify!(ERC20InvalidReceiver),
7085 ::core::stringify!(InvalidInitialization),
7086 ::core::stringify!(ERC20InsufficientAllowance),
7087 ];
7088 pub const SIGNATURES: &'static [&'static str] = &[
7090 <OnlyRewardClaim as alloy_sol_types::SolError>::SIGNATURE,
7091 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SIGNATURE,
7092 <FailedInnerCall as alloy_sol_types::SolError>::SIGNATURE,
7093 <OwnableInvalidOwner as alloy_sol_types::SolError>::SIGNATURE,
7094 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::SIGNATURE,
7095 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SIGNATURE,
7096 <ERC20InvalidSpender as alloy_sol_types::SolError>::SIGNATURE,
7097 <ERC20InvalidSender as alloy_sol_types::SolError>::SIGNATURE,
7098 <AddressEmptyCode as alloy_sol_types::SolError>::SIGNATURE,
7099 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SIGNATURE,
7100 <ERC1967NonPayable as alloy_sol_types::SolError>::SIGNATURE,
7101 <ZeroRewardClaimAddress as alloy_sol_types::SolError>::SIGNATURE,
7102 <NotInitializing as alloy_sol_types::SolError>::SIGNATURE,
7103 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SIGNATURE,
7104 <ERC20InsufficientBalance as alloy_sol_types::SolError>::SIGNATURE,
7105 <ERC20InvalidApprover as alloy_sol_types::SolError>::SIGNATURE,
7106 <ERC20InvalidReceiver as alloy_sol_types::SolError>::SIGNATURE,
7107 <InvalidInitialization as alloy_sol_types::SolError>::SIGNATURE,
7108 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::SIGNATURE,
7109 ];
7110 #[inline]
7112 pub fn signature_by_selector(
7113 selector: [u8; 4usize],
7114 ) -> ::core::option::Option<&'static str> {
7115 match Self::SELECTORS.binary_search(&selector) {
7116 ::core::result::Result::Ok(idx) => {
7117 ::core::option::Option::Some(Self::SIGNATURES[idx])
7118 }
7119 ::core::result::Result::Err(_) => ::core::option::Option::None,
7120 }
7121 }
7122 #[inline]
7124 pub fn name_by_selector(
7125 selector: [u8; 4usize],
7126 ) -> ::core::option::Option<&'static str> {
7127 let sig = Self::signature_by_selector(selector)?;
7128 sig.split_once('(').map(|(name, _)| name)
7129 }
7130 }
7131 #[automatically_derived]
7132 impl alloy_sol_types::SolInterface for EspTokenV2Errors {
7133 const NAME: &'static str = "EspTokenV2Errors";
7134 const MIN_DATA_LENGTH: usize = 0usize;
7135 const COUNT: usize = 19usize;
7136 #[inline]
7137 fn selector(&self) -> [u8; 4] {
7138 match self {
7139 Self::AddressEmptyCode(_) => {
7140 <AddressEmptyCode as alloy_sol_types::SolError>::SELECTOR
7141 }
7142 Self::ERC1967InvalidImplementation(_) => {
7143 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SELECTOR
7144 }
7145 Self::ERC1967NonPayable(_) => {
7146 <ERC1967NonPayable as alloy_sol_types::SolError>::SELECTOR
7147 }
7148 Self::ERC20InsufficientAllowance(_) => {
7149 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::SELECTOR
7150 }
7151 Self::ERC20InsufficientBalance(_) => {
7152 <ERC20InsufficientBalance as alloy_sol_types::SolError>::SELECTOR
7153 }
7154 Self::ERC20InvalidApprover(_) => {
7155 <ERC20InvalidApprover as alloy_sol_types::SolError>::SELECTOR
7156 }
7157 Self::ERC20InvalidReceiver(_) => {
7158 <ERC20InvalidReceiver as alloy_sol_types::SolError>::SELECTOR
7159 }
7160 Self::ERC20InvalidSender(_) => {
7161 <ERC20InvalidSender as alloy_sol_types::SolError>::SELECTOR
7162 }
7163 Self::ERC20InvalidSpender(_) => {
7164 <ERC20InvalidSpender as alloy_sol_types::SolError>::SELECTOR
7165 }
7166 Self::FailedInnerCall(_) => {
7167 <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
7168 }
7169 Self::InvalidInitialization(_) => {
7170 <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
7171 }
7172 Self::NotInitializing(_) => {
7173 <NotInitializing as alloy_sol_types::SolError>::SELECTOR
7174 }
7175 Self::OnlyRewardClaim(_) => {
7176 <OnlyRewardClaim as alloy_sol_types::SolError>::SELECTOR
7177 }
7178 Self::OwnableInvalidOwner(_) => {
7179 <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
7180 }
7181 Self::OwnableUnauthorizedAccount(_) => {
7182 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
7183 }
7184 Self::OwnershipCannotBeRenounced(_) => {
7185 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::SELECTOR
7186 }
7187 Self::UUPSUnauthorizedCallContext(_) => {
7188 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SELECTOR
7189 }
7190 Self::UUPSUnsupportedProxiableUUID(_) => {
7191 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SELECTOR
7192 }
7193 Self::ZeroRewardClaimAddress(_) => {
7194 <ZeroRewardClaimAddress as alloy_sol_types::SolError>::SELECTOR
7195 }
7196 }
7197 }
7198 #[inline]
7199 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
7200 Self::SELECTORS.get(i).copied()
7201 }
7202 #[inline]
7203 fn valid_selector(selector: [u8; 4]) -> bool {
7204 Self::SELECTORS.binary_search(&selector).is_ok()
7205 }
7206 #[inline]
7207 #[allow(non_snake_case)]
7208 fn abi_decode_raw(
7209 selector: [u8; 4],
7210 data: &[u8],
7211 ) -> alloy_sol_types::Result<Self> {
7212 Self::abi_decode_raw_with_config(
7213 selector,
7214 data,
7215 alloy_sol_types::abi::AbiDecoderConfig::default(),
7216 )
7217 }
7218 #[inline]
7219 #[allow(non_snake_case)]
7220 fn abi_decode_raw_with_config(
7221 selector: [u8; 4],
7222 data: &[u8],
7223 config: alloy_sol_types::abi::AbiDecoderConfig,
7224 ) -> alloy_sol_types::Result<Self> {
7225 static DECODE_SHIMS: &[fn(
7226 &[u8],
7227 alloy_sol_types::abi::AbiDecoderConfig,
7228 ) -> alloy_sol_types::Result<EspTokenV2Errors>] = &[
7229 {
7230 fn OnlyRewardClaim(
7231 data: &[u8],
7232 config: alloy_sol_types::abi::AbiDecoderConfig,
7233 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7234 <OnlyRewardClaim as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7235 data,
7236 config,
7237 )
7238 .map(EspTokenV2Errors::OnlyRewardClaim)
7239 }
7240 OnlyRewardClaim
7241 },
7242 {
7243 fn OwnableUnauthorizedAccount(
7244 data: &[u8],
7245 config: alloy_sol_types::abi::AbiDecoderConfig,
7246 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7247 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7248 data,
7249 config,
7250 )
7251 .map(EspTokenV2Errors::OwnableUnauthorizedAccount)
7252 }
7253 OwnableUnauthorizedAccount
7254 },
7255 {
7256 fn FailedInnerCall(
7257 data: &[u8],
7258 config: alloy_sol_types::abi::AbiDecoderConfig,
7259 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7260 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7261 data,
7262 config,
7263 )
7264 .map(EspTokenV2Errors::FailedInnerCall)
7265 }
7266 FailedInnerCall
7267 },
7268 {
7269 fn OwnableInvalidOwner(
7270 data: &[u8],
7271 config: alloy_sol_types::abi::AbiDecoderConfig,
7272 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7273 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7274 data,
7275 config,
7276 )
7277 .map(EspTokenV2Errors::OwnableInvalidOwner)
7278 }
7279 OwnableInvalidOwner
7280 },
7281 {
7282 fn OwnershipCannotBeRenounced(
7283 data: &[u8],
7284 config: alloy_sol_types::abi::AbiDecoderConfig,
7285 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7286 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7287 data,
7288 config,
7289 )
7290 .map(EspTokenV2Errors::OwnershipCannotBeRenounced)
7291 }
7292 OwnershipCannotBeRenounced
7293 },
7294 {
7295 fn ERC1967InvalidImplementation(
7296 data: &[u8],
7297 config: alloy_sol_types::abi::AbiDecoderConfig,
7298 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7299 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7300 data,
7301 config,
7302 )
7303 .map(EspTokenV2Errors::ERC1967InvalidImplementation)
7304 }
7305 ERC1967InvalidImplementation
7306 },
7307 {
7308 fn ERC20InvalidSpender(
7309 data: &[u8],
7310 config: alloy_sol_types::abi::AbiDecoderConfig,
7311 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7312 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7313 data,
7314 config,
7315 )
7316 .map(EspTokenV2Errors::ERC20InvalidSpender)
7317 }
7318 ERC20InvalidSpender
7319 },
7320 {
7321 fn ERC20InvalidSender(
7322 data: &[u8],
7323 config: alloy_sol_types::abi::AbiDecoderConfig,
7324 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7325 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7326 data,
7327 config,
7328 )
7329 .map(EspTokenV2Errors::ERC20InvalidSender)
7330 }
7331 ERC20InvalidSender
7332 },
7333 {
7334 fn AddressEmptyCode(
7335 data: &[u8],
7336 config: alloy_sol_types::abi::AbiDecoderConfig,
7337 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7338 <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7339 data,
7340 config,
7341 )
7342 .map(EspTokenV2Errors::AddressEmptyCode)
7343 }
7344 AddressEmptyCode
7345 },
7346 {
7347 fn UUPSUnsupportedProxiableUUID(
7348 data: &[u8],
7349 config: alloy_sol_types::abi::AbiDecoderConfig,
7350 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7351 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7352 data,
7353 config,
7354 )
7355 .map(EspTokenV2Errors::UUPSUnsupportedProxiableUUID)
7356 }
7357 UUPSUnsupportedProxiableUUID
7358 },
7359 {
7360 fn ERC1967NonPayable(
7361 data: &[u8],
7362 config: alloy_sol_types::abi::AbiDecoderConfig,
7363 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7364 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7365 data,
7366 config,
7367 )
7368 .map(EspTokenV2Errors::ERC1967NonPayable)
7369 }
7370 ERC1967NonPayable
7371 },
7372 {
7373 fn ZeroRewardClaimAddress(
7374 data: &[u8],
7375 config: alloy_sol_types::abi::AbiDecoderConfig,
7376 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7377 <ZeroRewardClaimAddress as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7378 data,
7379 config,
7380 )
7381 .map(EspTokenV2Errors::ZeroRewardClaimAddress)
7382 }
7383 ZeroRewardClaimAddress
7384 },
7385 {
7386 fn NotInitializing(
7387 data: &[u8],
7388 config: alloy_sol_types::abi::AbiDecoderConfig,
7389 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7390 <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7391 data,
7392 config,
7393 )
7394 .map(EspTokenV2Errors::NotInitializing)
7395 }
7396 NotInitializing
7397 },
7398 {
7399 fn UUPSUnauthorizedCallContext(
7400 data: &[u8],
7401 config: alloy_sol_types::abi::AbiDecoderConfig,
7402 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7403 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7404 data,
7405 config,
7406 )
7407 .map(EspTokenV2Errors::UUPSUnauthorizedCallContext)
7408 }
7409 UUPSUnauthorizedCallContext
7410 },
7411 {
7412 fn ERC20InsufficientBalance(
7413 data: &[u8],
7414 config: alloy_sol_types::abi::AbiDecoderConfig,
7415 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7416 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7417 data,
7418 config,
7419 )
7420 .map(EspTokenV2Errors::ERC20InsufficientBalance)
7421 }
7422 ERC20InsufficientBalance
7423 },
7424 {
7425 fn ERC20InvalidApprover(
7426 data: &[u8],
7427 config: alloy_sol_types::abi::AbiDecoderConfig,
7428 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7429 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7430 data,
7431 config,
7432 )
7433 .map(EspTokenV2Errors::ERC20InvalidApprover)
7434 }
7435 ERC20InvalidApprover
7436 },
7437 {
7438 fn ERC20InvalidReceiver(
7439 data: &[u8],
7440 config: alloy_sol_types::abi::AbiDecoderConfig,
7441 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7442 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7443 data,
7444 config,
7445 )
7446 .map(EspTokenV2Errors::ERC20InvalidReceiver)
7447 }
7448 ERC20InvalidReceiver
7449 },
7450 {
7451 fn InvalidInitialization(
7452 data: &[u8],
7453 config: alloy_sol_types::abi::AbiDecoderConfig,
7454 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7455 <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7456 data,
7457 config,
7458 )
7459 .map(EspTokenV2Errors::InvalidInitialization)
7460 }
7461 InvalidInitialization
7462 },
7463 {
7464 fn ERC20InsufficientAllowance(
7465 data: &[u8],
7466 config: alloy_sol_types::abi::AbiDecoderConfig,
7467 ) -> alloy_sol_types::Result<EspTokenV2Errors> {
7468 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_decode_raw_with_config(
7469 data,
7470 config,
7471 )
7472 .map(EspTokenV2Errors::ERC20InsufficientAllowance)
7473 }
7474 ERC20InsufficientAllowance
7475 },
7476 ];
7477 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
7478 return Err(
7479 alloy_sol_types::Error::unknown_selector(
7480 <Self as alloy_sol_types::SolInterface>::NAME,
7481 selector,
7482 ),
7483 );
7484 };
7485 DECODE_SHIMS[idx](data, config)
7486 }
7487 #[inline]
7488 #[allow(non_snake_case)]
7489 fn abi_decode_raw_validate(
7490 selector: [u8; 4],
7491 data: &[u8],
7492 ) -> alloy_sol_types::Result<Self> {
7493 Self::abi_decode_raw_with_config(
7494 selector,
7495 data,
7496 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
7497 )
7498 }
7499 #[inline]
7500 fn abi_encoded_size(&self) -> usize {
7501 match self {
7502 Self::AddressEmptyCode(inner) => {
7503 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encoded_size(
7504 inner,
7505 )
7506 }
7507 Self::ERC1967InvalidImplementation(inner) => {
7508 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encoded_size(
7509 inner,
7510 )
7511 }
7512 Self::ERC1967NonPayable(inner) => {
7513 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encoded_size(
7514 inner,
7515 )
7516 }
7517 Self::ERC20InsufficientAllowance(inner) => {
7518 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_encoded_size(
7519 inner,
7520 )
7521 }
7522 Self::ERC20InsufficientBalance(inner) => {
7523 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_encoded_size(
7524 inner,
7525 )
7526 }
7527 Self::ERC20InvalidApprover(inner) => {
7528 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_encoded_size(
7529 inner,
7530 )
7531 }
7532 Self::ERC20InvalidReceiver(inner) => {
7533 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_encoded_size(
7534 inner,
7535 )
7536 }
7537 Self::ERC20InvalidSender(inner) => {
7538 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_encoded_size(
7539 inner,
7540 )
7541 }
7542 Self::ERC20InvalidSpender(inner) => {
7543 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_encoded_size(
7544 inner,
7545 )
7546 }
7547 Self::FailedInnerCall(inner) => {
7548 <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(
7549 inner,
7550 )
7551 }
7552 Self::InvalidInitialization(inner) => {
7553 <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(
7554 inner,
7555 )
7556 }
7557 Self::NotInitializing(inner) => {
7558 <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(
7559 inner,
7560 )
7561 }
7562 Self::OnlyRewardClaim(inner) => {
7563 <OnlyRewardClaim as alloy_sol_types::SolError>::abi_encoded_size(
7564 inner,
7565 )
7566 }
7567 Self::OwnableInvalidOwner(inner) => {
7568 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
7569 inner,
7570 )
7571 }
7572 Self::OwnableUnauthorizedAccount(inner) => {
7573 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
7574 inner,
7575 )
7576 }
7577 Self::OwnershipCannotBeRenounced(inner) => {
7578 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_encoded_size(
7579 inner,
7580 )
7581 }
7582 Self::UUPSUnauthorizedCallContext(inner) => {
7583 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encoded_size(
7584 inner,
7585 )
7586 }
7587 Self::UUPSUnsupportedProxiableUUID(inner) => {
7588 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encoded_size(
7589 inner,
7590 )
7591 }
7592 Self::ZeroRewardClaimAddress(inner) => {
7593 <ZeroRewardClaimAddress as alloy_sol_types::SolError>::abi_encoded_size(
7594 inner,
7595 )
7596 }
7597 }
7598 }
7599 #[inline]
7600 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
7601 match self {
7602 Self::AddressEmptyCode(inner) => {
7603 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encode_raw(
7604 inner,
7605 out,
7606 )
7607 }
7608 Self::ERC1967InvalidImplementation(inner) => {
7609 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encode_raw(
7610 inner,
7611 out,
7612 )
7613 }
7614 Self::ERC1967NonPayable(inner) => {
7615 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encode_raw(
7616 inner,
7617 out,
7618 )
7619 }
7620 Self::ERC20InsufficientAllowance(inner) => {
7621 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_encode_raw(
7622 inner,
7623 out,
7624 )
7625 }
7626 Self::ERC20InsufficientBalance(inner) => {
7627 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_encode_raw(
7628 inner,
7629 out,
7630 )
7631 }
7632 Self::ERC20InvalidApprover(inner) => {
7633 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_encode_raw(
7634 inner,
7635 out,
7636 )
7637 }
7638 Self::ERC20InvalidReceiver(inner) => {
7639 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_encode_raw(
7640 inner,
7641 out,
7642 )
7643 }
7644 Self::ERC20InvalidSender(inner) => {
7645 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_encode_raw(
7646 inner,
7647 out,
7648 )
7649 }
7650 Self::ERC20InvalidSpender(inner) => {
7651 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_encode_raw(
7652 inner,
7653 out,
7654 )
7655 }
7656 Self::FailedInnerCall(inner) => {
7657 <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(
7658 inner,
7659 out,
7660 )
7661 }
7662 Self::InvalidInitialization(inner) => {
7663 <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(
7664 inner,
7665 out,
7666 )
7667 }
7668 Self::NotInitializing(inner) => {
7669 <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(
7670 inner,
7671 out,
7672 )
7673 }
7674 Self::OnlyRewardClaim(inner) => {
7675 <OnlyRewardClaim as alloy_sol_types::SolError>::abi_encode_raw(
7676 inner,
7677 out,
7678 )
7679 }
7680 Self::OwnableInvalidOwner(inner) => {
7681 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
7682 inner,
7683 out,
7684 )
7685 }
7686 Self::OwnableUnauthorizedAccount(inner) => {
7687 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
7688 inner,
7689 out,
7690 )
7691 }
7692 Self::OwnershipCannotBeRenounced(inner) => {
7693 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_encode_raw(
7694 inner,
7695 out,
7696 )
7697 }
7698 Self::UUPSUnauthorizedCallContext(inner) => {
7699 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encode_raw(
7700 inner,
7701 out,
7702 )
7703 }
7704 Self::UUPSUnsupportedProxiableUUID(inner) => {
7705 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encode_raw(
7706 inner,
7707 out,
7708 )
7709 }
7710 Self::ZeroRewardClaimAddress(inner) => {
7711 <ZeroRewardClaimAddress as alloy_sol_types::SolError>::abi_encode_raw(
7712 inner,
7713 out,
7714 )
7715 }
7716 }
7717 }
7718 }
7719 #[automatically_derived]
7720 impl EspTokenV2Errors {
7721 #[inline]
7727 pub fn address_empty_code(target: alloy::sol_types::private::Address) -> Self {
7728 Self::AddressEmptyCode(AddressEmptyCode { target: target })
7729 }
7730 #[inline]
7736 pub fn erc_1967_invalid_implementation(
7737 implementation: alloy::sol_types::private::Address,
7738 ) -> Self {
7739 Self::ERC1967InvalidImplementation(ERC1967InvalidImplementation {
7740 implementation: implementation,
7741 })
7742 }
7743 #[inline]
7749 pub fn erc_1967_non_payable() -> Self {
7750 Self::ERC1967NonPayable(ERC1967NonPayable)
7751 }
7752 #[inline]
7758 pub fn erc_20_insufficient_allowance(
7759 spender: alloy::sol_types::private::Address,
7760 allowance: alloy::sol_types::private::primitives::aliases::U256,
7761 needed: alloy::sol_types::private::primitives::aliases::U256,
7762 ) -> Self {
7763 Self::ERC20InsufficientAllowance(ERC20InsufficientAllowance {
7764 spender: spender,
7765 allowance: allowance,
7766 needed: needed,
7767 })
7768 }
7769 #[inline]
7775 pub fn erc_20_insufficient_balance(
7776 sender: alloy::sol_types::private::Address,
7777 balance: alloy::sol_types::private::primitives::aliases::U256,
7778 needed: alloy::sol_types::private::primitives::aliases::U256,
7779 ) -> Self {
7780 Self::ERC20InsufficientBalance(ERC20InsufficientBalance {
7781 sender: sender,
7782 balance: balance,
7783 needed: needed,
7784 })
7785 }
7786 #[inline]
7792 pub fn erc_20_invalid_approver(
7793 approver: alloy::sol_types::private::Address,
7794 ) -> Self {
7795 Self::ERC20InvalidApprover(ERC20InvalidApprover {
7796 approver: approver,
7797 })
7798 }
7799 #[inline]
7805 pub fn erc_20_invalid_receiver(
7806 receiver: alloy::sol_types::private::Address,
7807 ) -> Self {
7808 Self::ERC20InvalidReceiver(ERC20InvalidReceiver {
7809 receiver: receiver,
7810 })
7811 }
7812 #[inline]
7818 pub fn erc_20_invalid_sender(
7819 sender: alloy::sol_types::private::Address,
7820 ) -> Self {
7821 Self::ERC20InvalidSender(ERC20InvalidSender {
7822 sender: sender,
7823 })
7824 }
7825 #[inline]
7831 pub fn erc_20_invalid_spender(
7832 spender: alloy::sol_types::private::Address,
7833 ) -> Self {
7834 Self::ERC20InvalidSpender(ERC20InvalidSpender {
7835 spender: spender,
7836 })
7837 }
7838 #[inline]
7844 pub fn failed_inner_call() -> Self {
7845 Self::FailedInnerCall(FailedInnerCall)
7846 }
7847 #[inline]
7853 pub fn invalid_initialization() -> Self {
7854 Self::InvalidInitialization(InvalidInitialization)
7855 }
7856 #[inline]
7862 pub fn not_initializing() -> Self {
7863 Self::NotInitializing(NotInitializing)
7864 }
7865 #[inline]
7871 pub fn only_reward_claim() -> Self {
7872 Self::OnlyRewardClaim(OnlyRewardClaim)
7873 }
7874 #[inline]
7880 pub fn ownable_invalid_owner(owner: alloy::sol_types::private::Address) -> Self {
7881 Self::OwnableInvalidOwner(OwnableInvalidOwner {
7882 owner: owner,
7883 })
7884 }
7885 #[inline]
7891 pub fn ownable_unauthorized_account(
7892 account: alloy::sol_types::private::Address,
7893 ) -> Self {
7894 Self::OwnableUnauthorizedAccount(OwnableUnauthorizedAccount {
7895 account: account,
7896 })
7897 }
7898 #[inline]
7904 pub fn ownership_cannot_be_renounced() -> Self {
7905 Self::OwnershipCannotBeRenounced(OwnershipCannotBeRenounced)
7906 }
7907 #[inline]
7913 pub fn uups_unauthorized_call_context() -> Self {
7914 Self::UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext)
7915 }
7916 #[inline]
7922 pub fn uups_unsupported_proxiable_uuid(
7923 slot: alloy::sol_types::private::FixedBytes<32>,
7924 ) -> Self {
7925 Self::UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID {
7926 slot: slot,
7927 })
7928 }
7929 #[inline]
7935 pub fn zero_reward_claim_address() -> Self {
7936 Self::ZeroRewardClaimAddress(ZeroRewardClaimAddress)
7937 }
7938 }
7939 #[derive(Clone)]
7941 #[derive(serde::Serialize, serde::Deserialize)]
7942 #[derive(Debug, PartialEq, Eq, Hash)]
7943 pub enum EspTokenV2Events {
7944 #[allow(missing_docs)]
7945 Approval(Approval),
7946 #[allow(missing_docs)]
7947 Initialized(Initialized),
7948 #[allow(missing_docs)]
7949 OwnershipTransferred(OwnershipTransferred),
7950 #[allow(missing_docs)]
7951 Transfer(Transfer),
7952 #[allow(missing_docs)]
7953 Upgraded(Upgraded),
7954 }
7955 impl EspTokenV2Events {
7956 pub const SELECTORS: &'static [[u8; 32usize]] = &[
7963 [
7964 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
7965 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
7966 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
7967 ],
7968 [
7969 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8,
7970 66u8, 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8,
7971 41u8, 30u8, 91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
7972 ],
7973 [
7974 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
7975 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8,
7976 12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
7977 ],
7978 [
7979 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
7980 19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
7981 33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
7982 ],
7983 [
7984 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8,
7985 176u8, 104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8,
7986 196u8, 161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
7987 ],
7988 ];
7989 pub const VARIANT_NAMES: &'static [&'static str] = &[
7991 ::core::stringify!(OwnershipTransferred),
7992 ::core::stringify!(Approval),
7993 ::core::stringify!(Upgraded),
7994 ::core::stringify!(Initialized),
7995 ::core::stringify!(Transfer),
7996 ];
7997 pub const SIGNATURES: &'static [&'static str] = &[
7999 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
8000 <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
8001 <Upgraded as alloy_sol_types::SolEvent>::SIGNATURE,
8002 <Initialized as alloy_sol_types::SolEvent>::SIGNATURE,
8003 <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
8004 ];
8005 #[inline]
8007 pub fn signature_by_selector(
8008 selector: [u8; 32usize],
8009 ) -> ::core::option::Option<&'static str> {
8010 match Self::SELECTORS.binary_search(&selector) {
8011 ::core::result::Result::Ok(idx) => {
8012 ::core::option::Option::Some(Self::SIGNATURES[idx])
8013 }
8014 ::core::result::Result::Err(_) => ::core::option::Option::None,
8015 }
8016 }
8017 #[inline]
8019 pub fn name_by_selector(
8020 selector: [u8; 32usize],
8021 ) -> ::core::option::Option<&'static str> {
8022 let sig = Self::signature_by_selector(selector)?;
8023 sig.split_once('(').map(|(name, _)| name)
8024 }
8025 }
8026 #[automatically_derived]
8027 impl alloy_sol_types::SolEventInterface for EspTokenV2Events {
8028 const NAME: &'static str = "EspTokenV2Events";
8029 const COUNT: usize = 5usize;
8030 fn decode_raw_log(
8031 topics: &[alloy_sol_types::Word],
8032 data: &[u8],
8033 ) -> alloy_sol_types::Result<Self> {
8034 <Self as alloy_sol_types::SolEventInterface>::decode_raw_log_with_config(
8035 topics,
8036 data,
8037 alloy_sol_types::abi::AbiDecoderConfig::default(),
8038 )
8039 }
8040 fn decode_raw_log_with_config(
8041 topics: &[alloy_sol_types::Word],
8042 data: &[u8],
8043 config: alloy_sol_types::abi::AbiDecoderConfig,
8044 ) -> alloy_sol_types::Result<Self> {
8045 match topics.first().copied() {
8046 Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8047 <Approval as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
8048 topics,
8049 data,
8050 config,
8051 )
8052 .map(Self::Approval)
8053 }
8054 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8055 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
8056 topics,
8057 data,
8058 config,
8059 )
8060 .map(Self::Initialized)
8061 }
8062 Some(
8063 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
8064 ) => {
8065 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
8066 topics,
8067 data,
8068 config,
8069 )
8070 .map(Self::OwnershipTransferred)
8071 }
8072 Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8073 <Transfer as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
8074 topics,
8075 data,
8076 config,
8077 )
8078 .map(Self::Transfer)
8079 }
8080 Some(<Upgraded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8081 <Upgraded as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
8082 topics,
8083 data,
8084 config,
8085 )
8086 .map(Self::Upgraded)
8087 }
8088 _ => {
8089 if topics
8090 .len()
8091 .checked_mul(alloy_sol_types::Word::len_bytes())
8092 .and_then(|len| len.checked_add(data.len()))
8093 .is_none_or(|len| len > config.get_memory_limit())
8094 {
8095 return alloy_sol_types::private::Err(
8096 alloy_sol_types::Error::MemoryLimitExceeded(
8097 config.get_memory_limit(),
8098 ),
8099 );
8100 }
8101 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
8102 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
8103 log: alloy_sol_types::private::Box::new(
8104 alloy_sol_types::private::LogData::new_unchecked(
8105 topics.to_vec(),
8106 data.to_vec().into(),
8107 ),
8108 ),
8109 })
8110 }
8111 }
8112 }
8113 }
8114 #[automatically_derived]
8115 impl alloy_sol_types::private::IntoLogData for EspTokenV2Events {
8116 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
8117 match self {
8118 Self::Approval(inner) => {
8119 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8120 }
8121 Self::Initialized(inner) => {
8122 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8123 }
8124 Self::OwnershipTransferred(inner) => {
8125 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8126 }
8127 Self::Transfer(inner) => {
8128 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8129 }
8130 Self::Upgraded(inner) => {
8131 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8132 }
8133 }
8134 }
8135 fn into_log_data(self) -> alloy_sol_types::private::LogData {
8136 match self {
8137 Self::Approval(inner) => {
8138 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8139 }
8140 Self::Initialized(inner) => {
8141 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8142 }
8143 Self::OwnershipTransferred(inner) => {
8144 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8145 }
8146 Self::Transfer(inner) => {
8147 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8148 }
8149 Self::Upgraded(inner) => {
8150 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8151 }
8152 }
8153 }
8154 }
8155 #[automatically_derived]
8156 impl EspTokenV2Events {
8157 #[inline]
8163 pub fn approval(
8164 owner: alloy::sol_types::private::Address,
8165 spender: alloy::sol_types::private::Address,
8166 value: alloy::sol_types::private::primitives::aliases::U256,
8167 ) -> Self {
8168 Self::Approval(Approval {
8169 owner: owner,
8170 spender: spender,
8171 value: value,
8172 })
8173 }
8174 #[inline]
8180 pub fn initialized(version: u64) -> Self {
8181 Self::Initialized(Initialized { version: version })
8182 }
8183 #[inline]
8189 pub fn ownership_transferred(
8190 previous_owner: alloy::sol_types::private::Address,
8191 new_owner: alloy::sol_types::private::Address,
8192 ) -> Self {
8193 Self::OwnershipTransferred(OwnershipTransferred {
8194 previousOwner: previous_owner,
8195 newOwner: new_owner,
8196 })
8197 }
8198 #[inline]
8204 pub fn transfer(
8205 from: alloy::sol_types::private::Address,
8206 to: alloy::sol_types::private::Address,
8207 value: alloy::sol_types::private::primitives::aliases::U256,
8208 ) -> Self {
8209 Self::Transfer(Transfer {
8210 from: from,
8211 to: to,
8212 value: value,
8213 })
8214 }
8215 #[inline]
8221 pub fn upgraded(implementation: alloy::sol_types::private::Address) -> Self {
8222 Self::Upgraded(Upgraded {
8223 implementation: implementation,
8224 })
8225 }
8226 }
8227 use alloy::contract as alloy_contract;
8228 #[inline]
8232 pub const fn new<
8233 P: alloy_contract::private::Provider<N>,
8234 N: alloy_contract::private::Network,
8235 >(
8236 address: alloy_sol_types::private::Address,
8237 __provider: P,
8238 ) -> EspTokenV2Instance<P, N> {
8239 EspTokenV2Instance::<P, N>::new(address, __provider)
8240 }
8241 #[inline]
8247 pub fn deploy<
8248 P: alloy_contract::private::Provider<N>,
8249 N: alloy_contract::private::Network,
8250 >(
8251 __provider: P,
8252 ) -> impl ::core::future::Future<
8253 Output = alloy_contract::Result<EspTokenV2Instance<P, N>>,
8254 > {
8255 EspTokenV2Instance::<P, N>::deploy(__provider)
8256 }
8257 #[inline]
8263 pub fn deploy_builder<
8264 P: alloy_contract::private::Provider<N>,
8265 N: alloy_contract::private::Network,
8266 >(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
8267 EspTokenV2Instance::<P, N>::deploy_builder(__provider)
8268 }
8269 #[derive(Clone)]
8281 pub struct EspTokenV2Instance<P, N = alloy_contract::private::Ethereum> {
8282 address: alloy_sol_types::private::Address,
8283 provider: P,
8284 _network: ::core::marker::PhantomData<N>,
8285 }
8286 #[automatically_derived]
8287 impl<P, N> ::core::fmt::Debug for EspTokenV2Instance<P, N> {
8288 #[inline]
8289 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8290 f.debug_tuple("EspTokenV2Instance").field(&self.address).finish()
8291 }
8292 }
8293 impl<
8295 P: alloy_contract::private::Provider<N>,
8296 N: alloy_contract::private::Network,
8297 > EspTokenV2Instance<P, N> {
8298 #[inline]
8302 pub const fn new(
8303 address: alloy_sol_types::private::Address,
8304 __provider: P,
8305 ) -> Self {
8306 Self {
8307 address,
8308 provider: __provider,
8309 _network: ::core::marker::PhantomData,
8310 }
8311 }
8312 #[inline]
8318 pub async fn deploy(
8319 __provider: P,
8320 ) -> alloy_contract::Result<EspTokenV2Instance<P, N>> {
8321 let call_builder = Self::deploy_builder(__provider);
8322 let contract_address = call_builder.deploy().await?;
8323 Ok(Self::new(contract_address, call_builder.provider))
8324 }
8325 #[inline]
8331 pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
8332 alloy_contract::RawCallBuilder::new_raw_deploy(
8333 __provider,
8334 ::core::clone::Clone::clone(&BYTECODE),
8335 )
8336 }
8337 #[inline]
8339 pub const fn address(&self) -> &alloy_sol_types::private::Address {
8340 &self.address
8341 }
8342 #[inline]
8344 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
8345 self.address = address;
8346 }
8347 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
8349 self.set_address(address);
8350 self
8351 }
8352 #[inline]
8354 pub const fn provider(&self) -> &P {
8355 &self.provider
8356 }
8357 }
8358 impl<P: ::core::clone::Clone, N> EspTokenV2Instance<&P, N> {
8359 #[inline]
8361 pub fn with_cloned_provider(self) -> EspTokenV2Instance<P, N> {
8362 EspTokenV2Instance {
8363 address: self.address,
8364 provider: ::core::clone::Clone::clone(&self.provider),
8365 _network: ::core::marker::PhantomData,
8366 }
8367 }
8368 }
8369 impl<
8371 P: alloy_contract::private::Provider<N>,
8372 N: alloy_contract::private::Network,
8373 > EspTokenV2Instance<P, N> {
8374 pub fn call_builder<C: alloy_sol_types::SolCall>(
8379 &self,
8380 call: &C,
8381 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
8382 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
8383 }
8384 pub fn UPGRADE_INTERFACE_VERSION(
8386 &self,
8387 ) -> alloy_contract::SolCallBuilder<&P, UPGRADE_INTERFACE_VERSIONCall, N> {
8388 self.call_builder(&UPGRADE_INTERFACE_VERSIONCall)
8389 }
8390 pub fn allowance(
8392 &self,
8393 owner: alloy::sol_types::private::Address,
8394 spender: alloy::sol_types::private::Address,
8395 ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
8396 self.call_builder(&allowanceCall { owner, spender })
8397 }
8398 pub fn approve(
8400 &self,
8401 spender: alloy::sol_types::private::Address,
8402 value: alloy::sol_types::private::primitives::aliases::U256,
8403 ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
8404 self.call_builder(&approveCall { spender, value })
8405 }
8406 pub fn balanceOf(
8408 &self,
8409 account: alloy::sol_types::private::Address,
8410 ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
8411 self.call_builder(&balanceOfCall { account })
8412 }
8413 pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
8415 self.call_builder(&decimalsCall)
8416 }
8417 pub fn getVersion(
8419 &self,
8420 ) -> alloy_contract::SolCallBuilder<&P, getVersionCall, N> {
8421 self.call_builder(&getVersionCall)
8422 }
8423 pub fn initialize(
8425 &self,
8426 owner: alloy::sol_types::private::Address,
8427 initialRecipient: alloy::sol_types::private::Address,
8428 initialSupply: alloy::sol_types::private::primitives::aliases::U256,
8429 name: alloy::sol_types::private::String,
8430 symbol: alloy::sol_types::private::String,
8431 ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
8432 self.call_builder(
8433 &initializeCall {
8434 owner,
8435 initialRecipient,
8436 initialSupply,
8437 name,
8438 symbol,
8439 },
8440 )
8441 }
8442 pub fn initializeV2(
8444 &self,
8445 _rewardClaim: alloy::sol_types::private::Address,
8446 ) -> alloy_contract::SolCallBuilder<&P, initializeV2Call, N> {
8447 self.call_builder(&initializeV2Call { _rewardClaim })
8448 }
8449 pub fn mint(
8451 &self,
8452 to: alloy::sol_types::private::Address,
8453 amount: alloy::sol_types::private::primitives::aliases::U256,
8454 ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
8455 self.call_builder(&mintCall { to, amount })
8456 }
8457 pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
8459 self.call_builder(&nameCall)
8460 }
8461 pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
8463 self.call_builder(&ownerCall)
8464 }
8465 pub fn proxiableUUID(
8467 &self,
8468 ) -> alloy_contract::SolCallBuilder<&P, proxiableUUIDCall, N> {
8469 self.call_builder(&proxiableUUIDCall)
8470 }
8471 pub fn renounceOwnership(
8473 &self,
8474 ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
8475 self.call_builder(&renounceOwnershipCall)
8476 }
8477 pub fn rewardClaim(
8479 &self,
8480 ) -> alloy_contract::SolCallBuilder<&P, rewardClaimCall, N> {
8481 self.call_builder(&rewardClaimCall)
8482 }
8483 pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
8485 self.call_builder(&symbolCall)
8486 }
8487 pub fn totalSupply(
8489 &self,
8490 ) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
8491 self.call_builder(&totalSupplyCall)
8492 }
8493 pub fn transfer(
8495 &self,
8496 to: alloy::sol_types::private::Address,
8497 value: alloy::sol_types::private::primitives::aliases::U256,
8498 ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
8499 self.call_builder(&transferCall { to, value })
8500 }
8501 pub fn transferFrom(
8503 &self,
8504 from: alloy::sol_types::private::Address,
8505 to: alloy::sol_types::private::Address,
8506 value: alloy::sol_types::private::primitives::aliases::U256,
8507 ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
8508 self.call_builder(
8509 &transferFromCall {
8510 from,
8511 to,
8512 value,
8513 },
8514 )
8515 }
8516 pub fn transferOwnership(
8518 &self,
8519 newOwner: alloy::sol_types::private::Address,
8520 ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
8521 self.call_builder(&transferOwnershipCall { newOwner })
8522 }
8523 pub fn upgradeToAndCall(
8525 &self,
8526 newImplementation: alloy::sol_types::private::Address,
8527 data: alloy::sol_types::private::Bytes,
8528 ) -> alloy_contract::SolCallBuilder<&P, upgradeToAndCallCall, N> {
8529 self.call_builder(
8530 &upgradeToAndCallCall {
8531 newImplementation,
8532 data,
8533 },
8534 )
8535 }
8536 }
8537 impl<
8539 P: alloy_contract::private::Provider<N>,
8540 N: alloy_contract::private::Network,
8541 > EspTokenV2Instance<P, N> {
8542 pub fn event_filter<E: alloy_sol_types::SolEvent>(
8547 &self,
8548 ) -> alloy_contract::Event<&P, E, N> {
8549 alloy_contract::Event::new_sol(&self.provider, &self.address)
8550 }
8551 pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
8553 self.event_filter::<Approval>()
8554 }
8555 pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
8557 self.event_filter::<Initialized>()
8558 }
8559 pub fn OwnershipTransferred_filter(
8561 &self,
8562 ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
8563 self.event_filter::<OwnershipTransferred>()
8564 }
8565 pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
8567 self.event_filter::<Transfer>()
8568 }
8569 pub fn Upgraded_filter(&self) -> alloy_contract::Event<&P, Upgraded, N> {
8571 self.event_filter::<Upgraded>()
8572 }
8573 }
8574}