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