1#[allow(
627 non_camel_case_types,
628 non_snake_case,
629 clippy::pub_underscore_fields,
630 clippy::style,
631 clippy::empty_structs_with_brackets
632)]
633pub mod EspToken {
634 use alloy::sol_types as alloy_sol_types;
635
636 use super::*;
637 #[rustfmt::skip]
643 #[allow(clippy::all)]
644 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
645 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\x131a\0\xF9_9_\x81\x81a\x08Q\x01R\x81\x81a\x08z\x01Ra\t\xF8\x01Ra\x131_\xF3\xFE`\x80`@R`\x046\x10a\0\xFAW_5`\xE0\x1C\x80cR\xD1\x90-\x11a\0\x92W\x80c\x95\xD8\x9BA\x11a\0bW\x80c\x95\xD8\x9BA\x14a\x02\xDBW\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[\x80cR\xD1\x90-\x14a\x02-W\x80cp\xA0\x821\x14a\x02AW\x80cqP\x18\xA6\x14a\x02\x81W\x80c\x8D\xA5\xCB[\x14a\x02\x95W__\xFD[\x80c#\xB8r\xDD\x11a\0\xCDW\x80c#\xB8r\xDD\x14a\x01\xBFW\x80c1<\xE5g\x14a\x01\xDEW\x80cH\\\xC9U\x14a\x01\xF9W\x80cO\x1E\xF2\x86\x14a\x02\x1AW__\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\x8DV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x013W__\xFD[Pa\x01Ga\x01B6`\x04a\x0F\xDDV[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\x10\x05V[a\x04UV[4\x80\x15a\x01\xE9W__\xFD[P`@Q`\x12\x81R` \x01a\x01\x1FV[4\x80\x15a\x02\x04W__\xFD[Pa\x02\x18a\x02\x136`\x04a\x10?V[a\x04zV[\0[a\x02\x18a\x02(6`\x04a\x10\x84V[a\x05\xF2V[4\x80\x15a\x028W__\xFD[Pa\x01\xB1a\x06\x11V[4\x80\x15a\x02LW__\xFD[Pa\x01\xB1a\x02[6`\x04a\x11HV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R_Q` a\x12\xE5_9_Q\x90_R` R`@\x90 T\x90V[4\x80\x15a\x02\x8CW__\xFD[Pa\x02\x18a\x06,V[4\x80\x15a\x02\xA0W__\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\xE6W__\xFD[Pa\x01\x12a\x06?V[4\x80\x15a\x02\xFAW__\xFD[Pa\x01Ga\x03\t6`\x04a\x0F\xDDV[a\x06}V[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\x10?V[a\x06\x8AV[4\x80\x15a\x03hW__\xFD[Pa\x02\x18a\x03w6`\x04a\x11HV[a\x06\xD3V[\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\x12\xE5_9_Q\x90_R\x91a\x03\xBA\x90a\x11aV[\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\x11aV[\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\x07\x15V[`\x01\x91PP[\x92\x91PPV[_3a\x04b\x85\x82\x85a\x07'V[a\x04m\x85\x85\x85a\x07\x8AV[`\x01\x91PP[\x93\x92PPPV[\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\x04\xBFWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x04\xDBWP0;\x15[\x90P\x81\x15\x80\x15a\x04\xE9WP\x80\x15[\x15a\x05\x07W`@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\x051W\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x05|`@Q\x80`@\x01`@R\x80`\x0E\x81R` \x01m\"\xB9\xB892\xB9\xB9\xB7\x90*7\xB5\xB2\xB7`\x91\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\x04U5`\xEC\x1B\x81RPa\x07\xE7V[a\x05\x85\x87a\x07\xF9V[a\x05\x8Da\x08\nV[a\x05\xA3\x86k O\xCE^>%\x02a\x10\0\0\0a\x08\x12V[\x83\x15a\x05\xE9W\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[PPPPPPPV[a\x05\xFAa\x08FV[a\x06\x03\x82a\x08\xEAV[a\x06\r\x82\x82a\t1V[PPV[_a\x06\x1Aa\t\xEDV[P_Q` a\x13\x05_9_Q\x90_R\x90V[a\x064a\n6V[a\x06=_a\n\x91V[V[\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x04\x80T``\x91_Q` a\x12\xE5_9_Q\x90_R\x91a\x03\xBA\x90a\x11aV[_3a\x04I\x81\x85\x85a\x07\x8AV[`\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\xDBa\n6V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x07\tW`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[a\x07\x12\x81a\n\x91V[PV[a\x07\"\x83\x83\x83`\x01a\x0B\x01V[PPPV[_a\x072\x84\x84a\x06\x8AV[\x90P_\x19\x81\x14a\x07\x84W\x81\x81\x10\x15a\x07vW`@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\x07\0V[a\x07\x84\x84\x84\x84\x84\x03_a\x0B\x01V[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07\xB3W`@QcKc~\x8F`\xE1\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xDCW`@Qc\xECD/\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[a\x07\"\x83\x83\x83a\x0B\xE5V[a\x07\xEFa\r\x1EV[a\x06\r\x82\x82a\rgV[a\x08\x01a\r\x1EV[a\x07\x12\x81a\r\xB7V[a\x06=a\r\x1EV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08;W`@Qc\xECD/\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[a\x06\r_\x83\x83a\x0B\xE5V[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14\x80a\x08\xCCWP\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\xC0_Q` a\x13\x05_9_Q\x90_RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x06=W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08\xF2a\n6V[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01`@Q\x80\x91\x03\x90\xA1PV[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\t\x8BWP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\t\x88\x91\x81\x01\x90a\x11\x99V[`\x01[a\t\xB3W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x07\0V[_Q` a\x13\x05_9_Q\x90_R\x81\x14a\t\xE3W`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x07\0V[a\x07\"\x83\x83a\r\xBFV[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\x06=W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3a\nh\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\x06=W`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x07\0V[\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\x12\xE5_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x85\x16a\x0B8W`@Qc\xE6\x02\xDF\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0BaW`@QcJ\x14\x06\xB1`\xE1\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[`\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\xDEW\x83`\x01`\x01`\xA0\x1B\x03\x16\x85`\x01`\x01`\xA0\x1B\x03\x16\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x85`@Qa\x0B\xD5\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3[PPPPPV[_Q` a\x12\xE5_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0C\x1FW\x81\x81`\x02\x01_\x82\x82Ta\x0C\x14\x91\x90a\x11\xB0V[\x90\x91UPa\x0C\x8F\x90PV[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R` \x82\x90R`@\x90 T\x82\x81\x10\x15a\x0CqW`@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\x07\0V[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R` \x83\x90R`@\x90 \x90\x83\x90\x03\x90U[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x0C\xADW`\x02\x81\x01\x80T\x83\x90\x03\x90Ua\x0C\xCBV[`\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\r\x10\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[\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\x06=W`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\roa\r\x1EV[_Q` a\x12\xE5_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\xA8\x84\x82a\x12\x13V[P`\x04\x81\x01a\x07\x84\x83\x82a\x12\x13V[a\x06\xDBa\r\x1EV[a\r\xC8\x82a\x0E\x14V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\x0E\x0CWa\x07\"\x82\x82a\x0EwV[a\x06\ra\x0E\xE9V[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x0EIW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x07\0V[_Q` a\x13\x05_9_Q\x90_R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``__\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\x0E\x93\x91\x90a\x12\xCEV[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x0E\xCBW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0E\xD0V[``\x91P[P\x91P\x91Pa\x0E\xE0\x85\x83\x83a\x0F\x08V[\x95\x94PPPPPV[4\x15a\x06=W`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82a\x0F\x1DWa\x0F\x18\x82a\x0FdV[a\x04sV[\x81Q\x15\x80\x15a\x0F4WP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x0F]W`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\x07\0V[P\x80a\x04sV[\x80Q\x15a\x0FtW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0F\xD8W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0F\xEEW__\xFD[a\x0F\xF7\x83a\x0F\xC2V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x10\x17W__\xFD[a\x10 \x84a\x0F\xC2V[\x92Pa\x10.` \x85\x01a\x0F\xC2V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[__`@\x83\x85\x03\x12\x15a\x10PW__\xFD[a\x10Y\x83a\x0F\xC2V[\x91Pa\x10g` \x84\x01a\x0F\xC2V[\x90P\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[__`@\x83\x85\x03\x12\x15a\x10\x95W__\xFD[a\x10\x9E\x83a\x0F\xC2V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xB9W__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a\x10\xC9W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xE3Wa\x10\xE3a\x10pV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x11\x12Wa\x11\x12a\x10pV[`@R\x81\x81R\x82\x82\x01` \x01\x87\x10\x15a\x11)W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x11XW__\xFD[a\x04s\x82a\x0F\xC2V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x11uW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x11\x93WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x11\xA9W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x04OWcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[`\x1F\x82\x11\x15a\x07\"W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x11\xF4WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0B\xDEW_\x81U`\x01\x01a\x12\0V[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12-Wa\x12-a\x10pV[a\x12A\x81a\x12;\x84Ta\x11aV[\x84a\x11\xCFV[` `\x1F\x82\x11`\x01\x81\x14a\x12sW_\x83\x15a\x12\\WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0B\xDEV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x12\xA2W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x12\x82V[P\x84\x82\x10\x15a\x12\xBFW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV\xFER\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x006\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08\x1C\0\n",
646 );
647 #[rustfmt::skip]
653 #[allow(clippy::all)]
654 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
655 b"`\x80`@R`\x046\x10a\0\xFAW_5`\xE0\x1C\x80cR\xD1\x90-\x11a\0\x92W\x80c\x95\xD8\x9BA\x11a\0bW\x80c\x95\xD8\x9BA\x14a\x02\xDBW\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[\x80cR\xD1\x90-\x14a\x02-W\x80cp\xA0\x821\x14a\x02AW\x80cqP\x18\xA6\x14a\x02\x81W\x80c\x8D\xA5\xCB[\x14a\x02\x95W__\xFD[\x80c#\xB8r\xDD\x11a\0\xCDW\x80c#\xB8r\xDD\x14a\x01\xBFW\x80c1<\xE5g\x14a\x01\xDEW\x80cH\\\xC9U\x14a\x01\xF9W\x80cO\x1E\xF2\x86\x14a\x02\x1AW__\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\x8DV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x013W__\xFD[Pa\x01Ga\x01B6`\x04a\x0F\xDDV[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\x10\x05V[a\x04UV[4\x80\x15a\x01\xE9W__\xFD[P`@Q`\x12\x81R` \x01a\x01\x1FV[4\x80\x15a\x02\x04W__\xFD[Pa\x02\x18a\x02\x136`\x04a\x10?V[a\x04zV[\0[a\x02\x18a\x02(6`\x04a\x10\x84V[a\x05\xF2V[4\x80\x15a\x028W__\xFD[Pa\x01\xB1a\x06\x11V[4\x80\x15a\x02LW__\xFD[Pa\x01\xB1a\x02[6`\x04a\x11HV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R_Q` a\x12\xE5_9_Q\x90_R` R`@\x90 T\x90V[4\x80\x15a\x02\x8CW__\xFD[Pa\x02\x18a\x06,V[4\x80\x15a\x02\xA0W__\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\xE6W__\xFD[Pa\x01\x12a\x06?V[4\x80\x15a\x02\xFAW__\xFD[Pa\x01Ga\x03\t6`\x04a\x0F\xDDV[a\x06}V[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\x10?V[a\x06\x8AV[4\x80\x15a\x03hW__\xFD[Pa\x02\x18a\x03w6`\x04a\x11HV[a\x06\xD3V[\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\x12\xE5_9_Q\x90_R\x91a\x03\xBA\x90a\x11aV[\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\x11aV[\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\x07\x15V[`\x01\x91PP[\x92\x91PPV[_3a\x04b\x85\x82\x85a\x07'V[a\x04m\x85\x85\x85a\x07\x8AV[`\x01\x91PP[\x93\x92PPPV[\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\x04\xBFWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x04\xDBWP0;\x15[\x90P\x81\x15\x80\x15a\x04\xE9WP\x80\x15[\x15a\x05\x07W`@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\x051W\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x05|`@Q\x80`@\x01`@R\x80`\x0E\x81R` \x01m\"\xB9\xB892\xB9\xB9\xB7\x90*7\xB5\xB2\xB7`\x91\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\x04U5`\xEC\x1B\x81RPa\x07\xE7V[a\x05\x85\x87a\x07\xF9V[a\x05\x8Da\x08\nV[a\x05\xA3\x86k O\xCE^>%\x02a\x10\0\0\0a\x08\x12V[\x83\x15a\x05\xE9W\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[PPPPPPPV[a\x05\xFAa\x08FV[a\x06\x03\x82a\x08\xEAV[a\x06\r\x82\x82a\t1V[PPV[_a\x06\x1Aa\t\xEDV[P_Q` a\x13\x05_9_Q\x90_R\x90V[a\x064a\n6V[a\x06=_a\n\x91V[V[\x7FR\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x04\x80T``\x91_Q` a\x12\xE5_9_Q\x90_R\x91a\x03\xBA\x90a\x11aV[_3a\x04I\x81\x85\x85a\x07\x8AV[`\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\xDBa\n6V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x07\tW`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[a\x07\x12\x81a\n\x91V[PV[a\x07\"\x83\x83\x83`\x01a\x0B\x01V[PPPV[_a\x072\x84\x84a\x06\x8AV[\x90P_\x19\x81\x14a\x07\x84W\x81\x81\x10\x15a\x07vW`@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\x07\0V[a\x07\x84\x84\x84\x84\x84\x03_a\x0B\x01V[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07\xB3W`@QcKc~\x8F`\xE1\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xDCW`@Qc\xECD/\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[a\x07\"\x83\x83\x83a\x0B\xE5V[a\x07\xEFa\r\x1EV[a\x06\r\x82\x82a\rgV[a\x08\x01a\r\x1EV[a\x07\x12\x81a\r\xB7V[a\x06=a\r\x1EV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08;W`@Qc\xECD/\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[a\x06\r_\x83\x83a\x0B\xE5V[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14\x80a\x08\xCCWP\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\xC0_Q` a\x13\x05_9_Q\x90_RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x06=W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08\xF2a\n6V[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01`@Q\x80\x91\x03\x90\xA1PV[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\t\x8BWP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\t\x88\x91\x81\x01\x90a\x11\x99V[`\x01[a\t\xB3W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x07\0V[_Q` a\x13\x05_9_Q\x90_R\x81\x14a\t\xE3W`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x07\0V[a\x07\"\x83\x83a\r\xBFV[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\x06=W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3a\nh\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\x06=W`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x07\0V[\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\x12\xE5_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x85\x16a\x0B8W`@Qc\xE6\x02\xDF\x05`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0BaW`@QcJ\x14\x06\xB1`\xE1\x1B\x81R_`\x04\x82\x01R`$\x01a\x07\0V[`\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\xDEW\x83`\x01`\x01`\xA0\x1B\x03\x16\x85`\x01`\x01`\xA0\x1B\x03\x16\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x85`@Qa\x0B\xD5\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3[PPPPPV[_Q` a\x12\xE5_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0C\x1FW\x81\x81`\x02\x01_\x82\x82Ta\x0C\x14\x91\x90a\x11\xB0V[\x90\x91UPa\x0C\x8F\x90PV[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R` \x82\x90R`@\x90 T\x82\x81\x10\x15a\x0CqW`@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\x07\0V[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R` \x83\x90R`@\x90 \x90\x83\x90\x03\x90U[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x0C\xADW`\x02\x81\x01\x80T\x83\x90\x03\x90Ua\x0C\xCBV[`\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\r\x10\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[\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\x06=W`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\roa\r\x1EV[_Q` a\x12\xE5_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\xA8\x84\x82a\x12\x13V[P`\x04\x81\x01a\x07\x84\x83\x82a\x12\x13V[a\x06\xDBa\r\x1EV[a\r\xC8\x82a\x0E\x14V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\x0E\x0CWa\x07\"\x82\x82a\x0EwV[a\x06\ra\x0E\xE9V[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x0EIW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x07\0V[_Q` a\x13\x05_9_Q\x90_R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``__\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\x0E\x93\x91\x90a\x12\xCEV[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x0E\xCBW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0E\xD0V[``\x91P[P\x91P\x91Pa\x0E\xE0\x85\x83\x83a\x0F\x08V[\x95\x94PPPPPV[4\x15a\x06=W`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82a\x0F\x1DWa\x0F\x18\x82a\x0FdV[a\x04sV[\x81Q\x15\x80\x15a\x0F4WP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x0F]W`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\x07\0V[P\x80a\x04sV[\x80Q\x15a\x0FtW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0F\xD8W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0F\xEEW__\xFD[a\x0F\xF7\x83a\x0F\xC2V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x10\x17W__\xFD[a\x10 \x84a\x0F\xC2V[\x92Pa\x10.` \x85\x01a\x0F\xC2V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[__`@\x83\x85\x03\x12\x15a\x10PW__\xFD[a\x10Y\x83a\x0F\xC2V[\x91Pa\x10g` \x84\x01a\x0F\xC2V[\x90P\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[__`@\x83\x85\x03\x12\x15a\x10\x95W__\xFD[a\x10\x9E\x83a\x0F\xC2V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xB9W__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a\x10\xC9W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xE3Wa\x10\xE3a\x10pV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x11\x12Wa\x11\x12a\x10pV[`@R\x81\x81R\x82\x82\x01` \x01\x87\x10\x15a\x11)W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x11XW__\xFD[a\x04s\x82a\x0F\xC2V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x11uW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x11\x93WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x11\xA9W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x04OWcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[`\x1F\x82\x11\x15a\x07\"W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x11\xF4WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0B\xDEW_\x81U`\x01\x01a\x12\0V[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12-Wa\x12-a\x10pV[a\x12A\x81a\x12;\x84Ta\x11aV[\x84a\x11\xCFV[` `\x1F\x82\x11`\x01\x81\x14a\x12sW_\x83\x15a\x12\\WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0B\xDEV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x12\xA2W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x12\x82V[P\x84\x82\x10\x15a\x12\xBFW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV\xFER\xC62G\xE1\xF4}\xB1\x9D\\\xE0F\x000\xC4\x97\xF0g\xCAL\xEB\xF7\x1B\xA9\x8E\xEA\xDA\xBE \xBA\xCE\x006\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08\x1C\0\n",
656 );
657 #[derive(Default, Debug, PartialEq, Eq, Hash)]
658 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
663 #[derive(Clone)]
664 pub struct AddressEmptyCode {
665 #[allow(missing_docs)]
666 pub target: alloy::sol_types::private::Address,
667 }
668 #[allow(
669 non_camel_case_types,
670 non_snake_case,
671 clippy::pub_underscore_fields,
672 clippy::style
673 )]
674 const _: () = {
675 use alloy::sol_types as alloy_sol_types;
676 #[doc(hidden)]
677 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
678 #[doc(hidden)]
679 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
680 #[cfg(test)]
681 #[allow(dead_code, unreachable_patterns)]
682 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
683 match _t {
684 alloy_sol_types::private::AssertTypeEq::<
685 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
686 >(_) => {},
687 }
688 }
689 #[automatically_derived]
690 #[doc(hidden)]
691 impl ::core::convert::From<AddressEmptyCode> for UnderlyingRustTuple<'_> {
692 fn from(value: AddressEmptyCode) -> Self {
693 (value.target,)
694 }
695 }
696 #[automatically_derived]
697 #[doc(hidden)]
698 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressEmptyCode {
699 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
700 Self { target: tuple.0 }
701 }
702 }
703 #[automatically_derived]
704 impl alloy_sol_types::SolError for AddressEmptyCode {
705 type Parameters<'a> = UnderlyingSolTuple<'a>;
706 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
707 const SIGNATURE: &'static str = "AddressEmptyCode(address)";
708 const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8];
709 #[inline]
710 fn new<'a>(
711 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
712 ) -> Self {
713 tuple.into()
714 }
715 #[inline]
716 fn tokenize(&self) -> Self::Token<'_> {
717 (
718 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
719 &self.target,
720 ),
721 )
722 }
723 }
724 };
725 #[derive(Default, Debug, PartialEq, Eq, Hash)]
726 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
731 #[derive(Clone)]
732 pub struct ERC1967InvalidImplementation {
733 #[allow(missing_docs)]
734 pub implementation: alloy::sol_types::private::Address,
735 }
736 #[allow(
737 non_camel_case_types,
738 non_snake_case,
739 clippy::pub_underscore_fields,
740 clippy::style
741 )]
742 const _: () = {
743 use alloy::sol_types as alloy_sol_types;
744 #[doc(hidden)]
745 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
746 #[doc(hidden)]
747 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
748 #[cfg(test)]
749 #[allow(dead_code, unreachable_patterns)]
750 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
751 match _t {
752 alloy_sol_types::private::AssertTypeEq::<
753 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
754 >(_) => {},
755 }
756 }
757 #[automatically_derived]
758 #[doc(hidden)]
759 impl ::core::convert::From<ERC1967InvalidImplementation> for UnderlyingRustTuple<'_> {
760 fn from(value: ERC1967InvalidImplementation) -> Self {
761 (value.implementation,)
762 }
763 }
764 #[automatically_derived]
765 #[doc(hidden)]
766 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1967InvalidImplementation {
767 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
768 Self {
769 implementation: tuple.0,
770 }
771 }
772 }
773 #[automatically_derived]
774 impl alloy_sol_types::SolError for ERC1967InvalidImplementation {
775 type Parameters<'a> = UnderlyingSolTuple<'a>;
776 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
777 const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)";
778 const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8];
779 #[inline]
780 fn new<'a>(
781 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
782 ) -> Self {
783 tuple.into()
784 }
785 #[inline]
786 fn tokenize(&self) -> Self::Token<'_> {
787 (
788 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
789 &self.implementation,
790 ),
791 )
792 }
793 }
794 };
795 #[derive(Default, Debug, PartialEq, Eq, Hash)]
796 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
801 #[derive(Clone)]
802 pub struct ERC1967NonPayable {}
803 #[allow(
804 non_camel_case_types,
805 non_snake_case,
806 clippy::pub_underscore_fields,
807 clippy::style
808 )]
809 const _: () = {
810 use alloy::sol_types as alloy_sol_types;
811 #[doc(hidden)]
812 type UnderlyingSolTuple<'a> = ();
813 #[doc(hidden)]
814 type UnderlyingRustTuple<'a> = ();
815 #[cfg(test)]
816 #[allow(dead_code, unreachable_patterns)]
817 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
818 match _t {
819 alloy_sol_types::private::AssertTypeEq::<
820 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
821 >(_) => {},
822 }
823 }
824 #[automatically_derived]
825 #[doc(hidden)]
826 impl ::core::convert::From<ERC1967NonPayable> for UnderlyingRustTuple<'_> {
827 fn from(value: ERC1967NonPayable) -> Self {
828 ()
829 }
830 }
831 #[automatically_derived]
832 #[doc(hidden)]
833 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1967NonPayable {
834 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
835 Self {}
836 }
837 }
838 #[automatically_derived]
839 impl alloy_sol_types::SolError for ERC1967NonPayable {
840 type Parameters<'a> = UnderlyingSolTuple<'a>;
841 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
842 const SIGNATURE: &'static str = "ERC1967NonPayable()";
843 const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8];
844 #[inline]
845 fn new<'a>(
846 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
847 ) -> Self {
848 tuple.into()
849 }
850 #[inline]
851 fn tokenize(&self) -> Self::Token<'_> {
852 ()
853 }
854 }
855 };
856 #[derive(Default, Debug, PartialEq, Eq, Hash)]
857 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
862 #[derive(Clone)]
863 pub struct ERC20InsufficientAllowance {
864 #[allow(missing_docs)]
865 pub spender: alloy::sol_types::private::Address,
866 #[allow(missing_docs)]
867 pub allowance: alloy::sol_types::private::primitives::aliases::U256,
868 #[allow(missing_docs)]
869 pub needed: alloy::sol_types::private::primitives::aliases::U256,
870 }
871 #[allow(
872 non_camel_case_types,
873 non_snake_case,
874 clippy::pub_underscore_fields,
875 clippy::style
876 )]
877 const _: () = {
878 use alloy::sol_types as alloy_sol_types;
879 #[doc(hidden)]
880 type UnderlyingSolTuple<'a> = (
881 alloy::sol_types::sol_data::Address,
882 alloy::sol_types::sol_data::Uint<256>,
883 alloy::sol_types::sol_data::Uint<256>,
884 );
885 #[doc(hidden)]
886 type UnderlyingRustTuple<'a> = (
887 alloy::sol_types::private::Address,
888 alloy::sol_types::private::primitives::aliases::U256,
889 alloy::sol_types::private::primitives::aliases::U256,
890 );
891 #[cfg(test)]
892 #[allow(dead_code, unreachable_patterns)]
893 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
894 match _t {
895 alloy_sol_types::private::AssertTypeEq::<
896 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
897 >(_) => {},
898 }
899 }
900 #[automatically_derived]
901 #[doc(hidden)]
902 impl ::core::convert::From<ERC20InsufficientAllowance> for UnderlyingRustTuple<'_> {
903 fn from(value: ERC20InsufficientAllowance) -> Self {
904 (value.spender, value.allowance, value.needed)
905 }
906 }
907 #[automatically_derived]
908 #[doc(hidden)]
909 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InsufficientAllowance {
910 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
911 Self {
912 spender: tuple.0,
913 allowance: tuple.1,
914 needed: tuple.2,
915 }
916 }
917 }
918 #[automatically_derived]
919 impl alloy_sol_types::SolError for ERC20InsufficientAllowance {
920 type Parameters<'a> = UnderlyingSolTuple<'a>;
921 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
922 const SIGNATURE: &'static str = "ERC20InsufficientAllowance(address,uint256,uint256)";
923 const SELECTOR: [u8; 4] = [251u8, 143u8, 65u8, 178u8];
924 #[inline]
925 fn new<'a>(
926 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
927 ) -> Self {
928 tuple.into()
929 }
930 #[inline]
931 fn tokenize(&self) -> Self::Token<'_> {
932 (
933 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
934 &self.spender,
935 ),
936 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
937 &self.allowance,
938 ),
939 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
940 &self.needed,
941 ),
942 )
943 }
944 }
945 };
946 #[derive(Default, Debug, PartialEq, Eq, Hash)]
947 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
952 #[derive(Clone)]
953 pub struct ERC20InsufficientBalance {
954 #[allow(missing_docs)]
955 pub sender: alloy::sol_types::private::Address,
956 #[allow(missing_docs)]
957 pub balance: alloy::sol_types::private::primitives::aliases::U256,
958 #[allow(missing_docs)]
959 pub needed: alloy::sol_types::private::primitives::aliases::U256,
960 }
961 #[allow(
962 non_camel_case_types,
963 non_snake_case,
964 clippy::pub_underscore_fields,
965 clippy::style
966 )]
967 const _: () = {
968 use alloy::sol_types as alloy_sol_types;
969 #[doc(hidden)]
970 type UnderlyingSolTuple<'a> = (
971 alloy::sol_types::sol_data::Address,
972 alloy::sol_types::sol_data::Uint<256>,
973 alloy::sol_types::sol_data::Uint<256>,
974 );
975 #[doc(hidden)]
976 type UnderlyingRustTuple<'a> = (
977 alloy::sol_types::private::Address,
978 alloy::sol_types::private::primitives::aliases::U256,
979 alloy::sol_types::private::primitives::aliases::U256,
980 );
981 #[cfg(test)]
982 #[allow(dead_code, unreachable_patterns)]
983 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
984 match _t {
985 alloy_sol_types::private::AssertTypeEq::<
986 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
987 >(_) => {},
988 }
989 }
990 #[automatically_derived]
991 #[doc(hidden)]
992 impl ::core::convert::From<ERC20InsufficientBalance> for UnderlyingRustTuple<'_> {
993 fn from(value: ERC20InsufficientBalance) -> Self {
994 (value.sender, value.balance, value.needed)
995 }
996 }
997 #[automatically_derived]
998 #[doc(hidden)]
999 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InsufficientBalance {
1000 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1001 Self {
1002 sender: tuple.0,
1003 balance: tuple.1,
1004 needed: tuple.2,
1005 }
1006 }
1007 }
1008 #[automatically_derived]
1009 impl alloy_sol_types::SolError for ERC20InsufficientBalance {
1010 type Parameters<'a> = UnderlyingSolTuple<'a>;
1011 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1012 const SIGNATURE: &'static str = "ERC20InsufficientBalance(address,uint256,uint256)";
1013 const SELECTOR: [u8; 4] = [228u8, 80u8, 211u8, 140u8];
1014 #[inline]
1015 fn new<'a>(
1016 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1017 ) -> Self {
1018 tuple.into()
1019 }
1020 #[inline]
1021 fn tokenize(&self) -> Self::Token<'_> {
1022 (
1023 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1024 &self.sender,
1025 ),
1026 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1027 &self.balance,
1028 ),
1029 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1030 &self.needed,
1031 ),
1032 )
1033 }
1034 }
1035 };
1036 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1037 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1042 #[derive(Clone)]
1043 pub struct ERC20InvalidApprover {
1044 #[allow(missing_docs)]
1045 pub approver: alloy::sol_types::private::Address,
1046 }
1047 #[allow(
1048 non_camel_case_types,
1049 non_snake_case,
1050 clippy::pub_underscore_fields,
1051 clippy::style
1052 )]
1053 const _: () = {
1054 use alloy::sol_types as alloy_sol_types;
1055 #[doc(hidden)]
1056 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1057 #[doc(hidden)]
1058 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1059 #[cfg(test)]
1060 #[allow(dead_code, unreachable_patterns)]
1061 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1062 match _t {
1063 alloy_sol_types::private::AssertTypeEq::<
1064 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1065 >(_) => {},
1066 }
1067 }
1068 #[automatically_derived]
1069 #[doc(hidden)]
1070 impl ::core::convert::From<ERC20InvalidApprover> for UnderlyingRustTuple<'_> {
1071 fn from(value: ERC20InvalidApprover) -> Self {
1072 (value.approver,)
1073 }
1074 }
1075 #[automatically_derived]
1076 #[doc(hidden)]
1077 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidApprover {
1078 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1079 Self { approver: tuple.0 }
1080 }
1081 }
1082 #[automatically_derived]
1083 impl alloy_sol_types::SolError for ERC20InvalidApprover {
1084 type Parameters<'a> = UnderlyingSolTuple<'a>;
1085 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1086 const SIGNATURE: &'static str = "ERC20InvalidApprover(address)";
1087 const SELECTOR: [u8; 4] = [230u8, 2u8, 223u8, 5u8];
1088 #[inline]
1089 fn new<'a>(
1090 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1091 ) -> Self {
1092 tuple.into()
1093 }
1094 #[inline]
1095 fn tokenize(&self) -> Self::Token<'_> {
1096 (
1097 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1098 &self.approver,
1099 ),
1100 )
1101 }
1102 }
1103 };
1104 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1105 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1110 #[derive(Clone)]
1111 pub struct ERC20InvalidReceiver {
1112 #[allow(missing_docs)]
1113 pub receiver: alloy::sol_types::private::Address,
1114 }
1115 #[allow(
1116 non_camel_case_types,
1117 non_snake_case,
1118 clippy::pub_underscore_fields,
1119 clippy::style
1120 )]
1121 const _: () = {
1122 use alloy::sol_types as alloy_sol_types;
1123 #[doc(hidden)]
1124 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1125 #[doc(hidden)]
1126 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1127 #[cfg(test)]
1128 #[allow(dead_code, unreachable_patterns)]
1129 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1130 match _t {
1131 alloy_sol_types::private::AssertTypeEq::<
1132 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1133 >(_) => {},
1134 }
1135 }
1136 #[automatically_derived]
1137 #[doc(hidden)]
1138 impl ::core::convert::From<ERC20InvalidReceiver> for UnderlyingRustTuple<'_> {
1139 fn from(value: ERC20InvalidReceiver) -> Self {
1140 (value.receiver,)
1141 }
1142 }
1143 #[automatically_derived]
1144 #[doc(hidden)]
1145 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidReceiver {
1146 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1147 Self { receiver: tuple.0 }
1148 }
1149 }
1150 #[automatically_derived]
1151 impl alloy_sol_types::SolError for ERC20InvalidReceiver {
1152 type Parameters<'a> = UnderlyingSolTuple<'a>;
1153 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1154 const SIGNATURE: &'static str = "ERC20InvalidReceiver(address)";
1155 const SELECTOR: [u8; 4] = [236u8, 68u8, 47u8, 5u8];
1156 #[inline]
1157 fn new<'a>(
1158 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1159 ) -> Self {
1160 tuple.into()
1161 }
1162 #[inline]
1163 fn tokenize(&self) -> Self::Token<'_> {
1164 (
1165 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1166 &self.receiver,
1167 ),
1168 )
1169 }
1170 }
1171 };
1172 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1173 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1178 #[derive(Clone)]
1179 pub struct ERC20InvalidSender {
1180 #[allow(missing_docs)]
1181 pub sender: alloy::sol_types::private::Address,
1182 }
1183 #[allow(
1184 non_camel_case_types,
1185 non_snake_case,
1186 clippy::pub_underscore_fields,
1187 clippy::style
1188 )]
1189 const _: () = {
1190 use alloy::sol_types as alloy_sol_types;
1191 #[doc(hidden)]
1192 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1193 #[doc(hidden)]
1194 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1195 #[cfg(test)]
1196 #[allow(dead_code, unreachable_patterns)]
1197 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1198 match _t {
1199 alloy_sol_types::private::AssertTypeEq::<
1200 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1201 >(_) => {},
1202 }
1203 }
1204 #[automatically_derived]
1205 #[doc(hidden)]
1206 impl ::core::convert::From<ERC20InvalidSender> for UnderlyingRustTuple<'_> {
1207 fn from(value: ERC20InvalidSender) -> Self {
1208 (value.sender,)
1209 }
1210 }
1211 #[automatically_derived]
1212 #[doc(hidden)]
1213 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidSender {
1214 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1215 Self { sender: tuple.0 }
1216 }
1217 }
1218 #[automatically_derived]
1219 impl alloy_sol_types::SolError for ERC20InvalidSender {
1220 type Parameters<'a> = UnderlyingSolTuple<'a>;
1221 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1222 const SIGNATURE: &'static str = "ERC20InvalidSender(address)";
1223 const SELECTOR: [u8; 4] = [150u8, 198u8, 253u8, 30u8];
1224 #[inline]
1225 fn new<'a>(
1226 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1227 ) -> Self {
1228 tuple.into()
1229 }
1230 #[inline]
1231 fn tokenize(&self) -> Self::Token<'_> {
1232 (
1233 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1234 &self.sender,
1235 ),
1236 )
1237 }
1238 }
1239 };
1240 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1241 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1246 #[derive(Clone)]
1247 pub struct ERC20InvalidSpender {
1248 #[allow(missing_docs)]
1249 pub spender: alloy::sol_types::private::Address,
1250 }
1251 #[allow(
1252 non_camel_case_types,
1253 non_snake_case,
1254 clippy::pub_underscore_fields,
1255 clippy::style
1256 )]
1257 const _: () = {
1258 use alloy::sol_types as alloy_sol_types;
1259 #[doc(hidden)]
1260 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1261 #[doc(hidden)]
1262 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1263 #[cfg(test)]
1264 #[allow(dead_code, unreachable_patterns)]
1265 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1266 match _t {
1267 alloy_sol_types::private::AssertTypeEq::<
1268 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1269 >(_) => {},
1270 }
1271 }
1272 #[automatically_derived]
1273 #[doc(hidden)]
1274 impl ::core::convert::From<ERC20InvalidSpender> for UnderlyingRustTuple<'_> {
1275 fn from(value: ERC20InvalidSpender) -> Self {
1276 (value.spender,)
1277 }
1278 }
1279 #[automatically_derived]
1280 #[doc(hidden)]
1281 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC20InvalidSpender {
1282 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1283 Self { spender: tuple.0 }
1284 }
1285 }
1286 #[automatically_derived]
1287 impl alloy_sol_types::SolError for ERC20InvalidSpender {
1288 type Parameters<'a> = UnderlyingSolTuple<'a>;
1289 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1290 const SIGNATURE: &'static str = "ERC20InvalidSpender(address)";
1291 const SELECTOR: [u8; 4] = [148u8, 40u8, 13u8, 98u8];
1292 #[inline]
1293 fn new<'a>(
1294 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1295 ) -> Self {
1296 tuple.into()
1297 }
1298 #[inline]
1299 fn tokenize(&self) -> Self::Token<'_> {
1300 (
1301 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1302 &self.spender,
1303 ),
1304 )
1305 }
1306 }
1307 };
1308 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1309 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1314 #[derive(Clone)]
1315 pub struct FailedInnerCall {}
1316 #[allow(
1317 non_camel_case_types,
1318 non_snake_case,
1319 clippy::pub_underscore_fields,
1320 clippy::style
1321 )]
1322 const _: () = {
1323 use alloy::sol_types as alloy_sol_types;
1324 #[doc(hidden)]
1325 type UnderlyingSolTuple<'a> = ();
1326 #[doc(hidden)]
1327 type UnderlyingRustTuple<'a> = ();
1328 #[cfg(test)]
1329 #[allow(dead_code, unreachable_patterns)]
1330 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1331 match _t {
1332 alloy_sol_types::private::AssertTypeEq::<
1333 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1334 >(_) => {},
1335 }
1336 }
1337 #[automatically_derived]
1338 #[doc(hidden)]
1339 impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
1340 fn from(value: FailedInnerCall) -> Self {
1341 ()
1342 }
1343 }
1344 #[automatically_derived]
1345 #[doc(hidden)]
1346 impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
1347 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1348 Self {}
1349 }
1350 }
1351 #[automatically_derived]
1352 impl alloy_sol_types::SolError for FailedInnerCall {
1353 type Parameters<'a> = UnderlyingSolTuple<'a>;
1354 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1355 const SIGNATURE: &'static str = "FailedInnerCall()";
1356 const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
1357 #[inline]
1358 fn new<'a>(
1359 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1360 ) -> Self {
1361 tuple.into()
1362 }
1363 #[inline]
1364 fn tokenize(&self) -> Self::Token<'_> {
1365 ()
1366 }
1367 }
1368 };
1369 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1370 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1375 #[derive(Clone)]
1376 pub struct InvalidInitialization {}
1377 #[allow(
1378 non_camel_case_types,
1379 non_snake_case,
1380 clippy::pub_underscore_fields,
1381 clippy::style
1382 )]
1383 const _: () = {
1384 use alloy::sol_types as alloy_sol_types;
1385 #[doc(hidden)]
1386 type UnderlyingSolTuple<'a> = ();
1387 #[doc(hidden)]
1388 type UnderlyingRustTuple<'a> = ();
1389 #[cfg(test)]
1390 #[allow(dead_code, unreachable_patterns)]
1391 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1392 match _t {
1393 alloy_sol_types::private::AssertTypeEq::<
1394 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1395 >(_) => {},
1396 }
1397 }
1398 #[automatically_derived]
1399 #[doc(hidden)]
1400 impl ::core::convert::From<InvalidInitialization> for UnderlyingRustTuple<'_> {
1401 fn from(value: InvalidInitialization) -> Self {
1402 ()
1403 }
1404 }
1405 #[automatically_derived]
1406 #[doc(hidden)]
1407 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInitialization {
1408 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1409 Self {}
1410 }
1411 }
1412 #[automatically_derived]
1413 impl alloy_sol_types::SolError for InvalidInitialization {
1414 type Parameters<'a> = UnderlyingSolTuple<'a>;
1415 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1416 const SIGNATURE: &'static str = "InvalidInitialization()";
1417 const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8];
1418 #[inline]
1419 fn new<'a>(
1420 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1421 ) -> Self {
1422 tuple.into()
1423 }
1424 #[inline]
1425 fn tokenize(&self) -> Self::Token<'_> {
1426 ()
1427 }
1428 }
1429 };
1430 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1431 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1436 #[derive(Clone)]
1437 pub struct NotInitializing {}
1438 #[allow(
1439 non_camel_case_types,
1440 non_snake_case,
1441 clippy::pub_underscore_fields,
1442 clippy::style
1443 )]
1444 const _: () = {
1445 use alloy::sol_types as alloy_sol_types;
1446 #[doc(hidden)]
1447 type UnderlyingSolTuple<'a> = ();
1448 #[doc(hidden)]
1449 type UnderlyingRustTuple<'a> = ();
1450 #[cfg(test)]
1451 #[allow(dead_code, unreachable_patterns)]
1452 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1453 match _t {
1454 alloy_sol_types::private::AssertTypeEq::<
1455 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1456 >(_) => {},
1457 }
1458 }
1459 #[automatically_derived]
1460 #[doc(hidden)]
1461 impl ::core::convert::From<NotInitializing> for UnderlyingRustTuple<'_> {
1462 fn from(value: NotInitializing) -> Self {
1463 ()
1464 }
1465 }
1466 #[automatically_derived]
1467 #[doc(hidden)]
1468 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotInitializing {
1469 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1470 Self {}
1471 }
1472 }
1473 #[automatically_derived]
1474 impl alloy_sol_types::SolError for NotInitializing {
1475 type Parameters<'a> = UnderlyingSolTuple<'a>;
1476 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1477 const SIGNATURE: &'static str = "NotInitializing()";
1478 const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8];
1479 #[inline]
1480 fn new<'a>(
1481 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1482 ) -> Self {
1483 tuple.into()
1484 }
1485 #[inline]
1486 fn tokenize(&self) -> Self::Token<'_> {
1487 ()
1488 }
1489 }
1490 };
1491 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1492 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1497 #[derive(Clone)]
1498 pub struct OwnableInvalidOwner {
1499 #[allow(missing_docs)]
1500 pub owner: alloy::sol_types::private::Address,
1501 }
1502 #[allow(
1503 non_camel_case_types,
1504 non_snake_case,
1505 clippy::pub_underscore_fields,
1506 clippy::style
1507 )]
1508 const _: () = {
1509 use alloy::sol_types as alloy_sol_types;
1510 #[doc(hidden)]
1511 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1512 #[doc(hidden)]
1513 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1514 #[cfg(test)]
1515 #[allow(dead_code, unreachable_patterns)]
1516 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1517 match _t {
1518 alloy_sol_types::private::AssertTypeEq::<
1519 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1520 >(_) => {},
1521 }
1522 }
1523 #[automatically_derived]
1524 #[doc(hidden)]
1525 impl ::core::convert::From<OwnableInvalidOwner> for UnderlyingRustTuple<'_> {
1526 fn from(value: OwnableInvalidOwner) -> Self {
1527 (value.owner,)
1528 }
1529 }
1530 #[automatically_derived]
1531 #[doc(hidden)]
1532 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableInvalidOwner {
1533 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1534 Self { owner: tuple.0 }
1535 }
1536 }
1537 #[automatically_derived]
1538 impl alloy_sol_types::SolError for OwnableInvalidOwner {
1539 type Parameters<'a> = UnderlyingSolTuple<'a>;
1540 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1541 const SIGNATURE: &'static str = "OwnableInvalidOwner(address)";
1542 const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8];
1543 #[inline]
1544 fn new<'a>(
1545 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1546 ) -> Self {
1547 tuple.into()
1548 }
1549 #[inline]
1550 fn tokenize(&self) -> Self::Token<'_> {
1551 (
1552 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1553 &self.owner,
1554 ),
1555 )
1556 }
1557 }
1558 };
1559 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1560 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1565 #[derive(Clone)]
1566 pub struct OwnableUnauthorizedAccount {
1567 #[allow(missing_docs)]
1568 pub account: alloy::sol_types::private::Address,
1569 }
1570 #[allow(
1571 non_camel_case_types,
1572 non_snake_case,
1573 clippy::pub_underscore_fields,
1574 clippy::style
1575 )]
1576 const _: () = {
1577 use alloy::sol_types as alloy_sol_types;
1578 #[doc(hidden)]
1579 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1580 #[doc(hidden)]
1581 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1582 #[cfg(test)]
1583 #[allow(dead_code, unreachable_patterns)]
1584 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1585 match _t {
1586 alloy_sol_types::private::AssertTypeEq::<
1587 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1588 >(_) => {},
1589 }
1590 }
1591 #[automatically_derived]
1592 #[doc(hidden)]
1593 impl ::core::convert::From<OwnableUnauthorizedAccount> for UnderlyingRustTuple<'_> {
1594 fn from(value: OwnableUnauthorizedAccount) -> Self {
1595 (value.account,)
1596 }
1597 }
1598 #[automatically_derived]
1599 #[doc(hidden)]
1600 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableUnauthorizedAccount {
1601 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1602 Self { account: tuple.0 }
1603 }
1604 }
1605 #[automatically_derived]
1606 impl alloy_sol_types::SolError for OwnableUnauthorizedAccount {
1607 type Parameters<'a> = UnderlyingSolTuple<'a>;
1608 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1609 const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)";
1610 const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8];
1611 #[inline]
1612 fn new<'a>(
1613 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1614 ) -> Self {
1615 tuple.into()
1616 }
1617 #[inline]
1618 fn tokenize(&self) -> Self::Token<'_> {
1619 (
1620 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1621 &self.account,
1622 ),
1623 )
1624 }
1625 }
1626 };
1627 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1628 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1633 #[derive(Clone)]
1634 pub struct UUPSUnauthorizedCallContext {}
1635 #[allow(
1636 non_camel_case_types,
1637 non_snake_case,
1638 clippy::pub_underscore_fields,
1639 clippy::style
1640 )]
1641 const _: () = {
1642 use alloy::sol_types as alloy_sol_types;
1643 #[doc(hidden)]
1644 type UnderlyingSolTuple<'a> = ();
1645 #[doc(hidden)]
1646 type UnderlyingRustTuple<'a> = ();
1647 #[cfg(test)]
1648 #[allow(dead_code, unreachable_patterns)]
1649 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1650 match _t {
1651 alloy_sol_types::private::AssertTypeEq::<
1652 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1653 >(_) => {},
1654 }
1655 }
1656 #[automatically_derived]
1657 #[doc(hidden)]
1658 impl ::core::convert::From<UUPSUnauthorizedCallContext> for UnderlyingRustTuple<'_> {
1659 fn from(value: UUPSUnauthorizedCallContext) -> Self {
1660 ()
1661 }
1662 }
1663 #[automatically_derived]
1664 #[doc(hidden)]
1665 impl ::core::convert::From<UnderlyingRustTuple<'_>> for UUPSUnauthorizedCallContext {
1666 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1667 Self {}
1668 }
1669 }
1670 #[automatically_derived]
1671 impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext {
1672 type Parameters<'a> = UnderlyingSolTuple<'a>;
1673 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1674 const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()";
1675 const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8];
1676 #[inline]
1677 fn new<'a>(
1678 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1679 ) -> Self {
1680 tuple.into()
1681 }
1682 #[inline]
1683 fn tokenize(&self) -> Self::Token<'_> {
1684 ()
1685 }
1686 }
1687 };
1688 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1689 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1694 #[derive(Clone)]
1695 pub struct UUPSUnsupportedProxiableUUID {
1696 #[allow(missing_docs)]
1697 pub slot: alloy::sol_types::private::FixedBytes<32>,
1698 }
1699 #[allow(
1700 non_camel_case_types,
1701 non_snake_case,
1702 clippy::pub_underscore_fields,
1703 clippy::style
1704 )]
1705 const _: () = {
1706 use alloy::sol_types as alloy_sol_types;
1707 #[doc(hidden)]
1708 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1709 #[doc(hidden)]
1710 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1711 #[cfg(test)]
1712 #[allow(dead_code, unreachable_patterns)]
1713 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1714 match _t {
1715 alloy_sol_types::private::AssertTypeEq::<
1716 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1717 >(_) => {},
1718 }
1719 }
1720 #[automatically_derived]
1721 #[doc(hidden)]
1722 impl ::core::convert::From<UUPSUnsupportedProxiableUUID> for UnderlyingRustTuple<'_> {
1723 fn from(value: UUPSUnsupportedProxiableUUID) -> Self {
1724 (value.slot,)
1725 }
1726 }
1727 #[automatically_derived]
1728 #[doc(hidden)]
1729 impl ::core::convert::From<UnderlyingRustTuple<'_>> for UUPSUnsupportedProxiableUUID {
1730 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1731 Self { slot: tuple.0 }
1732 }
1733 }
1734 #[automatically_derived]
1735 impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID {
1736 type Parameters<'a> = UnderlyingSolTuple<'a>;
1737 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1738 const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)";
1739 const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8];
1740 #[inline]
1741 fn new<'a>(
1742 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1743 ) -> Self {
1744 tuple.into()
1745 }
1746 #[inline]
1747 fn tokenize(&self) -> Self::Token<'_> {
1748 (
1749 <alloy::sol_types::sol_data::FixedBytes<
1750 32,
1751 > as alloy_sol_types::SolType>::tokenize(&self.slot),
1752 )
1753 }
1754 }
1755 };
1756 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1757 #[allow(
1762 non_camel_case_types,
1763 non_snake_case,
1764 clippy::pub_underscore_fields,
1765 clippy::style
1766 )]
1767 #[derive(Clone)]
1768 pub struct Approval {
1769 #[allow(missing_docs)]
1770 pub owner: alloy::sol_types::private::Address,
1771 #[allow(missing_docs)]
1772 pub spender: alloy::sol_types::private::Address,
1773 #[allow(missing_docs)]
1774 pub value: alloy::sol_types::private::primitives::aliases::U256,
1775 }
1776 #[allow(
1777 non_camel_case_types,
1778 non_snake_case,
1779 clippy::pub_underscore_fields,
1780 clippy::style
1781 )]
1782 const _: () = {
1783 use alloy::sol_types as alloy_sol_types;
1784 #[automatically_derived]
1785 impl alloy_sol_types::SolEvent for Approval {
1786 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1787 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1788 type TopicList = (
1789 alloy_sol_types::sol_data::FixedBytes<32>,
1790 alloy::sol_types::sol_data::Address,
1791 alloy::sol_types::sol_data::Address,
1792 );
1793 const SIGNATURE: &'static str = "Approval(address,address,uint256)";
1794 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
1795 alloy_sol_types::private::B256::new([
1796 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
1797 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
1798 91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
1799 ]);
1800 const ANONYMOUS: bool = false;
1801 #[allow(unused_variables)]
1802 #[inline]
1803 fn new(
1804 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1805 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1806 ) -> Self {
1807 Self {
1808 owner: topics.1,
1809 spender: topics.2,
1810 value: data.0,
1811 }
1812 }
1813 #[inline]
1814 fn check_signature(
1815 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1816 ) -> alloy_sol_types::Result<()> {
1817 if topics.0 != Self::SIGNATURE_HASH {
1818 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
1819 Self::SIGNATURE,
1820 topics.0,
1821 Self::SIGNATURE_HASH,
1822 ));
1823 }
1824 Ok(())
1825 }
1826 #[inline]
1827 fn tokenize_body(&self) -> Self::DataToken<'_> {
1828 (
1829 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1830 &self.value,
1831 ),
1832 )
1833 }
1834 #[inline]
1835 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1836 (
1837 Self::SIGNATURE_HASH.into(),
1838 self.owner.clone(),
1839 self.spender.clone(),
1840 )
1841 }
1842 #[inline]
1843 fn encode_topics_raw(
1844 &self,
1845 out: &mut [alloy_sol_types::abi::token::WordToken],
1846 ) -> alloy_sol_types::Result<()> {
1847 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1848 return Err(alloy_sol_types::Error::Overrun);
1849 }
1850 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
1851 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1852 &self.owner,
1853 );
1854 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1855 &self.spender,
1856 );
1857 Ok(())
1858 }
1859 }
1860 #[automatically_derived]
1861 impl alloy_sol_types::private::IntoLogData for Approval {
1862 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1863 From::from(self)
1864 }
1865 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1866 From::from(&self)
1867 }
1868 }
1869 #[automatically_derived]
1870 impl From<&Approval> for alloy_sol_types::private::LogData {
1871 #[inline]
1872 fn from(this: &Approval) -> alloy_sol_types::private::LogData {
1873 alloy_sol_types::SolEvent::encode_log_data(this)
1874 }
1875 }
1876 };
1877 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1878 #[allow(
1883 non_camel_case_types,
1884 non_snake_case,
1885 clippy::pub_underscore_fields,
1886 clippy::style
1887 )]
1888 #[derive(Clone)]
1889 pub struct Initialized {
1890 #[allow(missing_docs)]
1891 pub version: u64,
1892 }
1893 #[allow(
1894 non_camel_case_types,
1895 non_snake_case,
1896 clippy::pub_underscore_fields,
1897 clippy::style
1898 )]
1899 const _: () = {
1900 use alloy::sol_types as alloy_sol_types;
1901 #[automatically_derived]
1902 impl alloy_sol_types::SolEvent for Initialized {
1903 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
1904 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1905 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1906 const SIGNATURE: &'static str = "Initialized(uint64)";
1907 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
1908 alloy_sol_types::private::B256::new([
1909 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8,
1910 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8,
1911 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
1912 ]);
1913 const ANONYMOUS: bool = false;
1914 #[allow(unused_variables)]
1915 #[inline]
1916 fn new(
1917 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1918 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1919 ) -> Self {
1920 Self { version: data.0 }
1921 }
1922 #[inline]
1923 fn check_signature(
1924 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1925 ) -> alloy_sol_types::Result<()> {
1926 if topics.0 != Self::SIGNATURE_HASH {
1927 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
1928 Self::SIGNATURE,
1929 topics.0,
1930 Self::SIGNATURE_HASH,
1931 ));
1932 }
1933 Ok(())
1934 }
1935 #[inline]
1936 fn tokenize_body(&self) -> Self::DataToken<'_> {
1937 (
1938 <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
1939 &self.version,
1940 ),
1941 )
1942 }
1943 #[inline]
1944 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1945 (Self::SIGNATURE_HASH.into(),)
1946 }
1947 #[inline]
1948 fn encode_topics_raw(
1949 &self,
1950 out: &mut [alloy_sol_types::abi::token::WordToken],
1951 ) -> alloy_sol_types::Result<()> {
1952 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1953 return Err(alloy_sol_types::Error::Overrun);
1954 }
1955 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
1956 Ok(())
1957 }
1958 }
1959 #[automatically_derived]
1960 impl alloy_sol_types::private::IntoLogData for Initialized {
1961 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1962 From::from(self)
1963 }
1964 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1965 From::from(&self)
1966 }
1967 }
1968 #[automatically_derived]
1969 impl From<&Initialized> for alloy_sol_types::private::LogData {
1970 #[inline]
1971 fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
1972 alloy_sol_types::SolEvent::encode_log_data(this)
1973 }
1974 }
1975 };
1976 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1977 #[allow(
1982 non_camel_case_types,
1983 non_snake_case,
1984 clippy::pub_underscore_fields,
1985 clippy::style
1986 )]
1987 #[derive(Clone)]
1988 pub struct OwnershipTransferred {
1989 #[allow(missing_docs)]
1990 pub previousOwner: alloy::sol_types::private::Address,
1991 #[allow(missing_docs)]
1992 pub newOwner: alloy::sol_types::private::Address,
1993 }
1994 #[allow(
1995 non_camel_case_types,
1996 non_snake_case,
1997 clippy::pub_underscore_fields,
1998 clippy::style
1999 )]
2000 const _: () = {
2001 use alloy::sol_types as alloy_sol_types;
2002 #[automatically_derived]
2003 impl alloy_sol_types::SolEvent for OwnershipTransferred {
2004 type DataTuple<'a> = ();
2005 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2006 type TopicList = (
2007 alloy_sol_types::sol_data::FixedBytes<32>,
2008 alloy::sol_types::sol_data::Address,
2009 alloy::sol_types::sol_data::Address,
2010 );
2011 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
2012 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2013 alloy_sol_types::private::B256::new([
2014 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8,
2015 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8,
2016 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
2017 ]);
2018 const ANONYMOUS: bool = false;
2019 #[allow(unused_variables)]
2020 #[inline]
2021 fn new(
2022 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2023 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2024 ) -> Self {
2025 Self {
2026 previousOwner: topics.1,
2027 newOwner: topics.2,
2028 }
2029 }
2030 #[inline]
2031 fn check_signature(
2032 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2033 ) -> alloy_sol_types::Result<()> {
2034 if topics.0 != Self::SIGNATURE_HASH {
2035 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2036 Self::SIGNATURE,
2037 topics.0,
2038 Self::SIGNATURE_HASH,
2039 ));
2040 }
2041 Ok(())
2042 }
2043 #[inline]
2044 fn tokenize_body(&self) -> Self::DataToken<'_> {
2045 ()
2046 }
2047 #[inline]
2048 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2049 (
2050 Self::SIGNATURE_HASH.into(),
2051 self.previousOwner.clone(),
2052 self.newOwner.clone(),
2053 )
2054 }
2055 #[inline]
2056 fn encode_topics_raw(
2057 &self,
2058 out: &mut [alloy_sol_types::abi::token::WordToken],
2059 ) -> alloy_sol_types::Result<()> {
2060 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2061 return Err(alloy_sol_types::Error::Overrun);
2062 }
2063 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2064 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2065 &self.previousOwner,
2066 );
2067 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2068 &self.newOwner,
2069 );
2070 Ok(())
2071 }
2072 }
2073 #[automatically_derived]
2074 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
2075 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2076 From::from(self)
2077 }
2078 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2079 From::from(&self)
2080 }
2081 }
2082 #[automatically_derived]
2083 impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
2084 #[inline]
2085 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
2086 alloy_sol_types::SolEvent::encode_log_data(this)
2087 }
2088 }
2089 };
2090 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2091 #[allow(
2096 non_camel_case_types,
2097 non_snake_case,
2098 clippy::pub_underscore_fields,
2099 clippy::style
2100 )]
2101 #[derive(Clone)]
2102 pub struct Transfer {
2103 #[allow(missing_docs)]
2104 pub from: alloy::sol_types::private::Address,
2105 #[allow(missing_docs)]
2106 pub to: alloy::sol_types::private::Address,
2107 #[allow(missing_docs)]
2108 pub value: alloy::sol_types::private::primitives::aliases::U256,
2109 }
2110 #[allow(
2111 non_camel_case_types,
2112 non_snake_case,
2113 clippy::pub_underscore_fields,
2114 clippy::style
2115 )]
2116 const _: () = {
2117 use alloy::sol_types as alloy_sol_types;
2118 #[automatically_derived]
2119 impl alloy_sol_types::SolEvent for Transfer {
2120 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2121 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2122 type TopicList = (
2123 alloy_sol_types::sol_data::FixedBytes<32>,
2124 alloy::sol_types::sol_data::Address,
2125 alloy::sol_types::sol_data::Address,
2126 );
2127 const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
2128 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2129 alloy_sol_types::private::B256::new([
2130 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
2131 104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
2132 161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
2133 ]);
2134 const ANONYMOUS: bool = false;
2135 #[allow(unused_variables)]
2136 #[inline]
2137 fn new(
2138 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2139 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2140 ) -> Self {
2141 Self {
2142 from: topics.1,
2143 to: topics.2,
2144 value: data.0,
2145 }
2146 }
2147 #[inline]
2148 fn check_signature(
2149 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2150 ) -> alloy_sol_types::Result<()> {
2151 if topics.0 != Self::SIGNATURE_HASH {
2152 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2153 Self::SIGNATURE,
2154 topics.0,
2155 Self::SIGNATURE_HASH,
2156 ));
2157 }
2158 Ok(())
2159 }
2160 #[inline]
2161 fn tokenize_body(&self) -> Self::DataToken<'_> {
2162 (
2163 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
2164 &self.value,
2165 ),
2166 )
2167 }
2168 #[inline]
2169 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2170 (
2171 Self::SIGNATURE_HASH.into(),
2172 self.from.clone(),
2173 self.to.clone(),
2174 )
2175 }
2176 #[inline]
2177 fn encode_topics_raw(
2178 &self,
2179 out: &mut [alloy_sol_types::abi::token::WordToken],
2180 ) -> alloy_sol_types::Result<()> {
2181 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2182 return Err(alloy_sol_types::Error::Overrun);
2183 }
2184 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2185 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2186 &self.from,
2187 );
2188 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2189 &self.to,
2190 );
2191 Ok(())
2192 }
2193 }
2194 #[automatically_derived]
2195 impl alloy_sol_types::private::IntoLogData for Transfer {
2196 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2197 From::from(self)
2198 }
2199 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2200 From::from(&self)
2201 }
2202 }
2203 #[automatically_derived]
2204 impl From<&Transfer> for alloy_sol_types::private::LogData {
2205 #[inline]
2206 fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
2207 alloy_sol_types::SolEvent::encode_log_data(this)
2208 }
2209 }
2210 };
2211 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2212 #[allow(
2217 non_camel_case_types,
2218 non_snake_case,
2219 clippy::pub_underscore_fields,
2220 clippy::style
2221 )]
2222 #[derive(Clone)]
2223 pub struct Upgrade {
2224 #[allow(missing_docs)]
2225 pub implementation: alloy::sol_types::private::Address,
2226 }
2227 #[allow(
2228 non_camel_case_types,
2229 non_snake_case,
2230 clippy::pub_underscore_fields,
2231 clippy::style
2232 )]
2233 const _: () = {
2234 use alloy::sol_types as alloy_sol_types;
2235 #[automatically_derived]
2236 impl alloy_sol_types::SolEvent for Upgrade {
2237 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
2238 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2239 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
2240 const SIGNATURE: &'static str = "Upgrade(address)";
2241 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2242 alloy_sol_types::private::B256::new([
2243 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8,
2244 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8,
2245 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
2246 ]);
2247 const ANONYMOUS: bool = false;
2248 #[allow(unused_variables)]
2249 #[inline]
2250 fn new(
2251 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2252 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2253 ) -> Self {
2254 Self {
2255 implementation: data.0,
2256 }
2257 }
2258 #[inline]
2259 fn check_signature(
2260 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2261 ) -> alloy_sol_types::Result<()> {
2262 if topics.0 != Self::SIGNATURE_HASH {
2263 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2264 Self::SIGNATURE,
2265 topics.0,
2266 Self::SIGNATURE_HASH,
2267 ));
2268 }
2269 Ok(())
2270 }
2271 #[inline]
2272 fn tokenize_body(&self) -> Self::DataToken<'_> {
2273 (
2274 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2275 &self.implementation,
2276 ),
2277 )
2278 }
2279 #[inline]
2280 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2281 (Self::SIGNATURE_HASH.into(),)
2282 }
2283 #[inline]
2284 fn encode_topics_raw(
2285 &self,
2286 out: &mut [alloy_sol_types::abi::token::WordToken],
2287 ) -> alloy_sol_types::Result<()> {
2288 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2289 return Err(alloy_sol_types::Error::Overrun);
2290 }
2291 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2292 Ok(())
2293 }
2294 }
2295 #[automatically_derived]
2296 impl alloy_sol_types::private::IntoLogData for Upgrade {
2297 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2298 From::from(self)
2299 }
2300 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2301 From::from(&self)
2302 }
2303 }
2304 #[automatically_derived]
2305 impl From<&Upgrade> for alloy_sol_types::private::LogData {
2306 #[inline]
2307 fn from(this: &Upgrade) -> alloy_sol_types::private::LogData {
2308 alloy_sol_types::SolEvent::encode_log_data(this)
2309 }
2310 }
2311 };
2312 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2313 #[allow(
2318 non_camel_case_types,
2319 non_snake_case,
2320 clippy::pub_underscore_fields,
2321 clippy::style
2322 )]
2323 #[derive(Clone)]
2324 pub struct Upgraded {
2325 #[allow(missing_docs)]
2326 pub implementation: alloy::sol_types::private::Address,
2327 }
2328 #[allow(
2329 non_camel_case_types,
2330 non_snake_case,
2331 clippy::pub_underscore_fields,
2332 clippy::style
2333 )]
2334 const _: () = {
2335 use alloy::sol_types as alloy_sol_types;
2336 #[automatically_derived]
2337 impl alloy_sol_types::SolEvent for Upgraded {
2338 type DataTuple<'a> = ();
2339 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2340 type TopicList = (
2341 alloy_sol_types::sol_data::FixedBytes<32>,
2342 alloy::sol_types::sol_data::Address,
2343 );
2344 const SIGNATURE: &'static str = "Upgraded(address)";
2345 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2346 alloy_sol_types::private::B256::new([
2347 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
2348 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8,
2349 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
2350 ]);
2351 const ANONYMOUS: bool = false;
2352 #[allow(unused_variables)]
2353 #[inline]
2354 fn new(
2355 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2356 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2357 ) -> Self {
2358 Self {
2359 implementation: topics.1,
2360 }
2361 }
2362 #[inline]
2363 fn check_signature(
2364 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2365 ) -> alloy_sol_types::Result<()> {
2366 if topics.0 != Self::SIGNATURE_HASH {
2367 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2368 Self::SIGNATURE,
2369 topics.0,
2370 Self::SIGNATURE_HASH,
2371 ));
2372 }
2373 Ok(())
2374 }
2375 #[inline]
2376 fn tokenize_body(&self) -> Self::DataToken<'_> {
2377 ()
2378 }
2379 #[inline]
2380 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2381 (Self::SIGNATURE_HASH.into(), self.implementation.clone())
2382 }
2383 #[inline]
2384 fn encode_topics_raw(
2385 &self,
2386 out: &mut [alloy_sol_types::abi::token::WordToken],
2387 ) -> alloy_sol_types::Result<()> {
2388 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2389 return Err(alloy_sol_types::Error::Overrun);
2390 }
2391 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2392 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2393 &self.implementation,
2394 );
2395 Ok(())
2396 }
2397 }
2398 #[automatically_derived]
2399 impl alloy_sol_types::private::IntoLogData for Upgraded {
2400 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2401 From::from(self)
2402 }
2403 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2404 From::from(&self)
2405 }
2406 }
2407 #[automatically_derived]
2408 impl From<&Upgraded> for alloy_sol_types::private::LogData {
2409 #[inline]
2410 fn from(this: &Upgraded) -> alloy_sol_types::private::LogData {
2411 alloy_sol_types::SolEvent::encode_log_data(this)
2412 }
2413 }
2414 };
2415 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2420 #[derive(Clone)]
2421 pub struct constructorCall {}
2422 const _: () = {
2423 use alloy::sol_types as alloy_sol_types;
2424 {
2425 #[doc(hidden)]
2426 type UnderlyingSolTuple<'a> = ();
2427 #[doc(hidden)]
2428 type UnderlyingRustTuple<'a> = ();
2429 #[cfg(test)]
2430 #[allow(dead_code, unreachable_patterns)]
2431 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2432 match _t {
2433 alloy_sol_types::private::AssertTypeEq::<
2434 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2435 >(_) => {},
2436 }
2437 }
2438 #[automatically_derived]
2439 #[doc(hidden)]
2440 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
2441 fn from(value: constructorCall) -> Self {
2442 ()
2443 }
2444 }
2445 #[automatically_derived]
2446 #[doc(hidden)]
2447 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
2448 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2449 Self {}
2450 }
2451 }
2452 }
2453 #[automatically_derived]
2454 impl alloy_sol_types::SolConstructor for constructorCall {
2455 type Parameters<'a> = ();
2456 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2457 #[inline]
2458 fn new<'a>(
2459 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2460 ) -> Self {
2461 tuple.into()
2462 }
2463 #[inline]
2464 fn tokenize(&self) -> Self::Token<'_> {
2465 ()
2466 }
2467 }
2468 };
2469 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2470 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2475 #[derive(Clone)]
2476 pub struct UPGRADE_INTERFACE_VERSIONCall {}
2477 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2478 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2480 #[derive(Clone)]
2481 pub struct UPGRADE_INTERFACE_VERSIONReturn {
2482 #[allow(missing_docs)]
2483 pub _0: alloy::sol_types::private::String,
2484 }
2485 #[allow(
2486 non_camel_case_types,
2487 non_snake_case,
2488 clippy::pub_underscore_fields,
2489 clippy::style
2490 )]
2491 const _: () = {
2492 use alloy::sol_types as alloy_sol_types;
2493 {
2494 #[doc(hidden)]
2495 type UnderlyingSolTuple<'a> = ();
2496 #[doc(hidden)]
2497 type UnderlyingRustTuple<'a> = ();
2498 #[cfg(test)]
2499 #[allow(dead_code, unreachable_patterns)]
2500 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2501 match _t {
2502 alloy_sol_types::private::AssertTypeEq::<
2503 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2504 >(_) => {},
2505 }
2506 }
2507 #[automatically_derived]
2508 #[doc(hidden)]
2509 impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONCall> for UnderlyingRustTuple<'_> {
2510 fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self {
2511 ()
2512 }
2513 }
2514 #[automatically_derived]
2515 #[doc(hidden)]
2516 impl ::core::convert::From<UnderlyingRustTuple<'_>> for UPGRADE_INTERFACE_VERSIONCall {
2517 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2518 Self {}
2519 }
2520 }
2521 }
2522 {
2523 #[doc(hidden)]
2524 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2525 #[doc(hidden)]
2526 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2527 #[cfg(test)]
2528 #[allow(dead_code, unreachable_patterns)]
2529 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2530 match _t {
2531 alloy_sol_types::private::AssertTypeEq::<
2532 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2533 >(_) => {},
2534 }
2535 }
2536 #[automatically_derived]
2537 #[doc(hidden)]
2538 impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONReturn> for UnderlyingRustTuple<'_> {
2539 fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self {
2540 (value._0,)
2541 }
2542 }
2543 #[automatically_derived]
2544 #[doc(hidden)]
2545 impl ::core::convert::From<UnderlyingRustTuple<'_>> for UPGRADE_INTERFACE_VERSIONReturn {
2546 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2547 Self { _0: tuple.0 }
2548 }
2549 }
2550 }
2551 #[automatically_derived]
2552 impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall {
2553 type Parameters<'a> = ();
2554 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2555 type Return = UPGRADE_INTERFACE_VERSIONReturn;
2556 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2557 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2558 const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()";
2559 const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8];
2560 #[inline]
2561 fn new<'a>(
2562 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2563 ) -> Self {
2564 tuple.into()
2565 }
2566 #[inline]
2567 fn tokenize(&self) -> Self::Token<'_> {
2568 ()
2569 }
2570 #[inline]
2571 fn abi_decode_returns(
2572 data: &[u8],
2573 validate: bool,
2574 ) -> alloy_sol_types::Result<Self::Return> {
2575 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
2576 data, validate,
2577 )
2578 .map(Into::into)
2579 }
2580 }
2581 };
2582 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2583 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2588 #[derive(Clone)]
2589 pub struct allowanceCall {
2590 #[allow(missing_docs)]
2591 pub owner: alloy::sol_types::private::Address,
2592 #[allow(missing_docs)]
2593 pub spender: alloy::sol_types::private::Address,
2594 }
2595 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2596 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2598 #[derive(Clone)]
2599 pub struct allowanceReturn {
2600 #[allow(missing_docs)]
2601 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2602 }
2603 #[allow(
2604 non_camel_case_types,
2605 non_snake_case,
2606 clippy::pub_underscore_fields,
2607 clippy::style
2608 )]
2609 const _: () = {
2610 use alloy::sol_types as alloy_sol_types;
2611 {
2612 #[doc(hidden)]
2613 type UnderlyingSolTuple<'a> = (
2614 alloy::sol_types::sol_data::Address,
2615 alloy::sol_types::sol_data::Address,
2616 );
2617 #[doc(hidden)]
2618 type UnderlyingRustTuple<'a> = (
2619 alloy::sol_types::private::Address,
2620 alloy::sol_types::private::Address,
2621 );
2622 #[cfg(test)]
2623 #[allow(dead_code, unreachable_patterns)]
2624 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2625 match _t {
2626 alloy_sol_types::private::AssertTypeEq::<
2627 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2628 >(_) => {},
2629 }
2630 }
2631 #[automatically_derived]
2632 #[doc(hidden)]
2633 impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
2634 fn from(value: allowanceCall) -> Self {
2635 (value.owner, value.spender)
2636 }
2637 }
2638 #[automatically_derived]
2639 #[doc(hidden)]
2640 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
2641 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2642 Self {
2643 owner: tuple.0,
2644 spender: tuple.1,
2645 }
2646 }
2647 }
2648 }
2649 {
2650 #[doc(hidden)]
2651 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2652 #[doc(hidden)]
2653 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
2654 #[cfg(test)]
2655 #[allow(dead_code, unreachable_patterns)]
2656 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2657 match _t {
2658 alloy_sol_types::private::AssertTypeEq::<
2659 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2660 >(_) => {},
2661 }
2662 }
2663 #[automatically_derived]
2664 #[doc(hidden)]
2665 impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
2666 fn from(value: allowanceReturn) -> Self {
2667 (value._0,)
2668 }
2669 }
2670 #[automatically_derived]
2671 #[doc(hidden)]
2672 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
2673 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2674 Self { _0: tuple.0 }
2675 }
2676 }
2677 }
2678 #[automatically_derived]
2679 impl alloy_sol_types::SolCall for allowanceCall {
2680 type Parameters<'a> = (
2681 alloy::sol_types::sol_data::Address,
2682 alloy::sol_types::sol_data::Address,
2683 );
2684 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2685 type Return = allowanceReturn;
2686 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2687 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2688 const SIGNATURE: &'static str = "allowance(address,address)";
2689 const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
2690 #[inline]
2691 fn new<'a>(
2692 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2693 ) -> Self {
2694 tuple.into()
2695 }
2696 #[inline]
2697 fn tokenize(&self) -> Self::Token<'_> {
2698 (
2699 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2700 &self.owner,
2701 ),
2702 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2703 &self.spender,
2704 ),
2705 )
2706 }
2707 #[inline]
2708 fn abi_decode_returns(
2709 data: &[u8],
2710 validate: bool,
2711 ) -> alloy_sol_types::Result<Self::Return> {
2712 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
2713 data, validate,
2714 )
2715 .map(Into::into)
2716 }
2717 }
2718 };
2719 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2720 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2725 #[derive(Clone)]
2726 pub struct approveCall {
2727 #[allow(missing_docs)]
2728 pub spender: alloy::sol_types::private::Address,
2729 #[allow(missing_docs)]
2730 pub value: alloy::sol_types::private::primitives::aliases::U256,
2731 }
2732 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2733 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2735 #[derive(Clone)]
2736 pub struct approveReturn {
2737 #[allow(missing_docs)]
2738 pub _0: bool,
2739 }
2740 #[allow(
2741 non_camel_case_types,
2742 non_snake_case,
2743 clippy::pub_underscore_fields,
2744 clippy::style
2745 )]
2746 const _: () = {
2747 use alloy::sol_types as alloy_sol_types;
2748 {
2749 #[doc(hidden)]
2750 type UnderlyingSolTuple<'a> = (
2751 alloy::sol_types::sol_data::Address,
2752 alloy::sol_types::sol_data::Uint<256>,
2753 );
2754 #[doc(hidden)]
2755 type UnderlyingRustTuple<'a> = (
2756 alloy::sol_types::private::Address,
2757 alloy::sol_types::private::primitives::aliases::U256,
2758 );
2759 #[cfg(test)]
2760 #[allow(dead_code, unreachable_patterns)]
2761 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2762 match _t {
2763 alloy_sol_types::private::AssertTypeEq::<
2764 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2765 >(_) => {},
2766 }
2767 }
2768 #[automatically_derived]
2769 #[doc(hidden)]
2770 impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
2771 fn from(value: approveCall) -> Self {
2772 (value.spender, value.value)
2773 }
2774 }
2775 #[automatically_derived]
2776 #[doc(hidden)]
2777 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
2778 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2779 Self {
2780 spender: tuple.0,
2781 value: tuple.1,
2782 }
2783 }
2784 }
2785 }
2786 {
2787 #[doc(hidden)]
2788 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2789 #[doc(hidden)]
2790 type UnderlyingRustTuple<'a> = (bool,);
2791 #[cfg(test)]
2792 #[allow(dead_code, unreachable_patterns)]
2793 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2794 match _t {
2795 alloy_sol_types::private::AssertTypeEq::<
2796 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2797 >(_) => {},
2798 }
2799 }
2800 #[automatically_derived]
2801 #[doc(hidden)]
2802 impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
2803 fn from(value: approveReturn) -> Self {
2804 (value._0,)
2805 }
2806 }
2807 #[automatically_derived]
2808 #[doc(hidden)]
2809 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
2810 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2811 Self { _0: tuple.0 }
2812 }
2813 }
2814 }
2815 #[automatically_derived]
2816 impl alloy_sol_types::SolCall for approveCall {
2817 type Parameters<'a> = (
2818 alloy::sol_types::sol_data::Address,
2819 alloy::sol_types::sol_data::Uint<256>,
2820 );
2821 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2822 type Return = approveReturn;
2823 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2824 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2825 const SIGNATURE: &'static str = "approve(address,uint256)";
2826 const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
2827 #[inline]
2828 fn new<'a>(
2829 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2830 ) -> Self {
2831 tuple.into()
2832 }
2833 #[inline]
2834 fn tokenize(&self) -> Self::Token<'_> {
2835 (
2836 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2837 &self.spender,
2838 ),
2839 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
2840 &self.value,
2841 ),
2842 )
2843 }
2844 #[inline]
2845 fn abi_decode_returns(
2846 data: &[u8],
2847 validate: bool,
2848 ) -> alloy_sol_types::Result<Self::Return> {
2849 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
2850 data, validate,
2851 )
2852 .map(Into::into)
2853 }
2854 }
2855 };
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 balanceOfCall {
2864 #[allow(missing_docs)]
2865 pub account: alloy::sol_types::private::Address,
2866 }
2867 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2868 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2870 #[derive(Clone)]
2871 pub struct balanceOfReturn {
2872 #[allow(missing_docs)]
2873 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2874 }
2875 #[allow(
2876 non_camel_case_types,
2877 non_snake_case,
2878 clippy::pub_underscore_fields,
2879 clippy::style
2880 )]
2881 const _: () = {
2882 use alloy::sol_types as alloy_sol_types;
2883 {
2884 #[doc(hidden)]
2885 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2886 #[doc(hidden)]
2887 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2888 #[cfg(test)]
2889 #[allow(dead_code, unreachable_patterns)]
2890 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2891 match _t {
2892 alloy_sol_types::private::AssertTypeEq::<
2893 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2894 >(_) => {},
2895 }
2896 }
2897 #[automatically_derived]
2898 #[doc(hidden)]
2899 impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
2900 fn from(value: balanceOfCall) -> Self {
2901 (value.account,)
2902 }
2903 }
2904 #[automatically_derived]
2905 #[doc(hidden)]
2906 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
2907 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2908 Self { account: tuple.0 }
2909 }
2910 }
2911 }
2912 {
2913 #[doc(hidden)]
2914 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2915 #[doc(hidden)]
2916 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
2917 #[cfg(test)]
2918 #[allow(dead_code, unreachable_patterns)]
2919 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2920 match _t {
2921 alloy_sol_types::private::AssertTypeEq::<
2922 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2923 >(_) => {},
2924 }
2925 }
2926 #[automatically_derived]
2927 #[doc(hidden)]
2928 impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
2929 fn from(value: balanceOfReturn) -> Self {
2930 (value._0,)
2931 }
2932 }
2933 #[automatically_derived]
2934 #[doc(hidden)]
2935 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
2936 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2937 Self { _0: tuple.0 }
2938 }
2939 }
2940 }
2941 #[automatically_derived]
2942 impl alloy_sol_types::SolCall for balanceOfCall {
2943 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2944 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2945 type Return = balanceOfReturn;
2946 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2947 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2948 const SIGNATURE: &'static str = "balanceOf(address)";
2949 const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
2950 #[inline]
2951 fn new<'a>(
2952 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2953 ) -> Self {
2954 tuple.into()
2955 }
2956 #[inline]
2957 fn tokenize(&self) -> Self::Token<'_> {
2958 (
2959 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2960 &self.account,
2961 ),
2962 )
2963 }
2964 #[inline]
2965 fn abi_decode_returns(
2966 data: &[u8],
2967 validate: bool,
2968 ) -> alloy_sol_types::Result<Self::Return> {
2969 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
2970 data, validate,
2971 )
2972 .map(Into::into)
2973 }
2974 }
2975 };
2976 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2977 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2982 #[derive(Clone)]
2983 pub struct decimalsCall {}
2984 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2985 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2987 #[derive(Clone)]
2988 pub struct decimalsReturn {
2989 #[allow(missing_docs)]
2990 pub _0: u8,
2991 }
2992 #[allow(
2993 non_camel_case_types,
2994 non_snake_case,
2995 clippy::pub_underscore_fields,
2996 clippy::style
2997 )]
2998 const _: () = {
2999 use alloy::sol_types as alloy_sol_types;
3000 {
3001 #[doc(hidden)]
3002 type UnderlyingSolTuple<'a> = ();
3003 #[doc(hidden)]
3004 type UnderlyingRustTuple<'a> = ();
3005 #[cfg(test)]
3006 #[allow(dead_code, unreachable_patterns)]
3007 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3008 match _t {
3009 alloy_sol_types::private::AssertTypeEq::<
3010 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3011 >(_) => {},
3012 }
3013 }
3014 #[automatically_derived]
3015 #[doc(hidden)]
3016 impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
3017 fn from(value: decimalsCall) -> Self {
3018 ()
3019 }
3020 }
3021 #[automatically_derived]
3022 #[doc(hidden)]
3023 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
3024 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3025 Self {}
3026 }
3027 }
3028 }
3029 {
3030 #[doc(hidden)]
3031 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3032 #[doc(hidden)]
3033 type UnderlyingRustTuple<'a> = (u8,);
3034 #[cfg(test)]
3035 #[allow(dead_code, unreachable_patterns)]
3036 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3037 match _t {
3038 alloy_sol_types::private::AssertTypeEq::<
3039 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3040 >(_) => {},
3041 }
3042 }
3043 #[automatically_derived]
3044 #[doc(hidden)]
3045 impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
3046 fn from(value: decimalsReturn) -> Self {
3047 (value._0,)
3048 }
3049 }
3050 #[automatically_derived]
3051 #[doc(hidden)]
3052 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
3053 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3054 Self { _0: tuple.0 }
3055 }
3056 }
3057 }
3058 #[automatically_derived]
3059 impl alloy_sol_types::SolCall for decimalsCall {
3060 type Parameters<'a> = ();
3061 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3062 type Return = decimalsReturn;
3063 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3064 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3065 const SIGNATURE: &'static str = "decimals()";
3066 const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
3067 #[inline]
3068 fn new<'a>(
3069 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3070 ) -> Self {
3071 tuple.into()
3072 }
3073 #[inline]
3074 fn tokenize(&self) -> Self::Token<'_> {
3075 ()
3076 }
3077 #[inline]
3078 fn abi_decode_returns(
3079 data: &[u8],
3080 validate: bool,
3081 ) -> alloy_sol_types::Result<Self::Return> {
3082 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3083 data, validate,
3084 )
3085 .map(Into::into)
3086 }
3087 }
3088 };
3089 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3090 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3095 #[derive(Clone)]
3096 pub struct getVersionCall {}
3097 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3098 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3100 #[derive(Clone)]
3101 pub struct getVersionReturn {
3102 #[allow(missing_docs)]
3103 pub majorVersion: u8,
3104 #[allow(missing_docs)]
3105 pub minorVersion: u8,
3106 #[allow(missing_docs)]
3107 pub patchVersion: u8,
3108 }
3109 #[allow(
3110 non_camel_case_types,
3111 non_snake_case,
3112 clippy::pub_underscore_fields,
3113 clippy::style
3114 )]
3115 const _: () = {
3116 use alloy::sol_types as alloy_sol_types;
3117 {
3118 #[doc(hidden)]
3119 type UnderlyingSolTuple<'a> = ();
3120 #[doc(hidden)]
3121 type UnderlyingRustTuple<'a> = ();
3122 #[cfg(test)]
3123 #[allow(dead_code, unreachable_patterns)]
3124 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3125 match _t {
3126 alloy_sol_types::private::AssertTypeEq::<
3127 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3128 >(_) => {},
3129 }
3130 }
3131 #[automatically_derived]
3132 #[doc(hidden)]
3133 impl ::core::convert::From<getVersionCall> for UnderlyingRustTuple<'_> {
3134 fn from(value: getVersionCall) -> Self {
3135 ()
3136 }
3137 }
3138 #[automatically_derived]
3139 #[doc(hidden)]
3140 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionCall {
3141 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3142 Self {}
3143 }
3144 }
3145 }
3146 {
3147 #[doc(hidden)]
3148 type UnderlyingSolTuple<'a> = (
3149 alloy::sol_types::sol_data::Uint<8>,
3150 alloy::sol_types::sol_data::Uint<8>,
3151 alloy::sol_types::sol_data::Uint<8>,
3152 );
3153 #[doc(hidden)]
3154 type UnderlyingRustTuple<'a> = (u8, u8, u8);
3155 #[cfg(test)]
3156 #[allow(dead_code, unreachable_patterns)]
3157 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3158 match _t {
3159 alloy_sol_types::private::AssertTypeEq::<
3160 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3161 >(_) => {},
3162 }
3163 }
3164 #[automatically_derived]
3165 #[doc(hidden)]
3166 impl ::core::convert::From<getVersionReturn> for UnderlyingRustTuple<'_> {
3167 fn from(value: getVersionReturn) -> Self {
3168 (value.majorVersion, value.minorVersion, value.patchVersion)
3169 }
3170 }
3171 #[automatically_derived]
3172 #[doc(hidden)]
3173 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionReturn {
3174 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3175 Self {
3176 majorVersion: tuple.0,
3177 minorVersion: tuple.1,
3178 patchVersion: tuple.2,
3179 }
3180 }
3181 }
3182 }
3183 #[automatically_derived]
3184 impl alloy_sol_types::SolCall for getVersionCall {
3185 type Parameters<'a> = ();
3186 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3187 type Return = getVersionReturn;
3188 type ReturnTuple<'a> = (
3189 alloy::sol_types::sol_data::Uint<8>,
3190 alloy::sol_types::sol_data::Uint<8>,
3191 alloy::sol_types::sol_data::Uint<8>,
3192 );
3193 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3194 const SIGNATURE: &'static str = "getVersion()";
3195 const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8];
3196 #[inline]
3197 fn new<'a>(
3198 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3199 ) -> Self {
3200 tuple.into()
3201 }
3202 #[inline]
3203 fn tokenize(&self) -> Self::Token<'_> {
3204 ()
3205 }
3206 #[inline]
3207 fn abi_decode_returns(
3208 data: &[u8],
3209 validate: bool,
3210 ) -> alloy_sol_types::Result<Self::Return> {
3211 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3212 data, validate,
3213 )
3214 .map(Into::into)
3215 }
3216 }
3217 };
3218 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3219 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3224 #[derive(Clone)]
3225 pub struct initializeCall {
3226 #[allow(missing_docs)]
3227 pub _owner: alloy::sol_types::private::Address,
3228 #[allow(missing_docs)]
3229 pub _initialGrantRecipient: alloy::sol_types::private::Address,
3230 }
3231 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3233 #[derive(Clone)]
3234 pub struct initializeReturn {}
3235 #[allow(
3236 non_camel_case_types,
3237 non_snake_case,
3238 clippy::pub_underscore_fields,
3239 clippy::style
3240 )]
3241 const _: () = {
3242 use alloy::sol_types as alloy_sol_types;
3243 {
3244 #[doc(hidden)]
3245 type UnderlyingSolTuple<'a> = (
3246 alloy::sol_types::sol_data::Address,
3247 alloy::sol_types::sol_data::Address,
3248 );
3249 #[doc(hidden)]
3250 type UnderlyingRustTuple<'a> = (
3251 alloy::sol_types::private::Address,
3252 alloy::sol_types::private::Address,
3253 );
3254 #[cfg(test)]
3255 #[allow(dead_code, unreachable_patterns)]
3256 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3257 match _t {
3258 alloy_sol_types::private::AssertTypeEq::<
3259 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3260 >(_) => {},
3261 }
3262 }
3263 #[automatically_derived]
3264 #[doc(hidden)]
3265 impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
3266 fn from(value: initializeCall) -> Self {
3267 (value._owner, value._initialGrantRecipient)
3268 }
3269 }
3270 #[automatically_derived]
3271 #[doc(hidden)]
3272 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
3273 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3274 Self {
3275 _owner: tuple.0,
3276 _initialGrantRecipient: tuple.1,
3277 }
3278 }
3279 }
3280 }
3281 {
3282 #[doc(hidden)]
3283 type UnderlyingSolTuple<'a> = ();
3284 #[doc(hidden)]
3285 type UnderlyingRustTuple<'a> = ();
3286 #[cfg(test)]
3287 #[allow(dead_code, unreachable_patterns)]
3288 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3289 match _t {
3290 alloy_sol_types::private::AssertTypeEq::<
3291 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3292 >(_) => {},
3293 }
3294 }
3295 #[automatically_derived]
3296 #[doc(hidden)]
3297 impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
3298 fn from(value: initializeReturn) -> Self {
3299 ()
3300 }
3301 }
3302 #[automatically_derived]
3303 #[doc(hidden)]
3304 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
3305 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3306 Self {}
3307 }
3308 }
3309 }
3310 #[automatically_derived]
3311 impl alloy_sol_types::SolCall for initializeCall {
3312 type Parameters<'a> = (
3313 alloy::sol_types::sol_data::Address,
3314 alloy::sol_types::sol_data::Address,
3315 );
3316 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3317 type Return = initializeReturn;
3318 type ReturnTuple<'a> = ();
3319 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3320 const SIGNATURE: &'static str = "initialize(address,address)";
3321 const SELECTOR: [u8; 4] = [72u8, 92u8, 201u8, 85u8];
3322 #[inline]
3323 fn new<'a>(
3324 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3325 ) -> Self {
3326 tuple.into()
3327 }
3328 #[inline]
3329 fn tokenize(&self) -> Self::Token<'_> {
3330 (
3331 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3332 &self._owner,
3333 ),
3334 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3335 &self._initialGrantRecipient,
3336 ),
3337 )
3338 }
3339 #[inline]
3340 fn abi_decode_returns(
3341 data: &[u8],
3342 validate: bool,
3343 ) -> alloy_sol_types::Result<Self::Return> {
3344 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3345 data, validate,
3346 )
3347 .map(Into::into)
3348 }
3349 }
3350 };
3351 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3352 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3357 #[derive(Clone)]
3358 pub struct nameCall {}
3359 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3360 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3362 #[derive(Clone)]
3363 pub struct nameReturn {
3364 #[allow(missing_docs)]
3365 pub _0: alloy::sol_types::private::String,
3366 }
3367 #[allow(
3368 non_camel_case_types,
3369 non_snake_case,
3370 clippy::pub_underscore_fields,
3371 clippy::style
3372 )]
3373 const _: () = {
3374 use alloy::sol_types as alloy_sol_types;
3375 {
3376 #[doc(hidden)]
3377 type UnderlyingSolTuple<'a> = ();
3378 #[doc(hidden)]
3379 type UnderlyingRustTuple<'a> = ();
3380 #[cfg(test)]
3381 #[allow(dead_code, unreachable_patterns)]
3382 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3383 match _t {
3384 alloy_sol_types::private::AssertTypeEq::<
3385 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3386 >(_) => {},
3387 }
3388 }
3389 #[automatically_derived]
3390 #[doc(hidden)]
3391 impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
3392 fn from(value: nameCall) -> Self {
3393 ()
3394 }
3395 }
3396 #[automatically_derived]
3397 #[doc(hidden)]
3398 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
3399 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3400 Self {}
3401 }
3402 }
3403 }
3404 {
3405 #[doc(hidden)]
3406 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
3407 #[doc(hidden)]
3408 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
3409 #[cfg(test)]
3410 #[allow(dead_code, unreachable_patterns)]
3411 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3412 match _t {
3413 alloy_sol_types::private::AssertTypeEq::<
3414 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3415 >(_) => {},
3416 }
3417 }
3418 #[automatically_derived]
3419 #[doc(hidden)]
3420 impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
3421 fn from(value: nameReturn) -> Self {
3422 (value._0,)
3423 }
3424 }
3425 #[automatically_derived]
3426 #[doc(hidden)]
3427 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
3428 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3429 Self { _0: tuple.0 }
3430 }
3431 }
3432 }
3433 #[automatically_derived]
3434 impl alloy_sol_types::SolCall for nameCall {
3435 type Parameters<'a> = ();
3436 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3437 type Return = nameReturn;
3438 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
3439 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3440 const SIGNATURE: &'static str = "name()";
3441 const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
3442 #[inline]
3443 fn new<'a>(
3444 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3445 ) -> Self {
3446 tuple.into()
3447 }
3448 #[inline]
3449 fn tokenize(&self) -> Self::Token<'_> {
3450 ()
3451 }
3452 #[inline]
3453 fn abi_decode_returns(
3454 data: &[u8],
3455 validate: bool,
3456 ) -> alloy_sol_types::Result<Self::Return> {
3457 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3458 data, validate,
3459 )
3460 .map(Into::into)
3461 }
3462 }
3463 };
3464 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3465 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3470 #[derive(Clone)]
3471 pub struct ownerCall {}
3472 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3473 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3475 #[derive(Clone)]
3476 pub struct ownerReturn {
3477 #[allow(missing_docs)]
3478 pub _0: alloy::sol_types::private::Address,
3479 }
3480 #[allow(
3481 non_camel_case_types,
3482 non_snake_case,
3483 clippy::pub_underscore_fields,
3484 clippy::style
3485 )]
3486 const _: () = {
3487 use alloy::sol_types as alloy_sol_types;
3488 {
3489 #[doc(hidden)]
3490 type UnderlyingSolTuple<'a> = ();
3491 #[doc(hidden)]
3492 type UnderlyingRustTuple<'a> = ();
3493 #[cfg(test)]
3494 #[allow(dead_code, unreachable_patterns)]
3495 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3496 match _t {
3497 alloy_sol_types::private::AssertTypeEq::<
3498 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3499 >(_) => {},
3500 }
3501 }
3502 #[automatically_derived]
3503 #[doc(hidden)]
3504 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
3505 fn from(value: ownerCall) -> Self {
3506 ()
3507 }
3508 }
3509 #[automatically_derived]
3510 #[doc(hidden)]
3511 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
3512 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3513 Self {}
3514 }
3515 }
3516 }
3517 {
3518 #[doc(hidden)]
3519 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3520 #[doc(hidden)]
3521 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3522 #[cfg(test)]
3523 #[allow(dead_code, unreachable_patterns)]
3524 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3525 match _t {
3526 alloy_sol_types::private::AssertTypeEq::<
3527 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3528 >(_) => {},
3529 }
3530 }
3531 #[automatically_derived]
3532 #[doc(hidden)]
3533 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
3534 fn from(value: ownerReturn) -> Self {
3535 (value._0,)
3536 }
3537 }
3538 #[automatically_derived]
3539 #[doc(hidden)]
3540 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
3541 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3542 Self { _0: tuple.0 }
3543 }
3544 }
3545 }
3546 #[automatically_derived]
3547 impl alloy_sol_types::SolCall for ownerCall {
3548 type Parameters<'a> = ();
3549 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3550 type Return = ownerReturn;
3551 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3552 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3553 const SIGNATURE: &'static str = "owner()";
3554 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
3555 #[inline]
3556 fn new<'a>(
3557 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3558 ) -> Self {
3559 tuple.into()
3560 }
3561 #[inline]
3562 fn tokenize(&self) -> Self::Token<'_> {
3563 ()
3564 }
3565 #[inline]
3566 fn abi_decode_returns(
3567 data: &[u8],
3568 validate: bool,
3569 ) -> alloy_sol_types::Result<Self::Return> {
3570 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3571 data, validate,
3572 )
3573 .map(Into::into)
3574 }
3575 }
3576 };
3577 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3578 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3583 #[derive(Clone)]
3584 pub struct proxiableUUIDCall {}
3585 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3586 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3588 #[derive(Clone)]
3589 pub struct proxiableUUIDReturn {
3590 #[allow(missing_docs)]
3591 pub _0: alloy::sol_types::private::FixedBytes<32>,
3592 }
3593 #[allow(
3594 non_camel_case_types,
3595 non_snake_case,
3596 clippy::pub_underscore_fields,
3597 clippy::style
3598 )]
3599 const _: () = {
3600 use alloy::sol_types as alloy_sol_types;
3601 {
3602 #[doc(hidden)]
3603 type UnderlyingSolTuple<'a> = ();
3604 #[doc(hidden)]
3605 type UnderlyingRustTuple<'a> = ();
3606 #[cfg(test)]
3607 #[allow(dead_code, unreachable_patterns)]
3608 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3609 match _t {
3610 alloy_sol_types::private::AssertTypeEq::<
3611 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3612 >(_) => {},
3613 }
3614 }
3615 #[automatically_derived]
3616 #[doc(hidden)]
3617 impl ::core::convert::From<proxiableUUIDCall> for UnderlyingRustTuple<'_> {
3618 fn from(value: proxiableUUIDCall) -> Self {
3619 ()
3620 }
3621 }
3622 #[automatically_derived]
3623 #[doc(hidden)]
3624 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDCall {
3625 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3626 Self {}
3627 }
3628 }
3629 }
3630 {
3631 #[doc(hidden)]
3632 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3633 #[doc(hidden)]
3634 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3635 #[cfg(test)]
3636 #[allow(dead_code, unreachable_patterns)]
3637 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3638 match _t {
3639 alloy_sol_types::private::AssertTypeEq::<
3640 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3641 >(_) => {},
3642 }
3643 }
3644 #[automatically_derived]
3645 #[doc(hidden)]
3646 impl ::core::convert::From<proxiableUUIDReturn> for UnderlyingRustTuple<'_> {
3647 fn from(value: proxiableUUIDReturn) -> Self {
3648 (value._0,)
3649 }
3650 }
3651 #[automatically_derived]
3652 #[doc(hidden)]
3653 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDReturn {
3654 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3655 Self { _0: tuple.0 }
3656 }
3657 }
3658 }
3659 #[automatically_derived]
3660 impl alloy_sol_types::SolCall for proxiableUUIDCall {
3661 type Parameters<'a> = ();
3662 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3663 type Return = proxiableUUIDReturn;
3664 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3665 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3666 const SIGNATURE: &'static str = "proxiableUUID()";
3667 const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8];
3668 #[inline]
3669 fn new<'a>(
3670 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3671 ) -> Self {
3672 tuple.into()
3673 }
3674 #[inline]
3675 fn tokenize(&self) -> Self::Token<'_> {
3676 ()
3677 }
3678 #[inline]
3679 fn abi_decode_returns(
3680 data: &[u8],
3681 validate: bool,
3682 ) -> alloy_sol_types::Result<Self::Return> {
3683 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3684 data, validate,
3685 )
3686 .map(Into::into)
3687 }
3688 }
3689 };
3690 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3691 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3696 #[derive(Clone)]
3697 pub struct renounceOwnershipCall {}
3698 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3700 #[derive(Clone)]
3701 pub struct renounceOwnershipReturn {}
3702 #[allow(
3703 non_camel_case_types,
3704 non_snake_case,
3705 clippy::pub_underscore_fields,
3706 clippy::style
3707 )]
3708 const _: () = {
3709 use alloy::sol_types as alloy_sol_types;
3710 {
3711 #[doc(hidden)]
3712 type UnderlyingSolTuple<'a> = ();
3713 #[doc(hidden)]
3714 type UnderlyingRustTuple<'a> = ();
3715 #[cfg(test)]
3716 #[allow(dead_code, unreachable_patterns)]
3717 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3718 match _t {
3719 alloy_sol_types::private::AssertTypeEq::<
3720 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3721 >(_) => {},
3722 }
3723 }
3724 #[automatically_derived]
3725 #[doc(hidden)]
3726 impl ::core::convert::From<renounceOwnershipCall> for UnderlyingRustTuple<'_> {
3727 fn from(value: renounceOwnershipCall) -> Self {
3728 ()
3729 }
3730 }
3731 #[automatically_derived]
3732 #[doc(hidden)]
3733 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipCall {
3734 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3735 Self {}
3736 }
3737 }
3738 }
3739 {
3740 #[doc(hidden)]
3741 type UnderlyingSolTuple<'a> = ();
3742 #[doc(hidden)]
3743 type UnderlyingRustTuple<'a> = ();
3744 #[cfg(test)]
3745 #[allow(dead_code, unreachable_patterns)]
3746 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3747 match _t {
3748 alloy_sol_types::private::AssertTypeEq::<
3749 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3750 >(_) => {},
3751 }
3752 }
3753 #[automatically_derived]
3754 #[doc(hidden)]
3755 impl ::core::convert::From<renounceOwnershipReturn> for UnderlyingRustTuple<'_> {
3756 fn from(value: renounceOwnershipReturn) -> Self {
3757 ()
3758 }
3759 }
3760 #[automatically_derived]
3761 #[doc(hidden)]
3762 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipReturn {
3763 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3764 Self {}
3765 }
3766 }
3767 }
3768 #[automatically_derived]
3769 impl alloy_sol_types::SolCall for renounceOwnershipCall {
3770 type Parameters<'a> = ();
3771 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3772 type Return = renounceOwnershipReturn;
3773 type ReturnTuple<'a> = ();
3774 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3775 const SIGNATURE: &'static str = "renounceOwnership()";
3776 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
3777 #[inline]
3778 fn new<'a>(
3779 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3780 ) -> Self {
3781 tuple.into()
3782 }
3783 #[inline]
3784 fn tokenize(&self) -> Self::Token<'_> {
3785 ()
3786 }
3787 #[inline]
3788 fn abi_decode_returns(
3789 data: &[u8],
3790 validate: bool,
3791 ) -> alloy_sol_types::Result<Self::Return> {
3792 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3793 data, validate,
3794 )
3795 .map(Into::into)
3796 }
3797 }
3798 };
3799 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3800 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3805 #[derive(Clone)]
3806 pub struct symbolCall {}
3807 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3808 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3810 #[derive(Clone)]
3811 pub struct symbolReturn {
3812 #[allow(missing_docs)]
3813 pub _0: alloy::sol_types::private::String,
3814 }
3815 #[allow(
3816 non_camel_case_types,
3817 non_snake_case,
3818 clippy::pub_underscore_fields,
3819 clippy::style
3820 )]
3821 const _: () = {
3822 use alloy::sol_types as alloy_sol_types;
3823 {
3824 #[doc(hidden)]
3825 type UnderlyingSolTuple<'a> = ();
3826 #[doc(hidden)]
3827 type UnderlyingRustTuple<'a> = ();
3828 #[cfg(test)]
3829 #[allow(dead_code, unreachable_patterns)]
3830 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3831 match _t {
3832 alloy_sol_types::private::AssertTypeEq::<
3833 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3834 >(_) => {},
3835 }
3836 }
3837 #[automatically_derived]
3838 #[doc(hidden)]
3839 impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
3840 fn from(value: symbolCall) -> Self {
3841 ()
3842 }
3843 }
3844 #[automatically_derived]
3845 #[doc(hidden)]
3846 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
3847 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3848 Self {}
3849 }
3850 }
3851 }
3852 {
3853 #[doc(hidden)]
3854 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
3855 #[doc(hidden)]
3856 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
3857 #[cfg(test)]
3858 #[allow(dead_code, unreachable_patterns)]
3859 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3860 match _t {
3861 alloy_sol_types::private::AssertTypeEq::<
3862 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3863 >(_) => {},
3864 }
3865 }
3866 #[automatically_derived]
3867 #[doc(hidden)]
3868 impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
3869 fn from(value: symbolReturn) -> Self {
3870 (value._0,)
3871 }
3872 }
3873 #[automatically_derived]
3874 #[doc(hidden)]
3875 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
3876 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3877 Self { _0: tuple.0 }
3878 }
3879 }
3880 }
3881 #[automatically_derived]
3882 impl alloy_sol_types::SolCall for symbolCall {
3883 type Parameters<'a> = ();
3884 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3885 type Return = symbolReturn;
3886 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
3887 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3888 const SIGNATURE: &'static str = "symbol()";
3889 const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
3890 #[inline]
3891 fn new<'a>(
3892 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3893 ) -> Self {
3894 tuple.into()
3895 }
3896 #[inline]
3897 fn tokenize(&self) -> Self::Token<'_> {
3898 ()
3899 }
3900 #[inline]
3901 fn abi_decode_returns(
3902 data: &[u8],
3903 validate: bool,
3904 ) -> alloy_sol_types::Result<Self::Return> {
3905 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
3906 data, validate,
3907 )
3908 .map(Into::into)
3909 }
3910 }
3911 };
3912 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3913 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3918 #[derive(Clone)]
3919 pub struct totalSupplyCall {}
3920 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3921 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3923 #[derive(Clone)]
3924 pub struct totalSupplyReturn {
3925 #[allow(missing_docs)]
3926 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3927 }
3928 #[allow(
3929 non_camel_case_types,
3930 non_snake_case,
3931 clippy::pub_underscore_fields,
3932 clippy::style
3933 )]
3934 const _: () = {
3935 use alloy::sol_types as alloy_sol_types;
3936 {
3937 #[doc(hidden)]
3938 type UnderlyingSolTuple<'a> = ();
3939 #[doc(hidden)]
3940 type UnderlyingRustTuple<'a> = ();
3941 #[cfg(test)]
3942 #[allow(dead_code, unreachable_patterns)]
3943 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3944 match _t {
3945 alloy_sol_types::private::AssertTypeEq::<
3946 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3947 >(_) => {},
3948 }
3949 }
3950 #[automatically_derived]
3951 #[doc(hidden)]
3952 impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
3953 fn from(value: totalSupplyCall) -> Self {
3954 ()
3955 }
3956 }
3957 #[automatically_derived]
3958 #[doc(hidden)]
3959 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
3960 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3961 Self {}
3962 }
3963 }
3964 }
3965 {
3966 #[doc(hidden)]
3967 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3968 #[doc(hidden)]
3969 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
3970 #[cfg(test)]
3971 #[allow(dead_code, unreachable_patterns)]
3972 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3973 match _t {
3974 alloy_sol_types::private::AssertTypeEq::<
3975 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3976 >(_) => {},
3977 }
3978 }
3979 #[automatically_derived]
3980 #[doc(hidden)]
3981 impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
3982 fn from(value: totalSupplyReturn) -> Self {
3983 (value._0,)
3984 }
3985 }
3986 #[automatically_derived]
3987 #[doc(hidden)]
3988 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
3989 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3990 Self { _0: tuple.0 }
3991 }
3992 }
3993 }
3994 #[automatically_derived]
3995 impl alloy_sol_types::SolCall for totalSupplyCall {
3996 type Parameters<'a> = ();
3997 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3998 type Return = totalSupplyReturn;
3999 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4000 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4001 const SIGNATURE: &'static str = "totalSupply()";
4002 const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
4003 #[inline]
4004 fn new<'a>(
4005 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4006 ) -> Self {
4007 tuple.into()
4008 }
4009 #[inline]
4010 fn tokenize(&self) -> Self::Token<'_> {
4011 ()
4012 }
4013 #[inline]
4014 fn abi_decode_returns(
4015 data: &[u8],
4016 validate: bool,
4017 ) -> alloy_sol_types::Result<Self::Return> {
4018 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4019 data, validate,
4020 )
4021 .map(Into::into)
4022 }
4023 }
4024 };
4025 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4026 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4031 #[derive(Clone)]
4032 pub struct transferCall {
4033 #[allow(missing_docs)]
4034 pub to: alloy::sol_types::private::Address,
4035 #[allow(missing_docs)]
4036 pub value: alloy::sol_types::private::primitives::aliases::U256,
4037 }
4038 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4039 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4041 #[derive(Clone)]
4042 pub struct transferReturn {
4043 #[allow(missing_docs)]
4044 pub _0: bool,
4045 }
4046 #[allow(
4047 non_camel_case_types,
4048 non_snake_case,
4049 clippy::pub_underscore_fields,
4050 clippy::style
4051 )]
4052 const _: () = {
4053 use alloy::sol_types as alloy_sol_types;
4054 {
4055 #[doc(hidden)]
4056 type UnderlyingSolTuple<'a> = (
4057 alloy::sol_types::sol_data::Address,
4058 alloy::sol_types::sol_data::Uint<256>,
4059 );
4060 #[doc(hidden)]
4061 type UnderlyingRustTuple<'a> = (
4062 alloy::sol_types::private::Address,
4063 alloy::sol_types::private::primitives::aliases::U256,
4064 );
4065 #[cfg(test)]
4066 #[allow(dead_code, unreachable_patterns)]
4067 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4068 match _t {
4069 alloy_sol_types::private::AssertTypeEq::<
4070 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4071 >(_) => {},
4072 }
4073 }
4074 #[automatically_derived]
4075 #[doc(hidden)]
4076 impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
4077 fn from(value: transferCall) -> Self {
4078 (value.to, value.value)
4079 }
4080 }
4081 #[automatically_derived]
4082 #[doc(hidden)]
4083 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
4084 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4085 Self {
4086 to: tuple.0,
4087 value: tuple.1,
4088 }
4089 }
4090 }
4091 }
4092 {
4093 #[doc(hidden)]
4094 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4095 #[doc(hidden)]
4096 type UnderlyingRustTuple<'a> = (bool,);
4097 #[cfg(test)]
4098 #[allow(dead_code, unreachable_patterns)]
4099 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4100 match _t {
4101 alloy_sol_types::private::AssertTypeEq::<
4102 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4103 >(_) => {},
4104 }
4105 }
4106 #[automatically_derived]
4107 #[doc(hidden)]
4108 impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
4109 fn from(value: transferReturn) -> Self {
4110 (value._0,)
4111 }
4112 }
4113 #[automatically_derived]
4114 #[doc(hidden)]
4115 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
4116 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4117 Self { _0: tuple.0 }
4118 }
4119 }
4120 }
4121 #[automatically_derived]
4122 impl alloy_sol_types::SolCall for transferCall {
4123 type Parameters<'a> = (
4124 alloy::sol_types::sol_data::Address,
4125 alloy::sol_types::sol_data::Uint<256>,
4126 );
4127 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4128 type Return = transferReturn;
4129 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4130 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4131 const SIGNATURE: &'static str = "transfer(address,uint256)";
4132 const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
4133 #[inline]
4134 fn new<'a>(
4135 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4136 ) -> Self {
4137 tuple.into()
4138 }
4139 #[inline]
4140 fn tokenize(&self) -> Self::Token<'_> {
4141 (
4142 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4143 &self.to,
4144 ),
4145 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
4146 &self.value,
4147 ),
4148 )
4149 }
4150 #[inline]
4151 fn abi_decode_returns(
4152 data: &[u8],
4153 validate: bool,
4154 ) -> alloy_sol_types::Result<Self::Return> {
4155 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4156 data, validate,
4157 )
4158 .map(Into::into)
4159 }
4160 }
4161 };
4162 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4163 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4168 #[derive(Clone)]
4169 pub struct transferFromCall {
4170 #[allow(missing_docs)]
4171 pub from: alloy::sol_types::private::Address,
4172 #[allow(missing_docs)]
4173 pub to: alloy::sol_types::private::Address,
4174 #[allow(missing_docs)]
4175 pub value: alloy::sol_types::private::primitives::aliases::U256,
4176 }
4177 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4178 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4180 #[derive(Clone)]
4181 pub struct transferFromReturn {
4182 #[allow(missing_docs)]
4183 pub _0: bool,
4184 }
4185 #[allow(
4186 non_camel_case_types,
4187 non_snake_case,
4188 clippy::pub_underscore_fields,
4189 clippy::style
4190 )]
4191 const _: () = {
4192 use alloy::sol_types as alloy_sol_types;
4193 {
4194 #[doc(hidden)]
4195 type UnderlyingSolTuple<'a> = (
4196 alloy::sol_types::sol_data::Address,
4197 alloy::sol_types::sol_data::Address,
4198 alloy::sol_types::sol_data::Uint<256>,
4199 );
4200 #[doc(hidden)]
4201 type UnderlyingRustTuple<'a> = (
4202 alloy::sol_types::private::Address,
4203 alloy::sol_types::private::Address,
4204 alloy::sol_types::private::primitives::aliases::U256,
4205 );
4206 #[cfg(test)]
4207 #[allow(dead_code, unreachable_patterns)]
4208 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4209 match _t {
4210 alloy_sol_types::private::AssertTypeEq::<
4211 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4212 >(_) => {},
4213 }
4214 }
4215 #[automatically_derived]
4216 #[doc(hidden)]
4217 impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
4218 fn from(value: transferFromCall) -> Self {
4219 (value.from, value.to, value.value)
4220 }
4221 }
4222 #[automatically_derived]
4223 #[doc(hidden)]
4224 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
4225 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4226 Self {
4227 from: tuple.0,
4228 to: tuple.1,
4229 value: tuple.2,
4230 }
4231 }
4232 }
4233 }
4234 {
4235 #[doc(hidden)]
4236 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4237 #[doc(hidden)]
4238 type UnderlyingRustTuple<'a> = (bool,);
4239 #[cfg(test)]
4240 #[allow(dead_code, unreachable_patterns)]
4241 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4242 match _t {
4243 alloy_sol_types::private::AssertTypeEq::<
4244 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4245 >(_) => {},
4246 }
4247 }
4248 #[automatically_derived]
4249 #[doc(hidden)]
4250 impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
4251 fn from(value: transferFromReturn) -> Self {
4252 (value._0,)
4253 }
4254 }
4255 #[automatically_derived]
4256 #[doc(hidden)]
4257 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
4258 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4259 Self { _0: tuple.0 }
4260 }
4261 }
4262 }
4263 #[automatically_derived]
4264 impl alloy_sol_types::SolCall for transferFromCall {
4265 type Parameters<'a> = (
4266 alloy::sol_types::sol_data::Address,
4267 alloy::sol_types::sol_data::Address,
4268 alloy::sol_types::sol_data::Uint<256>,
4269 );
4270 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4271 type Return = transferFromReturn;
4272 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4273 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4274 const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
4275 const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
4276 #[inline]
4277 fn new<'a>(
4278 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4279 ) -> Self {
4280 tuple.into()
4281 }
4282 #[inline]
4283 fn tokenize(&self) -> Self::Token<'_> {
4284 (
4285 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4286 &self.from,
4287 ),
4288 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4289 &self.to,
4290 ),
4291 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
4292 &self.value,
4293 ),
4294 )
4295 }
4296 #[inline]
4297 fn abi_decode_returns(
4298 data: &[u8],
4299 validate: bool,
4300 ) -> alloy_sol_types::Result<Self::Return> {
4301 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4302 data, validate,
4303 )
4304 .map(Into::into)
4305 }
4306 }
4307 };
4308 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4309 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4314 #[derive(Clone)]
4315 pub struct transferOwnershipCall {
4316 #[allow(missing_docs)]
4317 pub newOwner: alloy::sol_types::private::Address,
4318 }
4319 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4321 #[derive(Clone)]
4322 pub struct transferOwnershipReturn {}
4323 #[allow(
4324 non_camel_case_types,
4325 non_snake_case,
4326 clippy::pub_underscore_fields,
4327 clippy::style
4328 )]
4329 const _: () = {
4330 use alloy::sol_types as alloy_sol_types;
4331 {
4332 #[doc(hidden)]
4333 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4334 #[doc(hidden)]
4335 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4336 #[cfg(test)]
4337 #[allow(dead_code, unreachable_patterns)]
4338 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4339 match _t {
4340 alloy_sol_types::private::AssertTypeEq::<
4341 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4342 >(_) => {},
4343 }
4344 }
4345 #[automatically_derived]
4346 #[doc(hidden)]
4347 impl ::core::convert::From<transferOwnershipCall> for UnderlyingRustTuple<'_> {
4348 fn from(value: transferOwnershipCall) -> Self {
4349 (value.newOwner,)
4350 }
4351 }
4352 #[automatically_derived]
4353 #[doc(hidden)]
4354 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipCall {
4355 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4356 Self { newOwner: tuple.0 }
4357 }
4358 }
4359 }
4360 {
4361 #[doc(hidden)]
4362 type UnderlyingSolTuple<'a> = ();
4363 #[doc(hidden)]
4364 type UnderlyingRustTuple<'a> = ();
4365 #[cfg(test)]
4366 #[allow(dead_code, unreachable_patterns)]
4367 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4368 match _t {
4369 alloy_sol_types::private::AssertTypeEq::<
4370 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4371 >(_) => {},
4372 }
4373 }
4374 #[automatically_derived]
4375 #[doc(hidden)]
4376 impl ::core::convert::From<transferOwnershipReturn> for UnderlyingRustTuple<'_> {
4377 fn from(value: transferOwnershipReturn) -> Self {
4378 ()
4379 }
4380 }
4381 #[automatically_derived]
4382 #[doc(hidden)]
4383 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipReturn {
4384 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4385 Self {}
4386 }
4387 }
4388 }
4389 #[automatically_derived]
4390 impl alloy_sol_types::SolCall for transferOwnershipCall {
4391 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4392 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4393 type Return = transferOwnershipReturn;
4394 type ReturnTuple<'a> = ();
4395 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4396 const SIGNATURE: &'static str = "transferOwnership(address)";
4397 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
4398 #[inline]
4399 fn new<'a>(
4400 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4401 ) -> Self {
4402 tuple.into()
4403 }
4404 #[inline]
4405 fn tokenize(&self) -> Self::Token<'_> {
4406 (
4407 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4408 &self.newOwner,
4409 ),
4410 )
4411 }
4412 #[inline]
4413 fn abi_decode_returns(
4414 data: &[u8],
4415 validate: bool,
4416 ) -> alloy_sol_types::Result<Self::Return> {
4417 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4418 data, validate,
4419 )
4420 .map(Into::into)
4421 }
4422 }
4423 };
4424 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4425 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4430 #[derive(Clone)]
4431 pub struct upgradeToAndCallCall {
4432 #[allow(missing_docs)]
4433 pub newImplementation: alloy::sol_types::private::Address,
4434 #[allow(missing_docs)]
4435 pub data: alloy::sol_types::private::Bytes,
4436 }
4437 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4439 #[derive(Clone)]
4440 pub struct upgradeToAndCallReturn {}
4441 #[allow(
4442 non_camel_case_types,
4443 non_snake_case,
4444 clippy::pub_underscore_fields,
4445 clippy::style
4446 )]
4447 const _: () = {
4448 use alloy::sol_types as alloy_sol_types;
4449 {
4450 #[doc(hidden)]
4451 type UnderlyingSolTuple<'a> = (
4452 alloy::sol_types::sol_data::Address,
4453 alloy::sol_types::sol_data::Bytes,
4454 );
4455 #[doc(hidden)]
4456 type UnderlyingRustTuple<'a> = (
4457 alloy::sol_types::private::Address,
4458 alloy::sol_types::private::Bytes,
4459 );
4460 #[cfg(test)]
4461 #[allow(dead_code, unreachable_patterns)]
4462 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4463 match _t {
4464 alloy_sol_types::private::AssertTypeEq::<
4465 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4466 >(_) => {},
4467 }
4468 }
4469 #[automatically_derived]
4470 #[doc(hidden)]
4471 impl ::core::convert::From<upgradeToAndCallCall> for UnderlyingRustTuple<'_> {
4472 fn from(value: upgradeToAndCallCall) -> Self {
4473 (value.newImplementation, value.data)
4474 }
4475 }
4476 #[automatically_derived]
4477 #[doc(hidden)]
4478 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeToAndCallCall {
4479 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4480 Self {
4481 newImplementation: tuple.0,
4482 data: tuple.1,
4483 }
4484 }
4485 }
4486 }
4487 {
4488 #[doc(hidden)]
4489 type UnderlyingSolTuple<'a> = ();
4490 #[doc(hidden)]
4491 type UnderlyingRustTuple<'a> = ();
4492 #[cfg(test)]
4493 #[allow(dead_code, unreachable_patterns)]
4494 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4495 match _t {
4496 alloy_sol_types::private::AssertTypeEq::<
4497 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4498 >(_) => {},
4499 }
4500 }
4501 #[automatically_derived]
4502 #[doc(hidden)]
4503 impl ::core::convert::From<upgradeToAndCallReturn> for UnderlyingRustTuple<'_> {
4504 fn from(value: upgradeToAndCallReturn) -> Self {
4505 ()
4506 }
4507 }
4508 #[automatically_derived]
4509 #[doc(hidden)]
4510 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeToAndCallReturn {
4511 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4512 Self {}
4513 }
4514 }
4515 }
4516 #[automatically_derived]
4517 impl alloy_sol_types::SolCall for upgradeToAndCallCall {
4518 type Parameters<'a> = (
4519 alloy::sol_types::sol_data::Address,
4520 alloy::sol_types::sol_data::Bytes,
4521 );
4522 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4523 type Return = upgradeToAndCallReturn;
4524 type ReturnTuple<'a> = ();
4525 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4526 const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)";
4527 const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8];
4528 #[inline]
4529 fn new<'a>(
4530 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4531 ) -> Self {
4532 tuple.into()
4533 }
4534 #[inline]
4535 fn tokenize(&self) -> Self::Token<'_> {
4536 (
4537 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4538 &self.newImplementation,
4539 ),
4540 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
4541 &self.data,
4542 ),
4543 )
4544 }
4545 #[inline]
4546 fn abi_decode_returns(
4547 data: &[u8],
4548 validate: bool,
4549 ) -> alloy_sol_types::Result<Self::Return> {
4550 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
4551 data, validate,
4552 )
4553 .map(Into::into)
4554 }
4555 }
4556 };
4557 #[derive()]
4559 pub enum EspTokenCalls {
4560 #[allow(missing_docs)]
4561 UPGRADE_INTERFACE_VERSION(UPGRADE_INTERFACE_VERSIONCall),
4562 #[allow(missing_docs)]
4563 allowance(allowanceCall),
4564 #[allow(missing_docs)]
4565 approve(approveCall),
4566 #[allow(missing_docs)]
4567 balanceOf(balanceOfCall),
4568 #[allow(missing_docs)]
4569 decimals(decimalsCall),
4570 #[allow(missing_docs)]
4571 getVersion(getVersionCall),
4572 #[allow(missing_docs)]
4573 initialize(initializeCall),
4574 #[allow(missing_docs)]
4575 name(nameCall),
4576 #[allow(missing_docs)]
4577 owner(ownerCall),
4578 #[allow(missing_docs)]
4579 proxiableUUID(proxiableUUIDCall),
4580 #[allow(missing_docs)]
4581 renounceOwnership(renounceOwnershipCall),
4582 #[allow(missing_docs)]
4583 symbol(symbolCall),
4584 #[allow(missing_docs)]
4585 totalSupply(totalSupplyCall),
4586 #[allow(missing_docs)]
4587 transfer(transferCall),
4588 #[allow(missing_docs)]
4589 transferFrom(transferFromCall),
4590 #[allow(missing_docs)]
4591 transferOwnership(transferOwnershipCall),
4592 #[allow(missing_docs)]
4593 upgradeToAndCall(upgradeToAndCallCall),
4594 }
4595 #[automatically_derived]
4596 impl EspTokenCalls {
4597 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4604 [6u8, 253u8, 222u8, 3u8],
4605 [9u8, 94u8, 167u8, 179u8],
4606 [13u8, 142u8, 110u8, 44u8],
4607 [24u8, 22u8, 13u8, 221u8],
4608 [35u8, 184u8, 114u8, 221u8],
4609 [49u8, 60u8, 229u8, 103u8],
4610 [72u8, 92u8, 201u8, 85u8],
4611 [79u8, 30u8, 242u8, 134u8],
4612 [82u8, 209u8, 144u8, 45u8],
4613 [112u8, 160u8, 130u8, 49u8],
4614 [113u8, 80u8, 24u8, 166u8],
4615 [141u8, 165u8, 203u8, 91u8],
4616 [149u8, 216u8, 155u8, 65u8],
4617 [169u8, 5u8, 156u8, 187u8],
4618 [173u8, 60u8, 177u8, 204u8],
4619 [221u8, 98u8, 237u8, 62u8],
4620 [242u8, 253u8, 227u8, 139u8],
4621 ];
4622 }
4623 #[automatically_derived]
4624 impl alloy_sol_types::SolInterface for EspTokenCalls {
4625 const NAME: &'static str = "EspTokenCalls";
4626 const MIN_DATA_LENGTH: usize = 0usize;
4627 const COUNT: usize = 17usize;
4628 #[inline]
4629 fn selector(&self) -> [u8; 4] {
4630 match self {
4631 Self::UPGRADE_INTERFACE_VERSION(_) => {
4632 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SELECTOR
4633 },
4634 Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
4635 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
4636 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
4637 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
4638 Self::getVersion(_) => <getVersionCall as alloy_sol_types::SolCall>::SELECTOR,
4639 Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
4640 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
4641 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
4642 Self::proxiableUUID(_) => <proxiableUUIDCall as alloy_sol_types::SolCall>::SELECTOR,
4643 Self::renounceOwnership(_) => {
4644 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4645 },
4646 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
4647 Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
4648 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
4649 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
4650 Self::transferOwnership(_) => {
4651 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4652 },
4653 Self::upgradeToAndCall(_) => {
4654 <upgradeToAndCallCall as alloy_sol_types::SolCall>::SELECTOR
4655 },
4656 }
4657 }
4658 #[inline]
4659 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4660 Self::SELECTORS.get(i).copied()
4661 }
4662 #[inline]
4663 fn valid_selector(selector: [u8; 4]) -> bool {
4664 Self::SELECTORS.binary_search(&selector).is_ok()
4665 }
4666 #[inline]
4667 #[allow(non_snake_case)]
4668 fn abi_decode_raw(
4669 selector: [u8; 4],
4670 data: &[u8],
4671 validate: bool,
4672 ) -> alloy_sol_types::Result<Self> {
4673 static DECODE_SHIMS: &[fn(&[u8], bool) -> alloy_sol_types::Result<EspTokenCalls>] = &[
4674 {
4675 fn name(data: &[u8], validate: bool) -> alloy_sol_types::Result<EspTokenCalls> {
4676 <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4677 .map(EspTokenCalls::name)
4678 }
4679 name
4680 },
4681 {
4682 fn approve(
4683 data: &[u8],
4684 validate: bool,
4685 ) -> alloy_sol_types::Result<EspTokenCalls> {
4686 <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4687 .map(EspTokenCalls::approve)
4688 }
4689 approve
4690 },
4691 {
4692 fn getVersion(
4693 data: &[u8],
4694 validate: bool,
4695 ) -> alloy_sol_types::Result<EspTokenCalls> {
4696 <getVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4697 .map(EspTokenCalls::getVersion)
4698 }
4699 getVersion
4700 },
4701 {
4702 fn totalSupply(
4703 data: &[u8],
4704 validate: bool,
4705 ) -> alloy_sol_types::Result<EspTokenCalls> {
4706 <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(
4707 data, validate,
4708 )
4709 .map(EspTokenCalls::totalSupply)
4710 }
4711 totalSupply
4712 },
4713 {
4714 fn transferFrom(
4715 data: &[u8],
4716 validate: bool,
4717 ) -> alloy_sol_types::Result<EspTokenCalls> {
4718 <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(
4719 data, validate,
4720 )
4721 .map(EspTokenCalls::transferFrom)
4722 }
4723 transferFrom
4724 },
4725 {
4726 fn decimals(
4727 data: &[u8],
4728 validate: bool,
4729 ) -> alloy_sol_types::Result<EspTokenCalls> {
4730 <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4731 .map(EspTokenCalls::decimals)
4732 }
4733 decimals
4734 },
4735 {
4736 fn initialize(
4737 data: &[u8],
4738 validate: bool,
4739 ) -> alloy_sol_types::Result<EspTokenCalls> {
4740 <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4741 .map(EspTokenCalls::initialize)
4742 }
4743 initialize
4744 },
4745 {
4746 fn upgradeToAndCall(
4747 data: &[u8],
4748 validate: bool,
4749 ) -> alloy_sol_types::Result<EspTokenCalls> {
4750 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(
4751 data, validate,
4752 )
4753 .map(EspTokenCalls::upgradeToAndCall)
4754 }
4755 upgradeToAndCall
4756 },
4757 {
4758 fn proxiableUUID(
4759 data: &[u8],
4760 validate: bool,
4761 ) -> alloy_sol_types::Result<EspTokenCalls> {
4762 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
4763 data, validate,
4764 )
4765 .map(EspTokenCalls::proxiableUUID)
4766 }
4767 proxiableUUID
4768 },
4769 {
4770 fn balanceOf(
4771 data: &[u8],
4772 validate: bool,
4773 ) -> alloy_sol_types::Result<EspTokenCalls> {
4774 <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4775 .map(EspTokenCalls::balanceOf)
4776 }
4777 balanceOf
4778 },
4779 {
4780 fn renounceOwnership(
4781 data: &[u8],
4782 validate: bool,
4783 ) -> alloy_sol_types::Result<EspTokenCalls> {
4784 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
4785 data, validate,
4786 )
4787 .map(EspTokenCalls::renounceOwnership)
4788 }
4789 renounceOwnership
4790 },
4791 {
4792 fn owner(
4793 data: &[u8],
4794 validate: bool,
4795 ) -> alloy_sol_types::Result<EspTokenCalls> {
4796 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4797 .map(EspTokenCalls::owner)
4798 }
4799 owner
4800 },
4801 {
4802 fn symbol(
4803 data: &[u8],
4804 validate: bool,
4805 ) -> alloy_sol_types::Result<EspTokenCalls> {
4806 <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4807 .map(EspTokenCalls::symbol)
4808 }
4809 symbol
4810 },
4811 {
4812 fn transfer(
4813 data: &[u8],
4814 validate: bool,
4815 ) -> alloy_sol_types::Result<EspTokenCalls> {
4816 <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4817 .map(EspTokenCalls::transfer)
4818 }
4819 transfer
4820 },
4821 {
4822 fn UPGRADE_INTERFACE_VERSION(
4823 data: &[u8],
4824 validate: bool,
4825 ) -> alloy_sol_types::Result<EspTokenCalls> {
4826 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(
4827 data, validate,
4828 )
4829 .map(EspTokenCalls::UPGRADE_INTERFACE_VERSION)
4830 }
4831 UPGRADE_INTERFACE_VERSION
4832 },
4833 {
4834 fn allowance(
4835 data: &[u8],
4836 validate: bool,
4837 ) -> alloy_sol_types::Result<EspTokenCalls> {
4838 <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
4839 .map(EspTokenCalls::allowance)
4840 }
4841 allowance
4842 },
4843 {
4844 fn transferOwnership(
4845 data: &[u8],
4846 validate: bool,
4847 ) -> alloy_sol_types::Result<EspTokenCalls> {
4848 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
4849 data, validate,
4850 )
4851 .map(EspTokenCalls::transferOwnership)
4852 }
4853 transferOwnership
4854 },
4855 ];
4856 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4857 return Err(alloy_sol_types::Error::unknown_selector(
4858 <Self as alloy_sol_types::SolInterface>::NAME,
4859 selector,
4860 ));
4861 };
4862 DECODE_SHIMS[idx](data, validate)
4863 }
4864 #[inline]
4865 fn abi_encoded_size(&self) -> usize {
4866 match self {
4867 Self::UPGRADE_INTERFACE_VERSION(inner) => {
4868 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
4869 inner,
4870 )
4871 },
4872 Self::allowance(inner) => {
4873 <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4874 },
4875 Self::approve(inner) => {
4876 <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4877 },
4878 Self::balanceOf(inner) => {
4879 <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4880 },
4881 Self::decimals(inner) => {
4882 <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4883 },
4884 Self::getVersion(inner) => {
4885 <getVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4886 },
4887 Self::initialize(inner) => {
4888 <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4889 },
4890 Self::name(inner) => {
4891 <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4892 },
4893 Self::owner(inner) => {
4894 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4895 },
4896 Self::proxiableUUID(inner) => {
4897 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4898 },
4899 Self::renounceOwnership(inner) => {
4900 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4901 },
4902 Self::symbol(inner) => {
4903 <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4904 },
4905 Self::totalSupply(inner) => {
4906 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4907 },
4908 Self::transfer(inner) => {
4909 <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4910 },
4911 Self::transferFrom(inner) => {
4912 <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4913 },
4914 Self::transferOwnership(inner) => {
4915 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4916 },
4917 Self::upgradeToAndCall(inner) => {
4918 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4919 },
4920 }
4921 }
4922 #[inline]
4923 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4924 match self {
4925 Self::UPGRADE_INTERFACE_VERSION(inner) => {
4926 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
4927 inner, out,
4928 )
4929 },
4930 Self::allowance(inner) => {
4931 <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4932 },
4933 Self::approve(inner) => {
4934 <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4935 },
4936 Self::balanceOf(inner) => {
4937 <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4938 },
4939 Self::decimals(inner) => {
4940 <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4941 },
4942 Self::getVersion(inner) => {
4943 <getVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4944 },
4945 Self::initialize(inner) => {
4946 <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4947 },
4948 Self::name(inner) => {
4949 <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4950 },
4951 Self::owner(inner) => {
4952 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4953 },
4954 Self::proxiableUUID(inner) => {
4955 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4956 },
4957 Self::renounceOwnership(inner) => {
4958 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4959 },
4960 Self::symbol(inner) => {
4961 <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4962 },
4963 Self::totalSupply(inner) => {
4964 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4965 },
4966 Self::transfer(inner) => {
4967 <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4968 },
4969 Self::transferFrom(inner) => {
4970 <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4971 },
4972 Self::transferOwnership(inner) => {
4973 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4974 },
4975 Self::upgradeToAndCall(inner) => {
4976 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4977 },
4978 }
4979 }
4980 }
4981 #[derive(Debug, PartialEq, Eq, Hash)]
4983 pub enum EspTokenErrors {
4984 #[allow(missing_docs)]
4985 AddressEmptyCode(AddressEmptyCode),
4986 #[allow(missing_docs)]
4987 ERC1967InvalidImplementation(ERC1967InvalidImplementation),
4988 #[allow(missing_docs)]
4989 ERC1967NonPayable(ERC1967NonPayable),
4990 #[allow(missing_docs)]
4991 ERC20InsufficientAllowance(ERC20InsufficientAllowance),
4992 #[allow(missing_docs)]
4993 ERC20InsufficientBalance(ERC20InsufficientBalance),
4994 #[allow(missing_docs)]
4995 ERC20InvalidApprover(ERC20InvalidApprover),
4996 #[allow(missing_docs)]
4997 ERC20InvalidReceiver(ERC20InvalidReceiver),
4998 #[allow(missing_docs)]
4999 ERC20InvalidSender(ERC20InvalidSender),
5000 #[allow(missing_docs)]
5001 ERC20InvalidSpender(ERC20InvalidSpender),
5002 #[allow(missing_docs)]
5003 FailedInnerCall(FailedInnerCall),
5004 #[allow(missing_docs)]
5005 InvalidInitialization(InvalidInitialization),
5006 #[allow(missing_docs)]
5007 NotInitializing(NotInitializing),
5008 #[allow(missing_docs)]
5009 OwnableInvalidOwner(OwnableInvalidOwner),
5010 #[allow(missing_docs)]
5011 OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
5012 #[allow(missing_docs)]
5013 UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext),
5014 #[allow(missing_docs)]
5015 UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID),
5016 }
5017 #[automatically_derived]
5018 impl EspTokenErrors {
5019 pub const SELECTORS: &'static [[u8; 4usize]] = &[
5026 [17u8, 140u8, 218u8, 167u8],
5027 [20u8, 37u8, 234u8, 66u8],
5028 [30u8, 79u8, 189u8, 247u8],
5029 [76u8, 156u8, 140u8, 227u8],
5030 [148u8, 40u8, 13u8, 98u8],
5031 [150u8, 198u8, 253u8, 30u8],
5032 [153u8, 150u8, 179u8, 21u8],
5033 [170u8, 29u8, 73u8, 164u8],
5034 [179u8, 152u8, 151u8, 159u8],
5035 [215u8, 230u8, 188u8, 248u8],
5036 [224u8, 124u8, 141u8, 186u8],
5037 [228u8, 80u8, 211u8, 140u8],
5038 [230u8, 2u8, 223u8, 5u8],
5039 [236u8, 68u8, 47u8, 5u8],
5040 [249u8, 46u8, 232u8, 169u8],
5041 [251u8, 143u8, 65u8, 178u8],
5042 ];
5043 }
5044 #[automatically_derived]
5045 impl alloy_sol_types::SolInterface for EspTokenErrors {
5046 const NAME: &'static str = "EspTokenErrors";
5047 const MIN_DATA_LENGTH: usize = 0usize;
5048 const COUNT: usize = 16usize;
5049 #[inline]
5050 fn selector(&self) -> [u8; 4] {
5051 match self {
5052 Self::AddressEmptyCode(_) => {
5053 <AddressEmptyCode as alloy_sol_types::SolError>::SELECTOR
5054 },
5055 Self::ERC1967InvalidImplementation(_) => {
5056 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SELECTOR
5057 },
5058 Self::ERC1967NonPayable(_) => {
5059 <ERC1967NonPayable as alloy_sol_types::SolError>::SELECTOR
5060 },
5061 Self::ERC20InsufficientAllowance(_) => {
5062 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::SELECTOR
5063 },
5064 Self::ERC20InsufficientBalance(_) => {
5065 <ERC20InsufficientBalance as alloy_sol_types::SolError>::SELECTOR
5066 },
5067 Self::ERC20InvalidApprover(_) => {
5068 <ERC20InvalidApprover as alloy_sol_types::SolError>::SELECTOR
5069 },
5070 Self::ERC20InvalidReceiver(_) => {
5071 <ERC20InvalidReceiver as alloy_sol_types::SolError>::SELECTOR
5072 },
5073 Self::ERC20InvalidSender(_) => {
5074 <ERC20InvalidSender as alloy_sol_types::SolError>::SELECTOR
5075 },
5076 Self::ERC20InvalidSpender(_) => {
5077 <ERC20InvalidSpender as alloy_sol_types::SolError>::SELECTOR
5078 },
5079 Self::FailedInnerCall(_) => {
5080 <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
5081 },
5082 Self::InvalidInitialization(_) => {
5083 <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
5084 },
5085 Self::NotInitializing(_) => {
5086 <NotInitializing as alloy_sol_types::SolError>::SELECTOR
5087 },
5088 Self::OwnableInvalidOwner(_) => {
5089 <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
5090 },
5091 Self::OwnableUnauthorizedAccount(_) => {
5092 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
5093 },
5094 Self::UUPSUnauthorizedCallContext(_) => {
5095 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SELECTOR
5096 },
5097 Self::UUPSUnsupportedProxiableUUID(_) => {
5098 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SELECTOR
5099 },
5100 }
5101 }
5102 #[inline]
5103 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5104 Self::SELECTORS.get(i).copied()
5105 }
5106 #[inline]
5107 fn valid_selector(selector: [u8; 4]) -> bool {
5108 Self::SELECTORS.binary_search(&selector).is_ok()
5109 }
5110 #[inline]
5111 #[allow(non_snake_case)]
5112 fn abi_decode_raw(
5113 selector: [u8; 4],
5114 data: &[u8],
5115 validate: bool,
5116 ) -> alloy_sol_types::Result<Self> {
5117 static DECODE_SHIMS: &[fn(&[u8], bool) -> alloy_sol_types::Result<EspTokenErrors>] = &[
5118 {
5119 fn OwnableUnauthorizedAccount(
5120 data: &[u8],
5121 validate: bool,
5122 ) -> alloy_sol_types::Result<EspTokenErrors> {
5123 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
5124 data, validate,
5125 )
5126 .map(EspTokenErrors::OwnableUnauthorizedAccount)
5127 }
5128 OwnableUnauthorizedAccount
5129 },
5130 {
5131 fn FailedInnerCall(
5132 data: &[u8],
5133 validate: bool,
5134 ) -> alloy_sol_types::Result<EspTokenErrors> {
5135 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(
5136 data, validate,
5137 )
5138 .map(EspTokenErrors::FailedInnerCall)
5139 }
5140 FailedInnerCall
5141 },
5142 {
5143 fn OwnableInvalidOwner(
5144 data: &[u8],
5145 validate: bool,
5146 ) -> alloy_sol_types::Result<EspTokenErrors> {
5147 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
5148 data, validate,
5149 )
5150 .map(EspTokenErrors::OwnableInvalidOwner)
5151 }
5152 OwnableInvalidOwner
5153 },
5154 {
5155 fn ERC1967InvalidImplementation(
5156 data: &[u8],
5157 validate: bool,
5158 ) -> alloy_sol_types::Result<EspTokenErrors> {
5159 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_decode_raw(
5160 data, validate,
5161 )
5162 .map(EspTokenErrors::ERC1967InvalidImplementation)
5163 }
5164 ERC1967InvalidImplementation
5165 },
5166 {
5167 fn ERC20InvalidSpender(
5168 data: &[u8],
5169 validate: bool,
5170 ) -> alloy_sol_types::Result<EspTokenErrors> {
5171 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_decode_raw(
5172 data, validate,
5173 )
5174 .map(EspTokenErrors::ERC20InvalidSpender)
5175 }
5176 ERC20InvalidSpender
5177 },
5178 {
5179 fn ERC20InvalidSender(
5180 data: &[u8],
5181 validate: bool,
5182 ) -> alloy_sol_types::Result<EspTokenErrors> {
5183 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_decode_raw(
5184 data, validate,
5185 )
5186 .map(EspTokenErrors::ERC20InvalidSender)
5187 }
5188 ERC20InvalidSender
5189 },
5190 {
5191 fn AddressEmptyCode(
5192 data: &[u8],
5193 validate: bool,
5194 ) -> alloy_sol_types::Result<EspTokenErrors> {
5195 <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw(
5196 data, validate,
5197 )
5198 .map(EspTokenErrors::AddressEmptyCode)
5199 }
5200 AddressEmptyCode
5201 },
5202 {
5203 fn UUPSUnsupportedProxiableUUID(
5204 data: &[u8],
5205 validate: bool,
5206 ) -> alloy_sol_types::Result<EspTokenErrors> {
5207 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_decode_raw(
5208 data, validate,
5209 )
5210 .map(EspTokenErrors::UUPSUnsupportedProxiableUUID)
5211 }
5212 UUPSUnsupportedProxiableUUID
5213 },
5214 {
5215 fn ERC1967NonPayable(
5216 data: &[u8],
5217 validate: bool,
5218 ) -> alloy_sol_types::Result<EspTokenErrors> {
5219 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_decode_raw(
5220 data, validate,
5221 )
5222 .map(EspTokenErrors::ERC1967NonPayable)
5223 }
5224 ERC1967NonPayable
5225 },
5226 {
5227 fn NotInitializing(
5228 data: &[u8],
5229 validate: bool,
5230 ) -> alloy_sol_types::Result<EspTokenErrors> {
5231 <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw(
5232 data, validate,
5233 )
5234 .map(EspTokenErrors::NotInitializing)
5235 }
5236 NotInitializing
5237 },
5238 {
5239 fn UUPSUnauthorizedCallContext(
5240 data: &[u8],
5241 validate: bool,
5242 ) -> alloy_sol_types::Result<EspTokenErrors> {
5243 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_decode_raw(
5244 data, validate,
5245 )
5246 .map(EspTokenErrors::UUPSUnauthorizedCallContext)
5247 }
5248 UUPSUnauthorizedCallContext
5249 },
5250 {
5251 fn ERC20InsufficientBalance(
5252 data: &[u8],
5253 validate: bool,
5254 ) -> alloy_sol_types::Result<EspTokenErrors> {
5255 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw(
5256 data, validate,
5257 )
5258 .map(EspTokenErrors::ERC20InsufficientBalance)
5259 }
5260 ERC20InsufficientBalance
5261 },
5262 {
5263 fn ERC20InvalidApprover(
5264 data: &[u8],
5265 validate: bool,
5266 ) -> alloy_sol_types::Result<EspTokenErrors> {
5267 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_decode_raw(
5268 data, validate,
5269 )
5270 .map(EspTokenErrors::ERC20InvalidApprover)
5271 }
5272 ERC20InvalidApprover
5273 },
5274 {
5275 fn ERC20InvalidReceiver(
5276 data: &[u8],
5277 validate: bool,
5278 ) -> alloy_sol_types::Result<EspTokenErrors> {
5279 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_decode_raw(
5280 data, validate,
5281 )
5282 .map(EspTokenErrors::ERC20InvalidReceiver)
5283 }
5284 ERC20InvalidReceiver
5285 },
5286 {
5287 fn InvalidInitialization(
5288 data: &[u8],
5289 validate: bool,
5290 ) -> alloy_sol_types::Result<EspTokenErrors> {
5291 <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw(
5292 data, validate,
5293 )
5294 .map(EspTokenErrors::InvalidInitialization)
5295 }
5296 InvalidInitialization
5297 },
5298 {
5299 fn ERC20InsufficientAllowance(
5300 data: &[u8],
5301 validate: bool,
5302 ) -> alloy_sol_types::Result<EspTokenErrors> {
5303 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_decode_raw(
5304 data, validate,
5305 )
5306 .map(EspTokenErrors::ERC20InsufficientAllowance)
5307 }
5308 ERC20InsufficientAllowance
5309 },
5310 ];
5311 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5312 return Err(alloy_sol_types::Error::unknown_selector(
5313 <Self as alloy_sol_types::SolInterface>::NAME,
5314 selector,
5315 ));
5316 };
5317 DECODE_SHIMS[idx](data, validate)
5318 }
5319 #[inline]
5320 fn abi_encoded_size(&self) -> usize {
5321 match self {
5322 Self::AddressEmptyCode(inner) => {
5323 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encoded_size(inner)
5324 },
5325 Self::ERC1967InvalidImplementation(inner) => {
5326 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encoded_size(
5327 inner,
5328 )
5329 },
5330 Self::ERC1967NonPayable(inner) => {
5331 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encoded_size(inner)
5332 },
5333 Self::ERC20InsufficientAllowance(inner) => {
5334 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_encoded_size(
5335 inner,
5336 )
5337 },
5338 Self::ERC20InsufficientBalance(inner) => {
5339 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_encoded_size(inner)
5340 },
5341 Self::ERC20InvalidApprover(inner) => {
5342 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_encoded_size(inner)
5343 },
5344 Self::ERC20InvalidReceiver(inner) => {
5345 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_encoded_size(inner)
5346 },
5347 Self::ERC20InvalidSender(inner) => {
5348 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_encoded_size(inner)
5349 },
5350 Self::ERC20InvalidSpender(inner) => {
5351 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_encoded_size(inner)
5352 },
5353 Self::FailedInnerCall(inner) => {
5354 <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(inner)
5355 },
5356 Self::InvalidInitialization(inner) => {
5357 <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(inner)
5358 },
5359 Self::NotInitializing(inner) => {
5360 <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(inner)
5361 },
5362 Self::OwnableInvalidOwner(inner) => {
5363 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(inner)
5364 },
5365 Self::OwnableUnauthorizedAccount(inner) => {
5366 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
5367 inner,
5368 )
5369 },
5370 Self::UUPSUnauthorizedCallContext(inner) => {
5371 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encoded_size(
5372 inner,
5373 )
5374 },
5375 Self::UUPSUnsupportedProxiableUUID(inner) => {
5376 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encoded_size(
5377 inner,
5378 )
5379 },
5380 }
5381 }
5382 #[inline]
5383 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5384 match self {
5385 Self::AddressEmptyCode(inner) => {
5386 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5387 },
5388 Self::ERC1967InvalidImplementation(inner) => {
5389 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encode_raw(
5390 inner, out,
5391 )
5392 },
5393 Self::ERC1967NonPayable(inner) => {
5394 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5395 },
5396 Self::ERC20InsufficientAllowance(inner) => {
5397 <ERC20InsufficientAllowance as alloy_sol_types::SolError>::abi_encode_raw(
5398 inner, out,
5399 )
5400 },
5401 Self::ERC20InsufficientBalance(inner) => {
5402 <ERC20InsufficientBalance as alloy_sol_types::SolError>::abi_encode_raw(
5403 inner, out,
5404 )
5405 },
5406 Self::ERC20InvalidApprover(inner) => {
5407 <ERC20InvalidApprover as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5408 },
5409 Self::ERC20InvalidReceiver(inner) => {
5410 <ERC20InvalidReceiver as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5411 },
5412 Self::ERC20InvalidSender(inner) => {
5413 <ERC20InvalidSender as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5414 },
5415 Self::ERC20InvalidSpender(inner) => {
5416 <ERC20InvalidSpender as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5417 },
5418 Self::FailedInnerCall(inner) => {
5419 <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5420 },
5421 Self::InvalidInitialization(inner) => {
5422 <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5423 },
5424 Self::NotInitializing(inner) => {
5425 <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5426 },
5427 Self::OwnableInvalidOwner(inner) => {
5428 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5429 },
5430 Self::OwnableUnauthorizedAccount(inner) => {
5431 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
5432 inner, out,
5433 )
5434 },
5435 Self::UUPSUnauthorizedCallContext(inner) => {
5436 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encode_raw(
5437 inner, out,
5438 )
5439 },
5440 Self::UUPSUnsupportedProxiableUUID(inner) => {
5441 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encode_raw(
5442 inner, out,
5443 )
5444 },
5445 }
5446 }
5447 }
5448 #[derive(Debug, PartialEq, Eq, Hash)]
5450 pub enum EspTokenEvents {
5451 #[allow(missing_docs)]
5452 Approval(Approval),
5453 #[allow(missing_docs)]
5454 Initialized(Initialized),
5455 #[allow(missing_docs)]
5456 OwnershipTransferred(OwnershipTransferred),
5457 #[allow(missing_docs)]
5458 Transfer(Transfer),
5459 #[allow(missing_docs)]
5460 Upgrade(Upgrade),
5461 #[allow(missing_docs)]
5462 Upgraded(Upgraded),
5463 }
5464 #[automatically_derived]
5465 impl EspTokenEvents {
5466 pub const SELECTORS: &'static [[u8; 32usize]] = &[
5473 [
5474 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8,
5475 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8,
5476 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
5477 ],
5478 [
5479 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
5480 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
5481 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
5482 ],
5483 [
5484 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, 179u8,
5485 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, 192u8, 34u8,
5486 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
5487 ],
5488 [
5489 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8,
5490 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8,
5491 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
5492 ],
5493 [
5494 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
5495 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
5496 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
5497 ],
5498 [
5499 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8,
5500 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, 237u8,
5501 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
5502 ],
5503 ];
5504 }
5505 #[automatically_derived]
5506 impl alloy_sol_types::SolEventInterface for EspTokenEvents {
5507 const NAME: &'static str = "EspTokenEvents";
5508 const COUNT: usize = 6usize;
5509 fn decode_raw_log(
5510 topics: &[alloy_sol_types::Word],
5511 data: &[u8],
5512 validate: bool,
5513 ) -> alloy_sol_types::Result<Self> {
5514 match topics.first().copied() {
5515 Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5516 <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
5517 .map(Self::Approval)
5518 },
5519 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5520 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
5521 topics, data, validate,
5522 )
5523 .map(Self::Initialized)
5524 },
5525 Some(<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5526 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
5527 topics, data, validate,
5528 )
5529 .map(Self::OwnershipTransferred)
5530 },
5531 Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5532 <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
5533 .map(Self::Transfer)
5534 },
5535 Some(<Upgrade as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5536 <Upgrade as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
5537 .map(Self::Upgrade)
5538 },
5539 Some(<Upgraded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5540 <Upgraded as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
5541 .map(Self::Upgraded)
5542 },
5543 _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
5544 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
5545 log: alloy_sol_types::private::Box::new(
5546 alloy_sol_types::private::LogData::new_unchecked(
5547 topics.to_vec(),
5548 data.to_vec().into(),
5549 ),
5550 ),
5551 }),
5552 }
5553 }
5554 }
5555 #[automatically_derived]
5556 impl alloy_sol_types::private::IntoLogData for EspTokenEvents {
5557 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5558 match self {
5559 Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
5560 Self::Initialized(inner) => {
5561 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5562 },
5563 Self::OwnershipTransferred(inner) => {
5564 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5565 },
5566 Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
5567 Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
5568 Self::Upgraded(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
5569 }
5570 }
5571 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5572 match self {
5573 Self::Approval(inner) => {
5574 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5575 },
5576 Self::Initialized(inner) => {
5577 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5578 },
5579 Self::OwnershipTransferred(inner) => {
5580 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5581 },
5582 Self::Transfer(inner) => {
5583 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5584 },
5585 Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
5586 Self::Upgraded(inner) => {
5587 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5588 },
5589 }
5590 }
5591 }
5592 use alloy::contract as alloy_contract;
5593 #[inline]
5597 pub const fn new<
5598 T: alloy_contract::private::Transport + ::core::clone::Clone,
5599 P: alloy_contract::private::Provider<T, N>,
5600 N: alloy_contract::private::Network,
5601 >(
5602 address: alloy_sol_types::private::Address,
5603 provider: P,
5604 ) -> EspTokenInstance<T, P, N> {
5605 EspTokenInstance::<T, P, N>::new(address, provider)
5606 }
5607 #[inline]
5613 pub fn deploy<
5614 T: alloy_contract::private::Transport + ::core::clone::Clone,
5615 P: alloy_contract::private::Provider<T, N>,
5616 N: alloy_contract::private::Network,
5617 >(
5618 provider: P,
5619 ) -> impl ::core::future::Future<Output = alloy_contract::Result<EspTokenInstance<T, P, N>>>
5620 {
5621 EspTokenInstance::<T, P, N>::deploy(provider)
5622 }
5623 #[inline]
5629 pub fn deploy_builder<
5630 T: alloy_contract::private::Transport + ::core::clone::Clone,
5631 P: alloy_contract::private::Provider<T, N>,
5632 N: alloy_contract::private::Network,
5633 >(
5634 provider: P,
5635 ) -> alloy_contract::RawCallBuilder<T, P, N> {
5636 EspTokenInstance::<T, P, N>::deploy_builder(provider)
5637 }
5638 #[derive(Clone)]
5650 pub struct EspTokenInstance<T, P, N = alloy_contract::private::Ethereum> {
5651 address: alloy_sol_types::private::Address,
5652 provider: P,
5653 _network_transport: ::core::marker::PhantomData<(N, T)>,
5654 }
5655 #[automatically_derived]
5656 impl<T, P, N> ::core::fmt::Debug for EspTokenInstance<T, P, N> {
5657 #[inline]
5658 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5659 f.debug_tuple("EspTokenInstance")
5660 .field(&self.address)
5661 .finish()
5662 }
5663 }
5664 #[automatically_derived]
5666 impl<
5667 T: alloy_contract::private::Transport + ::core::clone::Clone,
5668 P: alloy_contract::private::Provider<T, N>,
5669 N: alloy_contract::private::Network,
5670 > EspTokenInstance<T, P, N>
5671 {
5672 #[inline]
5676 pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
5677 Self {
5678 address,
5679 provider,
5680 _network_transport: ::core::marker::PhantomData,
5681 }
5682 }
5683 #[inline]
5689 pub async fn deploy(provider: P) -> alloy_contract::Result<EspTokenInstance<T, P, N>> {
5690 let call_builder = Self::deploy_builder(provider);
5691 let contract_address = call_builder.deploy().await?;
5692 Ok(Self::new(contract_address, call_builder.provider))
5693 }
5694 #[inline]
5700 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
5701 alloy_contract::RawCallBuilder::new_raw_deploy(
5702 provider,
5703 ::core::clone::Clone::clone(&BYTECODE),
5704 )
5705 }
5706 #[inline]
5708 pub const fn address(&self) -> &alloy_sol_types::private::Address {
5709 &self.address
5710 }
5711 #[inline]
5713 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
5714 self.address = address;
5715 }
5716 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
5718 self.set_address(address);
5719 self
5720 }
5721 #[inline]
5723 pub const fn provider(&self) -> &P {
5724 &self.provider
5725 }
5726 }
5727 impl<T, P: ::core::clone::Clone, N> EspTokenInstance<T, &P, N> {
5728 #[inline]
5730 pub fn with_cloned_provider(self) -> EspTokenInstance<T, P, N> {
5731 EspTokenInstance {
5732 address: self.address,
5733 provider: ::core::clone::Clone::clone(&self.provider),
5734 _network_transport: ::core::marker::PhantomData,
5735 }
5736 }
5737 }
5738 #[automatically_derived]
5740 impl<
5741 T: alloy_contract::private::Transport + ::core::clone::Clone,
5742 P: alloy_contract::private::Provider<T, N>,
5743 N: alloy_contract::private::Network,
5744 > EspTokenInstance<T, P, N>
5745 {
5746 pub fn call_builder<C: alloy_sol_types::SolCall>(
5751 &self,
5752 call: &C,
5753 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
5754 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
5755 }
5756 pub fn UPGRADE_INTERFACE_VERSION(
5758 &self,
5759 ) -> alloy_contract::SolCallBuilder<T, &P, UPGRADE_INTERFACE_VERSIONCall, N> {
5760 self.call_builder(&UPGRADE_INTERFACE_VERSIONCall {})
5761 }
5762 pub fn allowance(
5764 &self,
5765 owner: alloy::sol_types::private::Address,
5766 spender: alloy::sol_types::private::Address,
5767 ) -> alloy_contract::SolCallBuilder<T, &P, allowanceCall, N> {
5768 self.call_builder(&allowanceCall { owner, spender })
5769 }
5770 pub fn approve(
5772 &self,
5773 spender: alloy::sol_types::private::Address,
5774 value: alloy::sol_types::private::primitives::aliases::U256,
5775 ) -> alloy_contract::SolCallBuilder<T, &P, approveCall, N> {
5776 self.call_builder(&approveCall { spender, value })
5777 }
5778 pub fn balanceOf(
5780 &self,
5781 account: alloy::sol_types::private::Address,
5782 ) -> alloy_contract::SolCallBuilder<T, &P, balanceOfCall, N> {
5783 self.call_builder(&balanceOfCall { account })
5784 }
5785 pub fn decimals(&self) -> alloy_contract::SolCallBuilder<T, &P, decimalsCall, N> {
5787 self.call_builder(&decimalsCall {})
5788 }
5789 pub fn getVersion(&self) -> alloy_contract::SolCallBuilder<T, &P, getVersionCall, N> {
5791 self.call_builder(&getVersionCall {})
5792 }
5793 pub fn initialize(
5795 &self,
5796 _owner: alloy::sol_types::private::Address,
5797 _initialGrantRecipient: alloy::sol_types::private::Address,
5798 ) -> alloy_contract::SolCallBuilder<T, &P, initializeCall, N> {
5799 self.call_builder(&initializeCall {
5800 _owner,
5801 _initialGrantRecipient,
5802 })
5803 }
5804 pub fn name(&self) -> alloy_contract::SolCallBuilder<T, &P, nameCall, N> {
5806 self.call_builder(&nameCall {})
5807 }
5808 pub fn owner(&self) -> alloy_contract::SolCallBuilder<T, &P, ownerCall, N> {
5810 self.call_builder(&ownerCall {})
5811 }
5812 pub fn proxiableUUID(&self) -> alloy_contract::SolCallBuilder<T, &P, proxiableUUIDCall, N> {
5814 self.call_builder(&proxiableUUIDCall {})
5815 }
5816 pub fn renounceOwnership(
5818 &self,
5819 ) -> alloy_contract::SolCallBuilder<T, &P, renounceOwnershipCall, N> {
5820 self.call_builder(&renounceOwnershipCall {})
5821 }
5822 pub fn symbol(&self) -> alloy_contract::SolCallBuilder<T, &P, symbolCall, N> {
5824 self.call_builder(&symbolCall {})
5825 }
5826 pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<T, &P, totalSupplyCall, N> {
5828 self.call_builder(&totalSupplyCall {})
5829 }
5830 pub fn transfer(
5832 &self,
5833 to: alloy::sol_types::private::Address,
5834 value: alloy::sol_types::private::primitives::aliases::U256,
5835 ) -> alloy_contract::SolCallBuilder<T, &P, transferCall, N> {
5836 self.call_builder(&transferCall { to, value })
5837 }
5838 pub fn transferFrom(
5840 &self,
5841 from: alloy::sol_types::private::Address,
5842 to: alloy::sol_types::private::Address,
5843 value: alloy::sol_types::private::primitives::aliases::U256,
5844 ) -> alloy_contract::SolCallBuilder<T, &P, transferFromCall, N> {
5845 self.call_builder(&transferFromCall { from, to, value })
5846 }
5847 pub fn transferOwnership(
5849 &self,
5850 newOwner: alloy::sol_types::private::Address,
5851 ) -> alloy_contract::SolCallBuilder<T, &P, transferOwnershipCall, N> {
5852 self.call_builder(&transferOwnershipCall { newOwner })
5853 }
5854 pub fn upgradeToAndCall(
5856 &self,
5857 newImplementation: alloy::sol_types::private::Address,
5858 data: alloy::sol_types::private::Bytes,
5859 ) -> alloy_contract::SolCallBuilder<T, &P, upgradeToAndCallCall, N> {
5860 self.call_builder(&upgradeToAndCallCall {
5861 newImplementation,
5862 data,
5863 })
5864 }
5865 }
5866 #[automatically_derived]
5868 impl<
5869 T: alloy_contract::private::Transport + ::core::clone::Clone,
5870 P: alloy_contract::private::Provider<T, N>,
5871 N: alloy_contract::private::Network,
5872 > EspTokenInstance<T, P, N>
5873 {
5874 pub fn event_filter<E: alloy_sol_types::SolEvent>(
5879 &self,
5880 ) -> alloy_contract::Event<T, &P, E, N> {
5881 alloy_contract::Event::new_sol(&self.provider, &self.address)
5882 }
5883 pub fn Approval_filter(&self) -> alloy_contract::Event<T, &P, Approval, N> {
5885 self.event_filter::<Approval>()
5886 }
5887 pub fn Initialized_filter(&self) -> alloy_contract::Event<T, &P, Initialized, N> {
5889 self.event_filter::<Initialized>()
5890 }
5891 pub fn OwnershipTransferred_filter(
5893 &self,
5894 ) -> alloy_contract::Event<T, &P, OwnershipTransferred, N> {
5895 self.event_filter::<OwnershipTransferred>()
5896 }
5897 pub fn Transfer_filter(&self) -> alloy_contract::Event<T, &P, Transfer, N> {
5899 self.event_filter::<Transfer>()
5900 }
5901 pub fn Upgrade_filter(&self) -> alloy_contract::Event<T, &P, Upgrade, N> {
5903 self.event_filter::<Upgrade>()
5904 }
5905 pub fn Upgraded_filter(&self) -> alloy_contract::Event<T, &P, Upgraded, N> {
5907 self.event_filter::<Upgraded>()
5908 }
5909 }
5910}