1#[allow(
492 non_camel_case_types,
493 non_snake_case,
494 clippy::pub_underscore_fields,
495 clippy::style,
496 clippy::empty_structs_with_brackets
497)]
498pub mod SimpleERC721 {
499 use super::*;
500 use alloy::sol_types as alloy_sol_types;
501 #[rustfmt::skip]
507 #[allow(clippy::all)]
508 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
509 b"`\x80\x80`@R4a\x034W`@\x81a\x10a\x808\x03\x80\x91a\0\x1F\x82\x85a\x05vV[\x839\x81\x01\x03\x12a\x034W\x80Q\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x90\x81\x83\x03a\x034W` \x01Q`@\x92\x83Qa\0Q\x85\x82a\x05vV[`\x0C\x81RkSimpleERC721`\xA0\x1B` \x82\x01R\x84Q\x90a\0w\x86\x83a\x05vV[`\x06\x82ReSIM721`\xD0\x1B` \x83\x01R\x80Q\x90`\x01`\x01`@\x1B\x03\x82\x11a\x02\xA7W_T\x90`\x01\x82\x81\x1C\x92\x16\x80\x15a\x05lW[` \x83\x10\x14a\x04sW\x81`\x1F\x84\x93\x11a\x04\xFFW[P` \x90`\x1F\x83\x11`\x01\x14a\x04\x9CW_\x92a\x04\x91W[PP\x81`\x01\x1B\x91_\x19\x90`\x03\x1B\x1C\x19\x16\x17_U[\x80Q\x90`\x01`\x01`@\x1B\x03\x82\x11a\x02\xA7W`\x01T\x90`\x01\x82\x81\x1C\x92\x16\x80\x15a\x04\x87W[` \x83\x10\x14a\x04sW\x81`\x1F\x84\x93\x11a\x04\x05W[P` \x90`\x1F\x83\x11`\x01\x14a\x03\x9FW_\x92a\x03\x94W[PP\x81`\x01\x1B\x91_\x19\x90`\x03\x1B\x1C\x19\x16\x17`\x01U[\x83Q` \x92a\x01[\x84\x83a\x05vV[_\x82R\x84\x15a\x03\x81W_\x81\x81R`\x02\x85R\x86\x90 T`\x01`\x01`\xA0\x1B\x03\x16\x92\x83\x15\x15\x80a\x03RW[_\x87\x81R`\x03\x87R\x88\x81 \x80T`\x01\x01\x90U\x83\x81R`\x02\x87R\x88\x81 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x89\x17\x90U\x88Q\x95\x84\x91\x89\x91\x90\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x90\x80\xA4a\x03?W;a\x01\xF3W[\x85Qa\n\xC7\x90\x81a\x05\x9A\x829\xF3[`\xA4\x83\x85\x80\x97\x98\x96\x94\x82\x94c\n\x85\xBD\x01`\xE1\x1B\x84R3`\x04\x85\x01R_`$\x85\x01R`D\x84\x01R`\x80`d\x84\x01R\x80Q\x91\x82\x91\x82`\x84\x86\x01R\x01\x84\x84\x01^_\x83\x82\x84\x01\x01R`\x1F\x80\x19\x91\x01\x16\x81\x01\x03\x01\x81_\x88Z\xF1_\x91\x81a\x02\xFBW[Pa\x02\xC3WP=\x15a\x02\xBBW=`\x01`\x01`@\x1B\x03\x81\x11a\x02\xA7W\x90Q\x90a\x02\x80`\x1F\x82\x01`\x1F\x19\x16\x84\x01\x83a\x05vV[\x81R=_\x83\x83\x01>[\x80Q\x91\x82a\x02\xA4W\x83c2PWI`\xE1\x1B_R`\x04R`$_\xFD[\x01\xFD[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[P``a\x02\x89V[\x90\x92\x91P`\x01`\x01`\xE0\x1B\x03\x19\x16cuzB\xFF`\xE1\x1B\x01a\x02\xE9WP_\x80\x80\x80\x80a\x01\xE5V[c2PWI`\xE1\x1B_R`\x04R`$_\xFD[\x90\x91P\x83\x81\x81=\x83\x11a\x038W[a\x03\x13\x81\x83a\x05vV[\x81\x01\x03\x12a\x034WQ`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x03a\x034W\x90_a\x02OV[_\x80\xFD[P=a\x03\tV[c9\xE3V7`\xE1\x1B_R_`\x04R`$_\xFD[_\x83\x81R`\x04\x87R\x88\x81 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U\x85\x81R`\x03\x87R\x88\x90 \x80T_\x19\x01\x90Ua\x01\x83V[c2PWI`\xE1\x1B_R_`\x04R`$_\xFD[\x01Q\x90P_\x80a\x017V[`\x01_\x90\x81R\x82\x81 \x93P`\x1F\x19\x85\x16\x90[\x81\x81\x10a\x03\xEDWP\x90\x84`\x01\x95\x94\x93\x92\x10a\x03\xD5W[PPP\x81\x1B\x01`\x01Ua\x01LV[\x01Q_\x19`\xF8\x84`\x03\x1B\x16\x1C\x19\x16\x90U_\x80\x80a\x03\xC7V[\x92\x93` `\x01\x81\x92\x87\x86\x01Q\x81U\x01\x95\x01\x93\x01a\x03\xB1V[`\x01_R\x90\x91P\x7F\xB1\x0E-Rv\x12\x07;&\xEE\xCD\xFDq~j2\x0C\xF4KJ\xFA\xC2\xB0s-\x9F\xCB\xE2\xB7\xFA\x0C\xF6`\x1F\x84\x01`\x05\x1C\x81\x01\x91` \x85\x10a\x04iW[\x90`\x1F\x85\x94\x93\x92\x01`\x05\x1C\x01\x90[\x81\x81\x10a\x04[WPa\x01!V[_\x81U\x84\x93P`\x01\x01a\x04NV[\x90\x91P\x81\x90a\x04@V[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x91`\x7F\x16\x91a\x01\rV[\x01Q\x90P_\x80a\0\xD6V[_\x80\x80R\x82\x81 \x93P`\x1F\x19\x85\x16\x90[\x81\x81\x10a\x04\xE7WP\x90\x84`\x01\x95\x94\x93\x92\x10a\x04\xCFW[PPP\x81\x1B\x01_Ua\0\xEAV[\x01Q_\x19`\xF8\x84`\x03\x1B\x16\x1C\x19\x16\x90U_\x80\x80a\x04\xC2V[\x92\x93` `\x01\x81\x92\x87\x86\x01Q\x81U\x01\x95\x01\x93\x01a\x04\xACV[_\x80R\x90\x91P\x7F)\r\xEC\xD9T\x8Bb\xA8\xD6\x03E\xA9\x888o\xC8K\xA6\xBC\x95H@\x08\xF66/\x93\x16\x0E\xF3\xE5c`\x1F\x84\x01`\x05\x1C\x81\x01\x91` \x85\x10a\x05bW[\x90`\x1F\x85\x94\x93\x92\x01`\x05\x1C\x01\x90[\x81\x81\x10a\x05TWPa\0\xC0V[_\x81U\x84\x93P`\x01\x01a\x05GV[\x90\x91P\x81\x90a\x059V[\x91`\x7F\x16\x91a\0\xACV[`\x1F\x90\x91\x01`\x1F\x19\x16\x81\x01\x90`\x01`\x01`@\x1B\x03\x82\x11\x90\x82\x10\x17a\x02\xA7W`@RV\xFE`\x80\x80`@R`\x046\x10\x15a\0\x12W_\x80\xFD[_\x90_5`\xE0\x1C\x90\x81c\x01\xFF\xC9\xA7\x14a\x060WP\x80c\x06\xFD\xDE\x03\x14a\x05xW\x80c\x08\x18\x12\xFC\x14a\x05<W\x80c\t^\xA7\xB3\x14a\x04RW\x80c#\xB8r\xDD\x14a\x04;W\x80cB\x84.\x0E\x14a\x04\x12W\x80ccR!\x1E\x14a\x03\xE2W\x80cp\xA0\x821\x14a\x03\x91W\x80c\x95\xD8\x9BA\x14a\x02\x89W\x80c\xA2,\xB4e\x14a\x01\xEEW\x80c\xB8\x8DO\xDE\x14a\x01dW\x80c\xC8{V\xDD\x14a\x01\x07Wc\xE9\x85\xE9\xC5\x14a\0\xADW_\x80\xFD[4a\x01\x04W`@6`\x03\x19\x01\x12a\x01\x04W`@a\0\xC8a\x06\xBFV[\x91a\0\xD1a\x06\xD5V[\x92`\x01\x80`\xA0\x1B\x03\x16\x81R`\x05` R \x90`\x01\x80`\xA0\x1B\x03\x16_R` R` `\xFF`@_ T\x16`@Q\x90\x15\x15\x81R\xF3[\x80\xFD[4a\x01`W` 6`\x03\x19\x01\x12a\x01`Wa\x01#`\x045a\n]V[P_`@Qa\x013` \x82a\x07%V[Ra\x01\\`@Qa\x01E` \x82a\x07%V[_\x81R`@Q\x91\x82\x91` \x83R` \x83\x01\x90a\x06\x9BV[\x03\x90\xF3[_\x80\xFD[4a\x01`W`\x806`\x03\x19\x01\x12a\x01`Wa\x01}a\x06\xBFV[a\x01\x85a\x06\xD5V[`d5\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x01`W6`#\x84\x01\x12\x15a\x01`W\x82`\x04\x015\x91a\x01\xB2\x83a\x07[V[\x92a\x01\xC0`@Q\x94\x85a\x07%V[\x80\x84R6`$\x82\x87\x01\x01\x11a\x01`W` \x81_\x92`$a\x01\xEC\x98\x01\x83\x88\x017\x85\x01\x01R`D5\x91a\t\x1DV[\0[4a\x01`W`@6`\x03\x19\x01\x12a\x01`Wa\x02\x07a\x06\xBFV[`$5\x90\x81\x15\x15\x80\x92\x03a\x01`W`\x01`\x01`\xA0\x1B\x03\x16\x90\x81\x15a\x02vW3_R`\x05` R`@_ \x82_R` R`@_ `\xFF\x19\x81T\x16`\xFF\x83\x16\x17\x90U`@Q\x90\x81R\x7F\x170~\xAB9\xABa\x07\xE8\x89\x98E\xAD=Y\xBD\x96S\xF2\0\xF2 \x92\x04\x89\xCA+Y7il1` 3\x92\xA3\0[Pc\x0Ba\x17C`\xE3\x1B_R`\x04R`$_\xFD[4a\x01`W_6`\x03\x19\x01\x12a\x01`W`@Q_`\x01T\x80`\x01\x1C\x90`\x01\x81\x16\x80\x15a\x03\x87W[` \x83\x10\x81\x14a\x03sW\x82\x85R\x90\x81\x15a\x03OWP`\x01\x14a\x02\xF1W[a\x01\\\x83a\x02\xDD\x81\x85\x03\x82a\x07%V[`@Q\x91\x82\x91` \x83R` \x83\x01\x90a\x06\x9BV[\x91\x90P`\x01_R\x7F\xB1\x0E-Rv\x12\x07;&\xEE\xCD\xFDq~j2\x0C\xF4KJ\xFA\xC2\xB0s-\x9F\xCB\xE2\xB7\xFA\x0C\xF6\x91_\x90[\x80\x82\x10a\x035WP\x90\x91P\x81\x01` \x01a\x02\xDDa\x02\xCDV[\x91\x92`\x01\x81` \x92T\x83\x85\x88\x01\x01R\x01\x91\x01\x90\x92\x91a\x03\x1DV[`\xFF\x19\x16` \x80\x86\x01\x91\x90\x91R\x91\x15\x15`\x05\x1B\x84\x01\x90\x91\x01\x91Pa\x02\xDD\x90Pa\x02\xCDV[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x91`\x7F\x16\x91a\x02\xB0V[4a\x01`W` 6`\x03\x19\x01\x12a\x01`W`\x01`\x01`\xA0\x1B\x03a\x03\xB2a\x06\xBFV[\x16\x80\x15a\x03\xCFW_R`\x03` R` `@_ T`@Q\x90\x81R\xF3[c\"q\x8A\xD9`\xE2\x1B_R_`\x04R`$_\xFD[4a\x01`W` 6`\x03\x19\x01\x12a\x01`W` a\x04\0`\x045a\n]V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R\xF3[4a\x01`Wa\x01\xECa\x04#6a\x06\xEBV[\x90`@Q\x92a\x043` \x85a\x07%V[_\x84Ra\t\x1DV[4a\x01`Wa\x01\xECa\x04L6a\x06\xEBV[\x91a\x07wV[4a\x01`W`@6`\x03\x19\x01\x12a\x01`Wa\x04ka\x06\xBFV[`$5a\x04w\x81a\n]V[3\x15\x15\x80a\x05)W[\x80a\x04\xFCW[a\x04\xE9W\x81\x90`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x16\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%_\x80\xA4_\x90\x81R`\x04` R`@\x90 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x90\x92\x16\x91\x90\x91\x17\x90U\0[c\xA9\xFB\xF5\x1F`\xE0\x1B_R3`\x04R`$_\xFD[P`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x05` \x90\x81R`@\x80\x83 3\x84R\x90\x91R\x90 T`\xFF\x16\x15a\x04\x86V[P`\x01`\x01`\xA0\x1B\x03\x81\x163\x14\x15a\x04\x80V[4a\x01`W` 6`\x03\x19\x01\x12a\x01`W`\x045a\x05Y\x81a\n]V[P_R`\x04` R` `\x01\x80`\xA0\x1B\x03`@_ T\x16`@Q\x90\x81R\xF3[4a\x01`W_6`\x03\x19\x01\x12a\x01`W`@Q__T\x80`\x01\x1C\x90`\x01\x81\x16\x80\x15a\x06&W[` \x83\x10\x81\x14a\x03sW\x82\x85R\x90\x81\x15a\x03OWP`\x01\x14a\x05\xCAWa\x01\\\x83a\x02\xDD\x81\x85\x03\x82a\x07%V[_\x80\x80R\x7F)\r\xEC\xD9T\x8Bb\xA8\xD6\x03E\xA9\x888o\xC8K\xA6\xBC\x95H@\x08\xF66/\x93\x16\x0E\xF3\xE5c\x93\x92P\x90[\x80\x82\x10a\x06\x0CWP\x90\x91P\x81\x01` \x01a\x02\xDDa\x02\xCDV[\x91\x92`\x01\x81` \x92T\x83\x85\x88\x01\x01R\x01\x91\x01\x90\x92\x91a\x05\xF4V[\x91`\x7F\x16\x91a\x05\x9EV[4a\x01`W` 6`\x03\x19\x01\x12a\x01`W`\x045\x90c\xFF\xFF\xFF\xFF`\xE0\x1B\x82\x16\x80\x92\x03a\x01`W` \x91c\x80\xACX\xCD`\xE0\x1B\x81\x14\x90\x81\x15a\x06\x8AW[\x81\x15a\x06yW[P\x15\x15\x81R\xF3[c\x01\xFF\xC9\xA7`\xE0\x1B\x14\x90P\x83a\x06rV[c[^\x13\x9F`\xE0\x1B\x81\x14\x91Pa\x06kV[\x80Q\x80\x83R` \x92\x91\x81\x90\x84\x01\x84\x84\x01^_\x82\x82\x01\x84\x01R`\x1F\x01`\x1F\x19\x16\x01\x01\x90V[`\x045\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x01`WV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x01`WV[``\x90`\x03\x19\x01\x12a\x01`W`\x045`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x01`W\x90`$5`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x01`W\x90`D5\x90V[\x90`\x1F\x80\x19\x91\x01\x16\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x07GW`@RV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x07GW`\x1F\x01`\x1F\x19\x16` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91\x90\x82\x15a\t\nW_\x82\x81R`\x02` R`@\x90 T`\x01`\x01`\xA0\x1B\x03\x16\x92\x82\x903\x15\x15\x80a\x08uW[P\x84a\x08<W[\x80_R`\x03` R`@_ `\x01\x81T\x01\x90U\x81_R`\x02` R`@_ \x81k\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\xA0\x1B\x82T\x16\x17\x90U\x84\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF_\x80\xA4`\x01`\x01`\xA0\x1B\x03\x16\x80\x83\x03a\x08$WPPPV[cd(={`\xE0\x1B_R`\x04R`$R`DR`d_\xFD[\x81_R`\x04` R`@_ k\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\xA0\x1B\x81T\x16\x90U\x84_R`\x03` R`@_ _\x19\x81T\x01\x90Ua\x07\xB4V[\x90\x91P\x80a\x08\xB9W[\x15a\x08\x8BW\x82\x90_a\x07\xADV[\x82\x84a\x08\xA3Wc~'2\x89`\xE0\x1B_R`\x04R`$_\xFD[c\x17~\x80/`\xE0\x1B_R3`\x04R`$R`D_\xFD[P3\x84\x14\x80\x15a\x08\xE8W[\x80a\x08~WP_\x83\x81R`\x04` R`@\x90 T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x08~V[P_\x84\x81R`\x05` \x90\x81R`@\x80\x83 3\x84R\x90\x91R\x90 T`\xFF\x16a\x08\xC4V[c2PWI`\xE1\x1B_R_`\x04R`$_\xFD[\x92\x91a\t*\x81\x83\x86a\x07wV[\x81;a\t7W[PPPPV[`@Qc\n\x85\xBD\x01`\xE1\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`$\x82\x01R`D\x81\x01\x91\x90\x91R`\x80`d\x82\x01R\x92\x16\x91\x90` \x90\x82\x90\x81\x90a\t\x82\x90`\x84\x83\x01\x90a\x06\x9BV[\x03\x81_\x86Z\xF1_\x91\x81a\n\x18W[Pa\t\xE5WP=\x15a\t\xDEW=a\t\xA6\x81a\x07[V[\x90a\t\xB4`@Q\x92\x83a\x07%V[\x81R=_` \x83\x01>[\x80Q\x90\x81a\t\xD9W\x82c2PWI`\xE1\x1B_R`\x04R`$_\xFD[` \x01\xFD[``a\t\xBEV[`\x01`\x01`\xE0\x1B\x03\x19\x16cuzB\xFF`\xE1\x1B\x01a\n\x06WP_\x80\x80\x80a\t1V[c2PWI`\xE1\x1B_R`\x04R`$_\xFD[\x90\x91P` \x81=` \x11a\nUW[\x81a\n4` \x93\x83a\x07%V[\x81\x01\x03\x12a\x01`WQ`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x03a\x01`W\x90_a\t\x90V[=\x91Pa\n'V[_\x81\x81R`\x02` R`@\x90 T`\x01`\x01`\xA0\x1B\x03\x16\x90\x81\x15a\n\x7FWP\x90V[c~'2\x89`\xE0\x1B_R`\x04R`$_\xFD\xFE\xA2dipfsX\"\x12 =\xE2\xFA\xFA\x8E0\x01k\xCC\xB2\x826\x06\xE8\x83\x16\x14)4\x19\xC0\xCA\x0E6'\xEE\xE3\x88l\0\x11\xD9dsolcC\0\x08\x1E\x003",
510 );
511 #[rustfmt::skip]
517 #[allow(clippy::all)]
518 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
519 b"`\x80\x80`@R`\x046\x10\x15a\0\x12W_\x80\xFD[_\x90_5`\xE0\x1C\x90\x81c\x01\xFF\xC9\xA7\x14a\x060WP\x80c\x06\xFD\xDE\x03\x14a\x05xW\x80c\x08\x18\x12\xFC\x14a\x05<W\x80c\t^\xA7\xB3\x14a\x04RW\x80c#\xB8r\xDD\x14a\x04;W\x80cB\x84.\x0E\x14a\x04\x12W\x80ccR!\x1E\x14a\x03\xE2W\x80cp\xA0\x821\x14a\x03\x91W\x80c\x95\xD8\x9BA\x14a\x02\x89W\x80c\xA2,\xB4e\x14a\x01\xEEW\x80c\xB8\x8DO\xDE\x14a\x01dW\x80c\xC8{V\xDD\x14a\x01\x07Wc\xE9\x85\xE9\xC5\x14a\0\xADW_\x80\xFD[4a\x01\x04W`@6`\x03\x19\x01\x12a\x01\x04W`@a\0\xC8a\x06\xBFV[\x91a\0\xD1a\x06\xD5V[\x92`\x01\x80`\xA0\x1B\x03\x16\x81R`\x05` R \x90`\x01\x80`\xA0\x1B\x03\x16_R` R` `\xFF`@_ T\x16`@Q\x90\x15\x15\x81R\xF3[\x80\xFD[4a\x01`W` 6`\x03\x19\x01\x12a\x01`Wa\x01#`\x045a\n]V[P_`@Qa\x013` \x82a\x07%V[Ra\x01\\`@Qa\x01E` \x82a\x07%V[_\x81R`@Q\x91\x82\x91` \x83R` \x83\x01\x90a\x06\x9BV[\x03\x90\xF3[_\x80\xFD[4a\x01`W`\x806`\x03\x19\x01\x12a\x01`Wa\x01}a\x06\xBFV[a\x01\x85a\x06\xD5V[`d5\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x01`W6`#\x84\x01\x12\x15a\x01`W\x82`\x04\x015\x91a\x01\xB2\x83a\x07[V[\x92a\x01\xC0`@Q\x94\x85a\x07%V[\x80\x84R6`$\x82\x87\x01\x01\x11a\x01`W` \x81_\x92`$a\x01\xEC\x98\x01\x83\x88\x017\x85\x01\x01R`D5\x91a\t\x1DV[\0[4a\x01`W`@6`\x03\x19\x01\x12a\x01`Wa\x02\x07a\x06\xBFV[`$5\x90\x81\x15\x15\x80\x92\x03a\x01`W`\x01`\x01`\xA0\x1B\x03\x16\x90\x81\x15a\x02vW3_R`\x05` R`@_ \x82_R` R`@_ `\xFF\x19\x81T\x16`\xFF\x83\x16\x17\x90U`@Q\x90\x81R\x7F\x170~\xAB9\xABa\x07\xE8\x89\x98E\xAD=Y\xBD\x96S\xF2\0\xF2 \x92\x04\x89\xCA+Y7il1` 3\x92\xA3\0[Pc\x0Ba\x17C`\xE3\x1B_R`\x04R`$_\xFD[4a\x01`W_6`\x03\x19\x01\x12a\x01`W`@Q_`\x01T\x80`\x01\x1C\x90`\x01\x81\x16\x80\x15a\x03\x87W[` \x83\x10\x81\x14a\x03sW\x82\x85R\x90\x81\x15a\x03OWP`\x01\x14a\x02\xF1W[a\x01\\\x83a\x02\xDD\x81\x85\x03\x82a\x07%V[`@Q\x91\x82\x91` \x83R` \x83\x01\x90a\x06\x9BV[\x91\x90P`\x01_R\x7F\xB1\x0E-Rv\x12\x07;&\xEE\xCD\xFDq~j2\x0C\xF4KJ\xFA\xC2\xB0s-\x9F\xCB\xE2\xB7\xFA\x0C\xF6\x91_\x90[\x80\x82\x10a\x035WP\x90\x91P\x81\x01` \x01a\x02\xDDa\x02\xCDV[\x91\x92`\x01\x81` \x92T\x83\x85\x88\x01\x01R\x01\x91\x01\x90\x92\x91a\x03\x1DV[`\xFF\x19\x16` \x80\x86\x01\x91\x90\x91R\x91\x15\x15`\x05\x1B\x84\x01\x90\x91\x01\x91Pa\x02\xDD\x90Pa\x02\xCDV[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x91`\x7F\x16\x91a\x02\xB0V[4a\x01`W` 6`\x03\x19\x01\x12a\x01`W`\x01`\x01`\xA0\x1B\x03a\x03\xB2a\x06\xBFV[\x16\x80\x15a\x03\xCFW_R`\x03` R` `@_ T`@Q\x90\x81R\xF3[c\"q\x8A\xD9`\xE2\x1B_R_`\x04R`$_\xFD[4a\x01`W` 6`\x03\x19\x01\x12a\x01`W` a\x04\0`\x045a\n]V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R\xF3[4a\x01`Wa\x01\xECa\x04#6a\x06\xEBV[\x90`@Q\x92a\x043` \x85a\x07%V[_\x84Ra\t\x1DV[4a\x01`Wa\x01\xECa\x04L6a\x06\xEBV[\x91a\x07wV[4a\x01`W`@6`\x03\x19\x01\x12a\x01`Wa\x04ka\x06\xBFV[`$5a\x04w\x81a\n]V[3\x15\x15\x80a\x05)W[\x80a\x04\xFCW[a\x04\xE9W\x81\x90`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x16\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%_\x80\xA4_\x90\x81R`\x04` R`@\x90 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x90\x92\x16\x91\x90\x91\x17\x90U\0[c\xA9\xFB\xF5\x1F`\xE0\x1B_R3`\x04R`$_\xFD[P`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x05` \x90\x81R`@\x80\x83 3\x84R\x90\x91R\x90 T`\xFF\x16\x15a\x04\x86V[P`\x01`\x01`\xA0\x1B\x03\x81\x163\x14\x15a\x04\x80V[4a\x01`W` 6`\x03\x19\x01\x12a\x01`W`\x045a\x05Y\x81a\n]V[P_R`\x04` R` `\x01\x80`\xA0\x1B\x03`@_ T\x16`@Q\x90\x81R\xF3[4a\x01`W_6`\x03\x19\x01\x12a\x01`W`@Q__T\x80`\x01\x1C\x90`\x01\x81\x16\x80\x15a\x06&W[` \x83\x10\x81\x14a\x03sW\x82\x85R\x90\x81\x15a\x03OWP`\x01\x14a\x05\xCAWa\x01\\\x83a\x02\xDD\x81\x85\x03\x82a\x07%V[_\x80\x80R\x7F)\r\xEC\xD9T\x8Bb\xA8\xD6\x03E\xA9\x888o\xC8K\xA6\xBC\x95H@\x08\xF66/\x93\x16\x0E\xF3\xE5c\x93\x92P\x90[\x80\x82\x10a\x06\x0CWP\x90\x91P\x81\x01` \x01a\x02\xDDa\x02\xCDV[\x91\x92`\x01\x81` \x92T\x83\x85\x88\x01\x01R\x01\x91\x01\x90\x92\x91a\x05\xF4V[\x91`\x7F\x16\x91a\x05\x9EV[4a\x01`W` 6`\x03\x19\x01\x12a\x01`W`\x045\x90c\xFF\xFF\xFF\xFF`\xE0\x1B\x82\x16\x80\x92\x03a\x01`W` \x91c\x80\xACX\xCD`\xE0\x1B\x81\x14\x90\x81\x15a\x06\x8AW[\x81\x15a\x06yW[P\x15\x15\x81R\xF3[c\x01\xFF\xC9\xA7`\xE0\x1B\x14\x90P\x83a\x06rV[c[^\x13\x9F`\xE0\x1B\x81\x14\x91Pa\x06kV[\x80Q\x80\x83R` \x92\x91\x81\x90\x84\x01\x84\x84\x01^_\x82\x82\x01\x84\x01R`\x1F\x01`\x1F\x19\x16\x01\x01\x90V[`\x045\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x01`WV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x01`WV[``\x90`\x03\x19\x01\x12a\x01`W`\x045`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x01`W\x90`$5`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x01`W\x90`D5\x90V[\x90`\x1F\x80\x19\x91\x01\x16\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x07GW`@RV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x07GW`\x1F\x01`\x1F\x19\x16` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91\x90\x82\x15a\t\nW_\x82\x81R`\x02` R`@\x90 T`\x01`\x01`\xA0\x1B\x03\x16\x92\x82\x903\x15\x15\x80a\x08uW[P\x84a\x08<W[\x80_R`\x03` R`@_ `\x01\x81T\x01\x90U\x81_R`\x02` R`@_ \x81k\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\xA0\x1B\x82T\x16\x17\x90U\x84\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF_\x80\xA4`\x01`\x01`\xA0\x1B\x03\x16\x80\x83\x03a\x08$WPPPV[cd(={`\xE0\x1B_R`\x04R`$R`DR`d_\xFD[\x81_R`\x04` R`@_ k\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\xA0\x1B\x81T\x16\x90U\x84_R`\x03` R`@_ _\x19\x81T\x01\x90Ua\x07\xB4V[\x90\x91P\x80a\x08\xB9W[\x15a\x08\x8BW\x82\x90_a\x07\xADV[\x82\x84a\x08\xA3Wc~'2\x89`\xE0\x1B_R`\x04R`$_\xFD[c\x17~\x80/`\xE0\x1B_R3`\x04R`$R`D_\xFD[P3\x84\x14\x80\x15a\x08\xE8W[\x80a\x08~WP_\x83\x81R`\x04` R`@\x90 T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x08~V[P_\x84\x81R`\x05` \x90\x81R`@\x80\x83 3\x84R\x90\x91R\x90 T`\xFF\x16a\x08\xC4V[c2PWI`\xE1\x1B_R_`\x04R`$_\xFD[\x92\x91a\t*\x81\x83\x86a\x07wV[\x81;a\t7W[PPPPV[`@Qc\n\x85\xBD\x01`\xE1\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`$\x82\x01R`D\x81\x01\x91\x90\x91R`\x80`d\x82\x01R\x92\x16\x91\x90` \x90\x82\x90\x81\x90a\t\x82\x90`\x84\x83\x01\x90a\x06\x9BV[\x03\x81_\x86Z\xF1_\x91\x81a\n\x18W[Pa\t\xE5WP=\x15a\t\xDEW=a\t\xA6\x81a\x07[V[\x90a\t\xB4`@Q\x92\x83a\x07%V[\x81R=_` \x83\x01>[\x80Q\x90\x81a\t\xD9W\x82c2PWI`\xE1\x1B_R`\x04R`$_\xFD[` \x01\xFD[``a\t\xBEV[`\x01`\x01`\xE0\x1B\x03\x19\x16cuzB\xFF`\xE1\x1B\x01a\n\x06WP_\x80\x80\x80a\t1V[c2PWI`\xE1\x1B_R`\x04R`$_\xFD[\x90\x91P` \x81=` \x11a\nUW[\x81a\n4` \x93\x83a\x07%V[\x81\x01\x03\x12a\x01`WQ`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x03a\x01`W\x90_a\t\x90V[=\x91Pa\n'V[_\x81\x81R`\x02` R`@\x90 T`\x01`\x01`\xA0\x1B\x03\x16\x90\x81\x15a\n\x7FWP\x90V[c~'2\x89`\xE0\x1B_R`\x04R`$_\xFD\xFE\xA2dipfsX\"\x12 =\xE2\xFA\xFA\x8E0\x01k\xCC\xB2\x826\x06\xE8\x83\x16\x14)4\x19\xC0\xCA\x0E6'\xEE\xE3\x88l\0\x11\xD9dsolcC\0\x08\x1E\x003",
520 );
521 #[derive(serde::Serialize, serde::Deserialize)]
522 #[derive(Default, Debug, PartialEq, Eq, Hash)]
523 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
528 #[derive(Clone)]
529 pub struct ERC721IncorrectOwner {
530 #[allow(missing_docs)]
531 pub sender: alloy::sol_types::private::Address,
532 #[allow(missing_docs)]
533 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
534 #[allow(missing_docs)]
535 pub owner: alloy::sol_types::private::Address,
536 }
537 #[allow(
538 non_camel_case_types,
539 non_snake_case,
540 clippy::pub_underscore_fields,
541 clippy::style
542 )]
543 const _: () = {
544 use alloy::sol_types as alloy_sol_types;
545 #[doc(hidden)]
546 #[allow(dead_code)]
547 type UnderlyingSolTuple<'a> = (
548 alloy::sol_types::sol_data::Address,
549 alloy::sol_types::sol_data::Uint<256>,
550 alloy::sol_types::sol_data::Address,
551 );
552 #[doc(hidden)]
553 type UnderlyingRustTuple<'a> = (
554 alloy::sol_types::private::Address,
555 alloy::sol_types::private::primitives::aliases::U256,
556 alloy::sol_types::private::Address,
557 );
558 #[cfg(test)]
559 #[allow(dead_code, unreachable_patterns)]
560 fn _type_assertion(
561 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
562 ) {
563 match _t {
564 alloy_sol_types::private::AssertTypeEq::<
565 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
566 >(_) => {}
567 }
568 }
569 #[automatically_derived]
570 #[doc(hidden)]
571 impl ::core::convert::From<ERC721IncorrectOwner> for UnderlyingRustTuple<'_> {
572 fn from(value: ERC721IncorrectOwner) -> Self {
573 (value.sender, value.tokenId, value.owner)
574 }
575 }
576 #[automatically_derived]
577 #[doc(hidden)]
578 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721IncorrectOwner {
579 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
580 Self {
581 sender: tuple.0,
582 tokenId: tuple.1,
583 owner: tuple.2,
584 }
585 }
586 }
587 #[automatically_derived]
588 impl alloy_sol_types::SolError for ERC721IncorrectOwner {
589 type Parameters<'a> = UnderlyingSolTuple<'a>;
590 type Token<'a> = <Self::Parameters<
591 'a,
592 > as alloy_sol_types::SolType>::Token<'a>;
593 const SIGNATURE: &'static str = "ERC721IncorrectOwner(address,uint256,address)";
594 const SELECTOR: [u8; 4] = [100u8, 40u8, 61u8, 123u8];
595 #[inline]
596 fn new<'a>(
597 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
598 ) -> Self {
599 tuple.into()
600 }
601 #[inline]
602 fn tokenize(&self) -> Self::Token<'_> {
603 (
604 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
605 &self.sender,
606 ),
607 <alloy::sol_types::sol_data::Uint<
608 256,
609 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
610 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
611 &self.owner,
612 ),
613 )
614 }
615 #[inline]
616 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
617 <Self::Parameters<
618 '_,
619 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
620 .map(Self::new)
621 }
622 }
623 };
624 #[derive(serde::Serialize, serde::Deserialize)]
625 #[derive(Default, Debug, PartialEq, Eq, Hash)]
626 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
631 #[derive(Clone)]
632 pub struct ERC721InsufficientApproval {
633 #[allow(missing_docs)]
634 pub operator: alloy::sol_types::private::Address,
635 #[allow(missing_docs)]
636 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
637 }
638 #[allow(
639 non_camel_case_types,
640 non_snake_case,
641 clippy::pub_underscore_fields,
642 clippy::style
643 )]
644 const _: () = {
645 use alloy::sol_types as alloy_sol_types;
646 #[doc(hidden)]
647 #[allow(dead_code)]
648 type UnderlyingSolTuple<'a> = (
649 alloy::sol_types::sol_data::Address,
650 alloy::sol_types::sol_data::Uint<256>,
651 );
652 #[doc(hidden)]
653 type UnderlyingRustTuple<'a> = (
654 alloy::sol_types::private::Address,
655 alloy::sol_types::private::primitives::aliases::U256,
656 );
657 #[cfg(test)]
658 #[allow(dead_code, unreachable_patterns)]
659 fn _type_assertion(
660 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
661 ) {
662 match _t {
663 alloy_sol_types::private::AssertTypeEq::<
664 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
665 >(_) => {}
666 }
667 }
668 #[automatically_derived]
669 #[doc(hidden)]
670 impl ::core::convert::From<ERC721InsufficientApproval>
671 for UnderlyingRustTuple<'_> {
672 fn from(value: ERC721InsufficientApproval) -> Self {
673 (value.operator, value.tokenId)
674 }
675 }
676 #[automatically_derived]
677 #[doc(hidden)]
678 impl ::core::convert::From<UnderlyingRustTuple<'_>>
679 for ERC721InsufficientApproval {
680 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
681 Self {
682 operator: tuple.0,
683 tokenId: tuple.1,
684 }
685 }
686 }
687 #[automatically_derived]
688 impl alloy_sol_types::SolError for ERC721InsufficientApproval {
689 type Parameters<'a> = UnderlyingSolTuple<'a>;
690 type Token<'a> = <Self::Parameters<
691 'a,
692 > as alloy_sol_types::SolType>::Token<'a>;
693 const SIGNATURE: &'static str = "ERC721InsufficientApproval(address,uint256)";
694 const SELECTOR: [u8; 4] = [23u8, 126u8, 128u8, 47u8];
695 #[inline]
696 fn new<'a>(
697 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
698 ) -> Self {
699 tuple.into()
700 }
701 #[inline]
702 fn tokenize(&self) -> Self::Token<'_> {
703 (
704 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
705 &self.operator,
706 ),
707 <alloy::sol_types::sol_data::Uint<
708 256,
709 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
710 )
711 }
712 #[inline]
713 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
714 <Self::Parameters<
715 '_,
716 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
717 .map(Self::new)
718 }
719 }
720 };
721 #[derive(serde::Serialize, serde::Deserialize)]
722 #[derive(Default, Debug, PartialEq, Eq, Hash)]
723 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
728 #[derive(Clone)]
729 pub struct ERC721InvalidApprover {
730 #[allow(missing_docs)]
731 pub approver: alloy::sol_types::private::Address,
732 }
733 #[allow(
734 non_camel_case_types,
735 non_snake_case,
736 clippy::pub_underscore_fields,
737 clippy::style
738 )]
739 const _: () = {
740 use alloy::sol_types as alloy_sol_types;
741 #[doc(hidden)]
742 #[allow(dead_code)]
743 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
744 #[doc(hidden)]
745 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
746 #[cfg(test)]
747 #[allow(dead_code, unreachable_patterns)]
748 fn _type_assertion(
749 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
750 ) {
751 match _t {
752 alloy_sol_types::private::AssertTypeEq::<
753 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
754 >(_) => {}
755 }
756 }
757 #[automatically_derived]
758 #[doc(hidden)]
759 impl ::core::convert::From<ERC721InvalidApprover> for UnderlyingRustTuple<'_> {
760 fn from(value: ERC721InvalidApprover) -> Self {
761 (value.approver,)
762 }
763 }
764 #[automatically_derived]
765 #[doc(hidden)]
766 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidApprover {
767 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
768 Self { approver: tuple.0 }
769 }
770 }
771 #[automatically_derived]
772 impl alloy_sol_types::SolError for ERC721InvalidApprover {
773 type Parameters<'a> = UnderlyingSolTuple<'a>;
774 type Token<'a> = <Self::Parameters<
775 'a,
776 > as alloy_sol_types::SolType>::Token<'a>;
777 const SIGNATURE: &'static str = "ERC721InvalidApprover(address)";
778 const SELECTOR: [u8; 4] = [169u8, 251u8, 245u8, 31u8];
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.approver,
790 ),
791 )
792 }
793 #[inline]
794 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
795 <Self::Parameters<
796 '_,
797 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
798 .map(Self::new)
799 }
800 }
801 };
802 #[derive(serde::Serialize, serde::Deserialize)]
803 #[derive(Default, Debug, PartialEq, Eq, Hash)]
804 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
809 #[derive(Clone)]
810 pub struct ERC721InvalidOperator {
811 #[allow(missing_docs)]
812 pub operator: alloy::sol_types::private::Address,
813 }
814 #[allow(
815 non_camel_case_types,
816 non_snake_case,
817 clippy::pub_underscore_fields,
818 clippy::style
819 )]
820 const _: () = {
821 use alloy::sol_types as alloy_sol_types;
822 #[doc(hidden)]
823 #[allow(dead_code)]
824 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
825 #[doc(hidden)]
826 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
827 #[cfg(test)]
828 #[allow(dead_code, unreachable_patterns)]
829 fn _type_assertion(
830 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
831 ) {
832 match _t {
833 alloy_sol_types::private::AssertTypeEq::<
834 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
835 >(_) => {}
836 }
837 }
838 #[automatically_derived]
839 #[doc(hidden)]
840 impl ::core::convert::From<ERC721InvalidOperator> for UnderlyingRustTuple<'_> {
841 fn from(value: ERC721InvalidOperator) -> Self {
842 (value.operator,)
843 }
844 }
845 #[automatically_derived]
846 #[doc(hidden)]
847 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidOperator {
848 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
849 Self { operator: tuple.0 }
850 }
851 }
852 #[automatically_derived]
853 impl alloy_sol_types::SolError for ERC721InvalidOperator {
854 type Parameters<'a> = UnderlyingSolTuple<'a>;
855 type Token<'a> = <Self::Parameters<
856 'a,
857 > as alloy_sol_types::SolType>::Token<'a>;
858 const SIGNATURE: &'static str = "ERC721InvalidOperator(address)";
859 const SELECTOR: [u8; 4] = [91u8, 8u8, 186u8, 24u8];
860 #[inline]
861 fn new<'a>(
862 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
863 ) -> Self {
864 tuple.into()
865 }
866 #[inline]
867 fn tokenize(&self) -> Self::Token<'_> {
868 (
869 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
870 &self.operator,
871 ),
872 )
873 }
874 #[inline]
875 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
876 <Self::Parameters<
877 '_,
878 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
879 .map(Self::new)
880 }
881 }
882 };
883 #[derive(serde::Serialize, serde::Deserialize)]
884 #[derive(Default, Debug, PartialEq, Eq, Hash)]
885 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
890 #[derive(Clone)]
891 pub struct ERC721InvalidOwner {
892 #[allow(missing_docs)]
893 pub owner: alloy::sol_types::private::Address,
894 }
895 #[allow(
896 non_camel_case_types,
897 non_snake_case,
898 clippy::pub_underscore_fields,
899 clippy::style
900 )]
901 const _: () = {
902 use alloy::sol_types as alloy_sol_types;
903 #[doc(hidden)]
904 #[allow(dead_code)]
905 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
906 #[doc(hidden)]
907 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
908 #[cfg(test)]
909 #[allow(dead_code, unreachable_patterns)]
910 fn _type_assertion(
911 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
912 ) {
913 match _t {
914 alloy_sol_types::private::AssertTypeEq::<
915 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
916 >(_) => {}
917 }
918 }
919 #[automatically_derived]
920 #[doc(hidden)]
921 impl ::core::convert::From<ERC721InvalidOwner> for UnderlyingRustTuple<'_> {
922 fn from(value: ERC721InvalidOwner) -> Self {
923 (value.owner,)
924 }
925 }
926 #[automatically_derived]
927 #[doc(hidden)]
928 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidOwner {
929 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
930 Self { owner: tuple.0 }
931 }
932 }
933 #[automatically_derived]
934 impl alloy_sol_types::SolError for ERC721InvalidOwner {
935 type Parameters<'a> = UnderlyingSolTuple<'a>;
936 type Token<'a> = <Self::Parameters<
937 'a,
938 > as alloy_sol_types::SolType>::Token<'a>;
939 const SIGNATURE: &'static str = "ERC721InvalidOwner(address)";
940 const SELECTOR: [u8; 4] = [137u8, 198u8, 43u8, 100u8];
941 #[inline]
942 fn new<'a>(
943 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
944 ) -> Self {
945 tuple.into()
946 }
947 #[inline]
948 fn tokenize(&self) -> Self::Token<'_> {
949 (
950 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
951 &self.owner,
952 ),
953 )
954 }
955 #[inline]
956 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
957 <Self::Parameters<
958 '_,
959 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
960 .map(Self::new)
961 }
962 }
963 };
964 #[derive(serde::Serialize, serde::Deserialize)]
965 #[derive(Default, Debug, PartialEq, Eq, Hash)]
966 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
971 #[derive(Clone)]
972 pub struct ERC721InvalidReceiver {
973 #[allow(missing_docs)]
974 pub receiver: alloy::sol_types::private::Address,
975 }
976 #[allow(
977 non_camel_case_types,
978 non_snake_case,
979 clippy::pub_underscore_fields,
980 clippy::style
981 )]
982 const _: () = {
983 use alloy::sol_types as alloy_sol_types;
984 #[doc(hidden)]
985 #[allow(dead_code)]
986 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
987 #[doc(hidden)]
988 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
989 #[cfg(test)]
990 #[allow(dead_code, unreachable_patterns)]
991 fn _type_assertion(
992 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
993 ) {
994 match _t {
995 alloy_sol_types::private::AssertTypeEq::<
996 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
997 >(_) => {}
998 }
999 }
1000 #[automatically_derived]
1001 #[doc(hidden)]
1002 impl ::core::convert::From<ERC721InvalidReceiver> for UnderlyingRustTuple<'_> {
1003 fn from(value: ERC721InvalidReceiver) -> Self {
1004 (value.receiver,)
1005 }
1006 }
1007 #[automatically_derived]
1008 #[doc(hidden)]
1009 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidReceiver {
1010 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1011 Self { receiver: tuple.0 }
1012 }
1013 }
1014 #[automatically_derived]
1015 impl alloy_sol_types::SolError for ERC721InvalidReceiver {
1016 type Parameters<'a> = UnderlyingSolTuple<'a>;
1017 type Token<'a> = <Self::Parameters<
1018 'a,
1019 > as alloy_sol_types::SolType>::Token<'a>;
1020 const SIGNATURE: &'static str = "ERC721InvalidReceiver(address)";
1021 const SELECTOR: [u8; 4] = [100u8, 160u8, 174u8, 146u8];
1022 #[inline]
1023 fn new<'a>(
1024 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1025 ) -> Self {
1026 tuple.into()
1027 }
1028 #[inline]
1029 fn tokenize(&self) -> Self::Token<'_> {
1030 (
1031 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1032 &self.receiver,
1033 ),
1034 )
1035 }
1036 #[inline]
1037 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1038 <Self::Parameters<
1039 '_,
1040 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1041 .map(Self::new)
1042 }
1043 }
1044 };
1045 #[derive(serde::Serialize, serde::Deserialize)]
1046 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1047 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1052 #[derive(Clone)]
1053 pub struct ERC721InvalidSender {
1054 #[allow(missing_docs)]
1055 pub sender: alloy::sol_types::private::Address,
1056 }
1057 #[allow(
1058 non_camel_case_types,
1059 non_snake_case,
1060 clippy::pub_underscore_fields,
1061 clippy::style
1062 )]
1063 const _: () = {
1064 use alloy::sol_types as alloy_sol_types;
1065 #[doc(hidden)]
1066 #[allow(dead_code)]
1067 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1068 #[doc(hidden)]
1069 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1070 #[cfg(test)]
1071 #[allow(dead_code, unreachable_patterns)]
1072 fn _type_assertion(
1073 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1074 ) {
1075 match _t {
1076 alloy_sol_types::private::AssertTypeEq::<
1077 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1078 >(_) => {}
1079 }
1080 }
1081 #[automatically_derived]
1082 #[doc(hidden)]
1083 impl ::core::convert::From<ERC721InvalidSender> for UnderlyingRustTuple<'_> {
1084 fn from(value: ERC721InvalidSender) -> Self {
1085 (value.sender,)
1086 }
1087 }
1088 #[automatically_derived]
1089 #[doc(hidden)]
1090 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidSender {
1091 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1092 Self { sender: tuple.0 }
1093 }
1094 }
1095 #[automatically_derived]
1096 impl alloy_sol_types::SolError for ERC721InvalidSender {
1097 type Parameters<'a> = UnderlyingSolTuple<'a>;
1098 type Token<'a> = <Self::Parameters<
1099 'a,
1100 > as alloy_sol_types::SolType>::Token<'a>;
1101 const SIGNATURE: &'static str = "ERC721InvalidSender(address)";
1102 const SELECTOR: [u8; 4] = [115u8, 198u8, 172u8, 110u8];
1103 #[inline]
1104 fn new<'a>(
1105 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1106 ) -> Self {
1107 tuple.into()
1108 }
1109 #[inline]
1110 fn tokenize(&self) -> Self::Token<'_> {
1111 (
1112 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1113 &self.sender,
1114 ),
1115 )
1116 }
1117 #[inline]
1118 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1119 <Self::Parameters<
1120 '_,
1121 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1122 .map(Self::new)
1123 }
1124 }
1125 };
1126 #[derive(serde::Serialize, serde::Deserialize)]
1127 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1128 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1133 #[derive(Clone)]
1134 pub struct ERC721NonexistentToken {
1135 #[allow(missing_docs)]
1136 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
1137 }
1138 #[allow(
1139 non_camel_case_types,
1140 non_snake_case,
1141 clippy::pub_underscore_fields,
1142 clippy::style
1143 )]
1144 const _: () = {
1145 use alloy::sol_types as alloy_sol_types;
1146 #[doc(hidden)]
1147 #[allow(dead_code)]
1148 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1149 #[doc(hidden)]
1150 type UnderlyingRustTuple<'a> = (
1151 alloy::sol_types::private::primitives::aliases::U256,
1152 );
1153 #[cfg(test)]
1154 #[allow(dead_code, unreachable_patterns)]
1155 fn _type_assertion(
1156 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1157 ) {
1158 match _t {
1159 alloy_sol_types::private::AssertTypeEq::<
1160 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1161 >(_) => {}
1162 }
1163 }
1164 #[automatically_derived]
1165 #[doc(hidden)]
1166 impl ::core::convert::From<ERC721NonexistentToken> for UnderlyingRustTuple<'_> {
1167 fn from(value: ERC721NonexistentToken) -> Self {
1168 (value.tokenId,)
1169 }
1170 }
1171 #[automatically_derived]
1172 #[doc(hidden)]
1173 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721NonexistentToken {
1174 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1175 Self { tokenId: tuple.0 }
1176 }
1177 }
1178 #[automatically_derived]
1179 impl alloy_sol_types::SolError for ERC721NonexistentToken {
1180 type Parameters<'a> = UnderlyingSolTuple<'a>;
1181 type Token<'a> = <Self::Parameters<
1182 'a,
1183 > as alloy_sol_types::SolType>::Token<'a>;
1184 const SIGNATURE: &'static str = "ERC721NonexistentToken(uint256)";
1185 const SELECTOR: [u8; 4] = [126u8, 39u8, 50u8, 137u8];
1186 #[inline]
1187 fn new<'a>(
1188 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1189 ) -> Self {
1190 tuple.into()
1191 }
1192 #[inline]
1193 fn tokenize(&self) -> Self::Token<'_> {
1194 (
1195 <alloy::sol_types::sol_data::Uint<
1196 256,
1197 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
1198 )
1199 }
1200 #[inline]
1201 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1202 <Self::Parameters<
1203 '_,
1204 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1205 .map(Self::new)
1206 }
1207 }
1208 };
1209 #[derive(serde::Serialize, serde::Deserialize)]
1210 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1211 #[allow(
1216 non_camel_case_types,
1217 non_snake_case,
1218 clippy::pub_underscore_fields,
1219 clippy::style
1220 )]
1221 #[derive(Clone)]
1222 pub struct Approval {
1223 #[allow(missing_docs)]
1224 pub owner: alloy::sol_types::private::Address,
1225 #[allow(missing_docs)]
1226 pub approved: alloy::sol_types::private::Address,
1227 #[allow(missing_docs)]
1228 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
1229 }
1230 #[allow(
1231 non_camel_case_types,
1232 non_snake_case,
1233 clippy::pub_underscore_fields,
1234 clippy::style
1235 )]
1236 const _: () = {
1237 use alloy::sol_types as alloy_sol_types;
1238 #[automatically_derived]
1239 impl alloy_sol_types::SolEvent for Approval {
1240 type DataTuple<'a> = ();
1241 type DataToken<'a> = <Self::DataTuple<
1242 'a,
1243 > as alloy_sol_types::SolType>::Token<'a>;
1244 type TopicList = (
1245 alloy_sol_types::sol_data::FixedBytes<32>,
1246 alloy::sol_types::sol_data::Address,
1247 alloy::sol_types::sol_data::Address,
1248 alloy::sol_types::sol_data::Uint<256>,
1249 );
1250 const SIGNATURE: &'static str = "Approval(address,address,uint256)";
1251 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1252 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8,
1253 66u8, 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8,
1254 41u8, 30u8, 91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
1255 ]);
1256 const ANONYMOUS: bool = false;
1257 #[allow(unused_variables)]
1258 #[inline]
1259 fn new(
1260 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1261 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1262 ) -> Self {
1263 Self {
1264 owner: topics.1,
1265 approved: topics.2,
1266 tokenId: topics.3,
1267 }
1268 }
1269 #[inline]
1270 fn check_signature(
1271 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1272 ) -> alloy_sol_types::Result<()> {
1273 if topics.0 != Self::SIGNATURE_HASH {
1274 return Err(
1275 alloy_sol_types::Error::invalid_event_signature_hash(
1276 Self::SIGNATURE,
1277 topics.0,
1278 Self::SIGNATURE_HASH,
1279 ),
1280 );
1281 }
1282 Ok(())
1283 }
1284 #[inline]
1285 fn tokenize_body(&self) -> Self::DataToken<'_> {
1286 ()
1287 }
1288 #[inline]
1289 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1290 (
1291 Self::SIGNATURE_HASH.into(),
1292 self.owner.clone(),
1293 self.approved.clone(),
1294 self.tokenId.clone(),
1295 )
1296 }
1297 #[inline]
1298 fn encode_topics_raw(
1299 &self,
1300 out: &mut [alloy_sol_types::abi::token::WordToken],
1301 ) -> alloy_sol_types::Result<()> {
1302 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1303 return Err(alloy_sol_types::Error::Overrun);
1304 }
1305 out[0usize] = alloy_sol_types::abi::token::WordToken(
1306 Self::SIGNATURE_HASH,
1307 );
1308 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1309 &self.owner,
1310 );
1311 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1312 &self.approved,
1313 );
1314 out[3usize] = <alloy::sol_types::sol_data::Uint<
1315 256,
1316 > as alloy_sol_types::EventTopic>::encode_topic(&self.tokenId);
1317 Ok(())
1318 }
1319 }
1320 #[automatically_derived]
1321 impl alloy_sol_types::private::IntoLogData for Approval {
1322 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1323 From::from(self)
1324 }
1325 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1326 From::from(&self)
1327 }
1328 }
1329 #[automatically_derived]
1330 impl From<&Approval> for alloy_sol_types::private::LogData {
1331 #[inline]
1332 fn from(this: &Approval) -> alloy_sol_types::private::LogData {
1333 alloy_sol_types::SolEvent::encode_log_data(this)
1334 }
1335 }
1336 };
1337 #[derive(serde::Serialize, serde::Deserialize)]
1338 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1339 #[allow(
1344 non_camel_case_types,
1345 non_snake_case,
1346 clippy::pub_underscore_fields,
1347 clippy::style
1348 )]
1349 #[derive(Clone)]
1350 pub struct ApprovalForAll {
1351 #[allow(missing_docs)]
1352 pub owner: alloy::sol_types::private::Address,
1353 #[allow(missing_docs)]
1354 pub operator: alloy::sol_types::private::Address,
1355 #[allow(missing_docs)]
1356 pub approved: bool,
1357 }
1358 #[allow(
1359 non_camel_case_types,
1360 non_snake_case,
1361 clippy::pub_underscore_fields,
1362 clippy::style
1363 )]
1364 const _: () = {
1365 use alloy::sol_types as alloy_sol_types;
1366 #[automatically_derived]
1367 impl alloy_sol_types::SolEvent for ApprovalForAll {
1368 type DataTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1369 type DataToken<'a> = <Self::DataTuple<
1370 'a,
1371 > as alloy_sol_types::SolType>::Token<'a>;
1372 type TopicList = (
1373 alloy_sol_types::sol_data::FixedBytes<32>,
1374 alloy::sol_types::sol_data::Address,
1375 alloy::sol_types::sol_data::Address,
1376 );
1377 const SIGNATURE: &'static str = "ApprovalForAll(address,address,bool)";
1378 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1379 23u8, 48u8, 126u8, 171u8, 57u8, 171u8, 97u8, 7u8, 232u8, 137u8, 152u8,
1380 69u8, 173u8, 61u8, 89u8, 189u8, 150u8, 83u8, 242u8, 0u8, 242u8, 32u8,
1381 146u8, 4u8, 137u8, 202u8, 43u8, 89u8, 55u8, 105u8, 108u8, 49u8,
1382 ]);
1383 const ANONYMOUS: bool = false;
1384 #[allow(unused_variables)]
1385 #[inline]
1386 fn new(
1387 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1388 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1389 ) -> Self {
1390 Self {
1391 owner: topics.1,
1392 operator: topics.2,
1393 approved: data.0,
1394 }
1395 }
1396 #[inline]
1397 fn check_signature(
1398 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1399 ) -> alloy_sol_types::Result<()> {
1400 if topics.0 != Self::SIGNATURE_HASH {
1401 return Err(
1402 alloy_sol_types::Error::invalid_event_signature_hash(
1403 Self::SIGNATURE,
1404 topics.0,
1405 Self::SIGNATURE_HASH,
1406 ),
1407 );
1408 }
1409 Ok(())
1410 }
1411 #[inline]
1412 fn tokenize_body(&self) -> Self::DataToken<'_> {
1413 (
1414 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
1415 &self.approved,
1416 ),
1417 )
1418 }
1419 #[inline]
1420 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1421 (Self::SIGNATURE_HASH.into(), self.owner.clone(), self.operator.clone())
1422 }
1423 #[inline]
1424 fn encode_topics_raw(
1425 &self,
1426 out: &mut [alloy_sol_types::abi::token::WordToken],
1427 ) -> alloy_sol_types::Result<()> {
1428 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1429 return Err(alloy_sol_types::Error::Overrun);
1430 }
1431 out[0usize] = alloy_sol_types::abi::token::WordToken(
1432 Self::SIGNATURE_HASH,
1433 );
1434 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1435 &self.owner,
1436 );
1437 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1438 &self.operator,
1439 );
1440 Ok(())
1441 }
1442 }
1443 #[automatically_derived]
1444 impl alloy_sol_types::private::IntoLogData for ApprovalForAll {
1445 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1446 From::from(self)
1447 }
1448 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1449 From::from(&self)
1450 }
1451 }
1452 #[automatically_derived]
1453 impl From<&ApprovalForAll> for alloy_sol_types::private::LogData {
1454 #[inline]
1455 fn from(this: &ApprovalForAll) -> alloy_sol_types::private::LogData {
1456 alloy_sol_types::SolEvent::encode_log_data(this)
1457 }
1458 }
1459 };
1460 #[derive(serde::Serialize, serde::Deserialize)]
1461 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1462 #[allow(
1467 non_camel_case_types,
1468 non_snake_case,
1469 clippy::pub_underscore_fields,
1470 clippy::style
1471 )]
1472 #[derive(Clone)]
1473 pub struct Transfer {
1474 #[allow(missing_docs)]
1475 pub from: alloy::sol_types::private::Address,
1476 #[allow(missing_docs)]
1477 pub to: alloy::sol_types::private::Address,
1478 #[allow(missing_docs)]
1479 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
1480 }
1481 #[allow(
1482 non_camel_case_types,
1483 non_snake_case,
1484 clippy::pub_underscore_fields,
1485 clippy::style
1486 )]
1487 const _: () = {
1488 use alloy::sol_types as alloy_sol_types;
1489 #[automatically_derived]
1490 impl alloy_sol_types::SolEvent for Transfer {
1491 type DataTuple<'a> = ();
1492 type DataToken<'a> = <Self::DataTuple<
1493 'a,
1494 > as alloy_sol_types::SolType>::Token<'a>;
1495 type TopicList = (
1496 alloy_sol_types::sol_data::FixedBytes<32>,
1497 alloy::sol_types::sol_data::Address,
1498 alloy::sol_types::sol_data::Address,
1499 alloy::sol_types::sol_data::Uint<256>,
1500 );
1501 const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
1502 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1503 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8,
1504 176u8, 104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8,
1505 196u8, 161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
1506 ]);
1507 const ANONYMOUS: bool = false;
1508 #[allow(unused_variables)]
1509 #[inline]
1510 fn new(
1511 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1512 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1513 ) -> Self {
1514 Self {
1515 from: topics.1,
1516 to: topics.2,
1517 tokenId: topics.3,
1518 }
1519 }
1520 #[inline]
1521 fn check_signature(
1522 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1523 ) -> alloy_sol_types::Result<()> {
1524 if topics.0 != Self::SIGNATURE_HASH {
1525 return Err(
1526 alloy_sol_types::Error::invalid_event_signature_hash(
1527 Self::SIGNATURE,
1528 topics.0,
1529 Self::SIGNATURE_HASH,
1530 ),
1531 );
1532 }
1533 Ok(())
1534 }
1535 #[inline]
1536 fn tokenize_body(&self) -> Self::DataToken<'_> {
1537 ()
1538 }
1539 #[inline]
1540 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1541 (
1542 Self::SIGNATURE_HASH.into(),
1543 self.from.clone(),
1544 self.to.clone(),
1545 self.tokenId.clone(),
1546 )
1547 }
1548 #[inline]
1549 fn encode_topics_raw(
1550 &self,
1551 out: &mut [alloy_sol_types::abi::token::WordToken],
1552 ) -> alloy_sol_types::Result<()> {
1553 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1554 return Err(alloy_sol_types::Error::Overrun);
1555 }
1556 out[0usize] = alloy_sol_types::abi::token::WordToken(
1557 Self::SIGNATURE_HASH,
1558 );
1559 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1560 &self.from,
1561 );
1562 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1563 &self.to,
1564 );
1565 out[3usize] = <alloy::sol_types::sol_data::Uint<
1566 256,
1567 > as alloy_sol_types::EventTopic>::encode_topic(&self.tokenId);
1568 Ok(())
1569 }
1570 }
1571 #[automatically_derived]
1572 impl alloy_sol_types::private::IntoLogData for Transfer {
1573 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1574 From::from(self)
1575 }
1576 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1577 From::from(&self)
1578 }
1579 }
1580 #[automatically_derived]
1581 impl From<&Transfer> for alloy_sol_types::private::LogData {
1582 #[inline]
1583 fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
1584 alloy_sol_types::SolEvent::encode_log_data(this)
1585 }
1586 }
1587 };
1588 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1593 #[derive(Clone)]
1594 pub struct constructorCall {
1595 #[allow(missing_docs)]
1596 pub minter: alloy::sol_types::private::Address,
1597 #[allow(missing_docs)]
1598 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
1599 }
1600 const _: () = {
1601 use alloy::sol_types as alloy_sol_types;
1602 {
1603 #[doc(hidden)]
1604 #[allow(dead_code)]
1605 type UnderlyingSolTuple<'a> = (
1606 alloy::sol_types::sol_data::Address,
1607 alloy::sol_types::sol_data::Uint<256>,
1608 );
1609 #[doc(hidden)]
1610 type UnderlyingRustTuple<'a> = (
1611 alloy::sol_types::private::Address,
1612 alloy::sol_types::private::primitives::aliases::U256,
1613 );
1614 #[cfg(test)]
1615 #[allow(dead_code, unreachable_patterns)]
1616 fn _type_assertion(
1617 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1618 ) {
1619 match _t {
1620 alloy_sol_types::private::AssertTypeEq::<
1621 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1622 >(_) => {}
1623 }
1624 }
1625 #[automatically_derived]
1626 #[doc(hidden)]
1627 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
1628 fn from(value: constructorCall) -> Self {
1629 (value.minter, value.tokenId)
1630 }
1631 }
1632 #[automatically_derived]
1633 #[doc(hidden)]
1634 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
1635 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1636 Self {
1637 minter: tuple.0,
1638 tokenId: tuple.1,
1639 }
1640 }
1641 }
1642 }
1643 #[automatically_derived]
1644 impl alloy_sol_types::SolConstructor for constructorCall {
1645 type Parameters<'a> = (
1646 alloy::sol_types::sol_data::Address,
1647 alloy::sol_types::sol_data::Uint<256>,
1648 );
1649 type Token<'a> = <Self::Parameters<
1650 'a,
1651 > as alloy_sol_types::SolType>::Token<'a>;
1652 #[inline]
1653 fn new<'a>(
1654 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1655 ) -> Self {
1656 tuple.into()
1657 }
1658 #[inline]
1659 fn tokenize(&self) -> Self::Token<'_> {
1660 (
1661 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1662 &self.minter,
1663 ),
1664 <alloy::sol_types::sol_data::Uint<
1665 256,
1666 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
1667 )
1668 }
1669 }
1670 };
1671 #[derive(serde::Serialize, serde::Deserialize)]
1672 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1673 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1678 #[derive(Clone)]
1679 pub struct approveCall {
1680 #[allow(missing_docs)]
1681 pub to: alloy::sol_types::private::Address,
1682 #[allow(missing_docs)]
1683 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
1684 }
1685 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1687 #[derive(Clone)]
1688 pub struct approveReturn {}
1689 #[allow(
1690 non_camel_case_types,
1691 non_snake_case,
1692 clippy::pub_underscore_fields,
1693 clippy::style
1694 )]
1695 const _: () = {
1696 use alloy::sol_types as alloy_sol_types;
1697 {
1698 #[doc(hidden)]
1699 #[allow(dead_code)]
1700 type UnderlyingSolTuple<'a> = (
1701 alloy::sol_types::sol_data::Address,
1702 alloy::sol_types::sol_data::Uint<256>,
1703 );
1704 #[doc(hidden)]
1705 type UnderlyingRustTuple<'a> = (
1706 alloy::sol_types::private::Address,
1707 alloy::sol_types::private::primitives::aliases::U256,
1708 );
1709 #[cfg(test)]
1710 #[allow(dead_code, unreachable_patterns)]
1711 fn _type_assertion(
1712 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1713 ) {
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<approveCall> for UnderlyingRustTuple<'_> {
1723 fn from(value: approveCall) -> Self {
1724 (value.to, value.tokenId)
1725 }
1726 }
1727 #[automatically_derived]
1728 #[doc(hidden)]
1729 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
1730 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1731 Self {
1732 to: tuple.0,
1733 tokenId: tuple.1,
1734 }
1735 }
1736 }
1737 }
1738 {
1739 #[doc(hidden)]
1740 #[allow(dead_code)]
1741 type UnderlyingSolTuple<'a> = ();
1742 #[doc(hidden)]
1743 type UnderlyingRustTuple<'a> = ();
1744 #[cfg(test)]
1745 #[allow(dead_code, unreachable_patterns)]
1746 fn _type_assertion(
1747 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1748 ) {
1749 match _t {
1750 alloy_sol_types::private::AssertTypeEq::<
1751 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1752 >(_) => {}
1753 }
1754 }
1755 #[automatically_derived]
1756 #[doc(hidden)]
1757 impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
1758 fn from(value: approveReturn) -> Self {
1759 ()
1760 }
1761 }
1762 #[automatically_derived]
1763 #[doc(hidden)]
1764 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
1765 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1766 Self {}
1767 }
1768 }
1769 }
1770 impl approveReturn {
1771 fn _tokenize(
1772 &self,
1773 ) -> <approveCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1774 ()
1775 }
1776 }
1777 #[automatically_derived]
1778 impl alloy_sol_types::SolCall for approveCall {
1779 type Parameters<'a> = (
1780 alloy::sol_types::sol_data::Address,
1781 alloy::sol_types::sol_data::Uint<256>,
1782 );
1783 type Token<'a> = <Self::Parameters<
1784 'a,
1785 > as alloy_sol_types::SolType>::Token<'a>;
1786 type Return = approveReturn;
1787 type ReturnTuple<'a> = ();
1788 type ReturnToken<'a> = <Self::ReturnTuple<
1789 'a,
1790 > as alloy_sol_types::SolType>::Token<'a>;
1791 const SIGNATURE: &'static str = "approve(address,uint256)";
1792 const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
1793 #[inline]
1794 fn new<'a>(
1795 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1796 ) -> Self {
1797 tuple.into()
1798 }
1799 #[inline]
1800 fn tokenize(&self) -> Self::Token<'_> {
1801 (
1802 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1803 &self.to,
1804 ),
1805 <alloy::sol_types::sol_data::Uint<
1806 256,
1807 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
1808 )
1809 }
1810 #[inline]
1811 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1812 approveReturn::_tokenize(ret)
1813 }
1814 #[inline]
1815 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1816 <Self::ReturnTuple<
1817 '_,
1818 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1819 .map(Into::into)
1820 }
1821 #[inline]
1822 fn abi_decode_returns_validate(
1823 data: &[u8],
1824 ) -> alloy_sol_types::Result<Self::Return> {
1825 <Self::ReturnTuple<
1826 '_,
1827 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1828 .map(Into::into)
1829 }
1830 }
1831 };
1832 #[derive(serde::Serialize, serde::Deserialize)]
1833 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1834 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1839 #[derive(Clone)]
1840 pub struct balanceOfCall {
1841 #[allow(missing_docs)]
1842 pub owner: alloy::sol_types::private::Address,
1843 }
1844 #[derive(serde::Serialize, serde::Deserialize)]
1845 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1846 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1848 #[derive(Clone)]
1849 pub struct balanceOfReturn {
1850 #[allow(missing_docs)]
1851 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1852 }
1853 #[allow(
1854 non_camel_case_types,
1855 non_snake_case,
1856 clippy::pub_underscore_fields,
1857 clippy::style
1858 )]
1859 const _: () = {
1860 use alloy::sol_types as alloy_sol_types;
1861 {
1862 #[doc(hidden)]
1863 #[allow(dead_code)]
1864 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1865 #[doc(hidden)]
1866 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1867 #[cfg(test)]
1868 #[allow(dead_code, unreachable_patterns)]
1869 fn _type_assertion(
1870 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1871 ) {
1872 match _t {
1873 alloy_sol_types::private::AssertTypeEq::<
1874 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1875 >(_) => {}
1876 }
1877 }
1878 #[automatically_derived]
1879 #[doc(hidden)]
1880 impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
1881 fn from(value: balanceOfCall) -> Self {
1882 (value.owner,)
1883 }
1884 }
1885 #[automatically_derived]
1886 #[doc(hidden)]
1887 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
1888 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1889 Self { owner: tuple.0 }
1890 }
1891 }
1892 }
1893 {
1894 #[doc(hidden)]
1895 #[allow(dead_code)]
1896 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1897 #[doc(hidden)]
1898 type UnderlyingRustTuple<'a> = (
1899 alloy::sol_types::private::primitives::aliases::U256,
1900 );
1901 #[cfg(test)]
1902 #[allow(dead_code, unreachable_patterns)]
1903 fn _type_assertion(
1904 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1905 ) {
1906 match _t {
1907 alloy_sol_types::private::AssertTypeEq::<
1908 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1909 >(_) => {}
1910 }
1911 }
1912 #[automatically_derived]
1913 #[doc(hidden)]
1914 impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
1915 fn from(value: balanceOfReturn) -> Self {
1916 (value._0,)
1917 }
1918 }
1919 #[automatically_derived]
1920 #[doc(hidden)]
1921 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
1922 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1923 Self { _0: tuple.0 }
1924 }
1925 }
1926 }
1927 #[automatically_derived]
1928 impl alloy_sol_types::SolCall for balanceOfCall {
1929 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1930 type Token<'a> = <Self::Parameters<
1931 'a,
1932 > as alloy_sol_types::SolType>::Token<'a>;
1933 type Return = alloy::sol_types::private::primitives::aliases::U256;
1934 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1935 type ReturnToken<'a> = <Self::ReturnTuple<
1936 'a,
1937 > as alloy_sol_types::SolType>::Token<'a>;
1938 const SIGNATURE: &'static str = "balanceOf(address)";
1939 const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
1940 #[inline]
1941 fn new<'a>(
1942 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1943 ) -> Self {
1944 tuple.into()
1945 }
1946 #[inline]
1947 fn tokenize(&self) -> Self::Token<'_> {
1948 (
1949 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1950 &self.owner,
1951 ),
1952 )
1953 }
1954 #[inline]
1955 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1956 (
1957 <alloy::sol_types::sol_data::Uint<
1958 256,
1959 > as alloy_sol_types::SolType>::tokenize(ret),
1960 )
1961 }
1962 #[inline]
1963 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1964 <Self::ReturnTuple<
1965 '_,
1966 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1967 .map(|r| {
1968 let r: balanceOfReturn = r.into();
1969 r._0
1970 })
1971 }
1972 #[inline]
1973 fn abi_decode_returns_validate(
1974 data: &[u8],
1975 ) -> alloy_sol_types::Result<Self::Return> {
1976 <Self::ReturnTuple<
1977 '_,
1978 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1979 .map(|r| {
1980 let r: balanceOfReturn = r.into();
1981 r._0
1982 })
1983 }
1984 }
1985 };
1986 #[derive(serde::Serialize, serde::Deserialize)]
1987 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1988 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1993 #[derive(Clone)]
1994 pub struct getApprovedCall {
1995 #[allow(missing_docs)]
1996 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
1997 }
1998 #[derive(serde::Serialize, serde::Deserialize)]
1999 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2000 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2002 #[derive(Clone)]
2003 pub struct getApprovedReturn {
2004 #[allow(missing_docs)]
2005 pub _0: alloy::sol_types::private::Address,
2006 }
2007 #[allow(
2008 non_camel_case_types,
2009 non_snake_case,
2010 clippy::pub_underscore_fields,
2011 clippy::style
2012 )]
2013 const _: () = {
2014 use alloy::sol_types as alloy_sol_types;
2015 {
2016 #[doc(hidden)]
2017 #[allow(dead_code)]
2018 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2019 #[doc(hidden)]
2020 type UnderlyingRustTuple<'a> = (
2021 alloy::sol_types::private::primitives::aliases::U256,
2022 );
2023 #[cfg(test)]
2024 #[allow(dead_code, unreachable_patterns)]
2025 fn _type_assertion(
2026 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2027 ) {
2028 match _t {
2029 alloy_sol_types::private::AssertTypeEq::<
2030 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2031 >(_) => {}
2032 }
2033 }
2034 #[automatically_derived]
2035 #[doc(hidden)]
2036 impl ::core::convert::From<getApprovedCall> for UnderlyingRustTuple<'_> {
2037 fn from(value: getApprovedCall) -> Self {
2038 (value.tokenId,)
2039 }
2040 }
2041 #[automatically_derived]
2042 #[doc(hidden)]
2043 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getApprovedCall {
2044 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2045 Self { tokenId: tuple.0 }
2046 }
2047 }
2048 }
2049 {
2050 #[doc(hidden)]
2051 #[allow(dead_code)]
2052 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2053 #[doc(hidden)]
2054 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2055 #[cfg(test)]
2056 #[allow(dead_code, unreachable_patterns)]
2057 fn _type_assertion(
2058 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2059 ) {
2060 match _t {
2061 alloy_sol_types::private::AssertTypeEq::<
2062 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2063 >(_) => {}
2064 }
2065 }
2066 #[automatically_derived]
2067 #[doc(hidden)]
2068 impl ::core::convert::From<getApprovedReturn> for UnderlyingRustTuple<'_> {
2069 fn from(value: getApprovedReturn) -> Self {
2070 (value._0,)
2071 }
2072 }
2073 #[automatically_derived]
2074 #[doc(hidden)]
2075 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getApprovedReturn {
2076 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2077 Self { _0: tuple.0 }
2078 }
2079 }
2080 }
2081 #[automatically_derived]
2082 impl alloy_sol_types::SolCall for getApprovedCall {
2083 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2084 type Token<'a> = <Self::Parameters<
2085 'a,
2086 > as alloy_sol_types::SolType>::Token<'a>;
2087 type Return = alloy::sol_types::private::Address;
2088 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2089 type ReturnToken<'a> = <Self::ReturnTuple<
2090 'a,
2091 > as alloy_sol_types::SolType>::Token<'a>;
2092 const SIGNATURE: &'static str = "getApproved(uint256)";
2093 const SELECTOR: [u8; 4] = [8u8, 24u8, 18u8, 252u8];
2094 #[inline]
2095 fn new<'a>(
2096 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2097 ) -> Self {
2098 tuple.into()
2099 }
2100 #[inline]
2101 fn tokenize(&self) -> Self::Token<'_> {
2102 (
2103 <alloy::sol_types::sol_data::Uint<
2104 256,
2105 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
2106 )
2107 }
2108 #[inline]
2109 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2110 (
2111 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2112 ret,
2113 ),
2114 )
2115 }
2116 #[inline]
2117 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2118 <Self::ReturnTuple<
2119 '_,
2120 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2121 .map(|r| {
2122 let r: getApprovedReturn = r.into();
2123 r._0
2124 })
2125 }
2126 #[inline]
2127 fn abi_decode_returns_validate(
2128 data: &[u8],
2129 ) -> alloy_sol_types::Result<Self::Return> {
2130 <Self::ReturnTuple<
2131 '_,
2132 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2133 .map(|r| {
2134 let r: getApprovedReturn = r.into();
2135 r._0
2136 })
2137 }
2138 }
2139 };
2140 #[derive(serde::Serialize, serde::Deserialize)]
2141 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2142 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2147 #[derive(Clone)]
2148 pub struct isApprovedForAllCall {
2149 #[allow(missing_docs)]
2150 pub owner: alloy::sol_types::private::Address,
2151 #[allow(missing_docs)]
2152 pub operator: alloy::sol_types::private::Address,
2153 }
2154 #[derive(serde::Serialize, serde::Deserialize)]
2155 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2156 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2158 #[derive(Clone)]
2159 pub struct isApprovedForAllReturn {
2160 #[allow(missing_docs)]
2161 pub _0: bool,
2162 }
2163 #[allow(
2164 non_camel_case_types,
2165 non_snake_case,
2166 clippy::pub_underscore_fields,
2167 clippy::style
2168 )]
2169 const _: () = {
2170 use alloy::sol_types as alloy_sol_types;
2171 {
2172 #[doc(hidden)]
2173 #[allow(dead_code)]
2174 type UnderlyingSolTuple<'a> = (
2175 alloy::sol_types::sol_data::Address,
2176 alloy::sol_types::sol_data::Address,
2177 );
2178 #[doc(hidden)]
2179 type UnderlyingRustTuple<'a> = (
2180 alloy::sol_types::private::Address,
2181 alloy::sol_types::private::Address,
2182 );
2183 #[cfg(test)]
2184 #[allow(dead_code, unreachable_patterns)]
2185 fn _type_assertion(
2186 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2187 ) {
2188 match _t {
2189 alloy_sol_types::private::AssertTypeEq::<
2190 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2191 >(_) => {}
2192 }
2193 }
2194 #[automatically_derived]
2195 #[doc(hidden)]
2196 impl ::core::convert::From<isApprovedForAllCall>
2197 for UnderlyingRustTuple<'_> {
2198 fn from(value: isApprovedForAllCall) -> Self {
2199 (value.owner, value.operator)
2200 }
2201 }
2202 #[automatically_derived]
2203 #[doc(hidden)]
2204 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2205 for isApprovedForAllCall {
2206 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2207 Self {
2208 owner: tuple.0,
2209 operator: tuple.1,
2210 }
2211 }
2212 }
2213 }
2214 {
2215 #[doc(hidden)]
2216 #[allow(dead_code)]
2217 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2218 #[doc(hidden)]
2219 type UnderlyingRustTuple<'a> = (bool,);
2220 #[cfg(test)]
2221 #[allow(dead_code, unreachable_patterns)]
2222 fn _type_assertion(
2223 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2224 ) {
2225 match _t {
2226 alloy_sol_types::private::AssertTypeEq::<
2227 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2228 >(_) => {}
2229 }
2230 }
2231 #[automatically_derived]
2232 #[doc(hidden)]
2233 impl ::core::convert::From<isApprovedForAllReturn>
2234 for UnderlyingRustTuple<'_> {
2235 fn from(value: isApprovedForAllReturn) -> Self {
2236 (value._0,)
2237 }
2238 }
2239 #[automatically_derived]
2240 #[doc(hidden)]
2241 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2242 for isApprovedForAllReturn {
2243 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2244 Self { _0: tuple.0 }
2245 }
2246 }
2247 }
2248 #[automatically_derived]
2249 impl alloy_sol_types::SolCall for isApprovedForAllCall {
2250 type Parameters<'a> = (
2251 alloy::sol_types::sol_data::Address,
2252 alloy::sol_types::sol_data::Address,
2253 );
2254 type Token<'a> = <Self::Parameters<
2255 'a,
2256 > as alloy_sol_types::SolType>::Token<'a>;
2257 type Return = bool;
2258 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2259 type ReturnToken<'a> = <Self::ReturnTuple<
2260 'a,
2261 > as alloy_sol_types::SolType>::Token<'a>;
2262 const SIGNATURE: &'static str = "isApprovedForAll(address,address)";
2263 const SELECTOR: [u8; 4] = [233u8, 133u8, 233u8, 197u8];
2264 #[inline]
2265 fn new<'a>(
2266 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2267 ) -> Self {
2268 tuple.into()
2269 }
2270 #[inline]
2271 fn tokenize(&self) -> Self::Token<'_> {
2272 (
2273 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2274 &self.owner,
2275 ),
2276 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2277 &self.operator,
2278 ),
2279 )
2280 }
2281 #[inline]
2282 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2283 (
2284 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
2285 ret,
2286 ),
2287 )
2288 }
2289 #[inline]
2290 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2291 <Self::ReturnTuple<
2292 '_,
2293 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2294 .map(|r| {
2295 let r: isApprovedForAllReturn = r.into();
2296 r._0
2297 })
2298 }
2299 #[inline]
2300 fn abi_decode_returns_validate(
2301 data: &[u8],
2302 ) -> alloy_sol_types::Result<Self::Return> {
2303 <Self::ReturnTuple<
2304 '_,
2305 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2306 .map(|r| {
2307 let r: isApprovedForAllReturn = r.into();
2308 r._0
2309 })
2310 }
2311 }
2312 };
2313 #[derive(serde::Serialize, serde::Deserialize)]
2314 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2315 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2320 #[derive(Clone)]
2321 pub struct nameCall;
2322 #[derive(serde::Serialize, serde::Deserialize)]
2323 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2324 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2326 #[derive(Clone)]
2327 pub struct nameReturn {
2328 #[allow(missing_docs)]
2329 pub _0: alloy::sol_types::private::String,
2330 }
2331 #[allow(
2332 non_camel_case_types,
2333 non_snake_case,
2334 clippy::pub_underscore_fields,
2335 clippy::style
2336 )]
2337 const _: () = {
2338 use alloy::sol_types as alloy_sol_types;
2339 {
2340 #[doc(hidden)]
2341 #[allow(dead_code)]
2342 type UnderlyingSolTuple<'a> = ();
2343 #[doc(hidden)]
2344 type UnderlyingRustTuple<'a> = ();
2345 #[cfg(test)]
2346 #[allow(dead_code, unreachable_patterns)]
2347 fn _type_assertion(
2348 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2349 ) {
2350 match _t {
2351 alloy_sol_types::private::AssertTypeEq::<
2352 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2353 >(_) => {}
2354 }
2355 }
2356 #[automatically_derived]
2357 #[doc(hidden)]
2358 impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
2359 fn from(value: nameCall) -> Self {
2360 ()
2361 }
2362 }
2363 #[automatically_derived]
2364 #[doc(hidden)]
2365 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
2366 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2367 Self
2368 }
2369 }
2370 }
2371 {
2372 #[doc(hidden)]
2373 #[allow(dead_code)]
2374 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2375 #[doc(hidden)]
2376 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2377 #[cfg(test)]
2378 #[allow(dead_code, unreachable_patterns)]
2379 fn _type_assertion(
2380 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2381 ) {
2382 match _t {
2383 alloy_sol_types::private::AssertTypeEq::<
2384 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2385 >(_) => {}
2386 }
2387 }
2388 #[automatically_derived]
2389 #[doc(hidden)]
2390 impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
2391 fn from(value: nameReturn) -> Self {
2392 (value._0,)
2393 }
2394 }
2395 #[automatically_derived]
2396 #[doc(hidden)]
2397 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
2398 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2399 Self { _0: tuple.0 }
2400 }
2401 }
2402 }
2403 #[automatically_derived]
2404 impl alloy_sol_types::SolCall for nameCall {
2405 type Parameters<'a> = ();
2406 type Token<'a> = <Self::Parameters<
2407 'a,
2408 > as alloy_sol_types::SolType>::Token<'a>;
2409 type Return = alloy::sol_types::private::String;
2410 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2411 type ReturnToken<'a> = <Self::ReturnTuple<
2412 'a,
2413 > as alloy_sol_types::SolType>::Token<'a>;
2414 const SIGNATURE: &'static str = "name()";
2415 const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
2416 #[inline]
2417 fn new<'a>(
2418 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2419 ) -> Self {
2420 tuple.into()
2421 }
2422 #[inline]
2423 fn tokenize(&self) -> Self::Token<'_> {
2424 ()
2425 }
2426 #[inline]
2427 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2428 (
2429 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
2430 ret,
2431 ),
2432 )
2433 }
2434 #[inline]
2435 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2436 <Self::ReturnTuple<
2437 '_,
2438 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2439 .map(|r| {
2440 let r: nameReturn = r.into();
2441 r._0
2442 })
2443 }
2444 #[inline]
2445 fn abi_decode_returns_validate(
2446 data: &[u8],
2447 ) -> alloy_sol_types::Result<Self::Return> {
2448 <Self::ReturnTuple<
2449 '_,
2450 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2451 .map(|r| {
2452 let r: nameReturn = r.into();
2453 r._0
2454 })
2455 }
2456 }
2457 };
2458 #[derive(serde::Serialize, serde::Deserialize)]
2459 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2460 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2465 #[derive(Clone)]
2466 pub struct ownerOfCall {
2467 #[allow(missing_docs)]
2468 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
2469 }
2470 #[derive(serde::Serialize, serde::Deserialize)]
2471 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2472 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2474 #[derive(Clone)]
2475 pub struct ownerOfReturn {
2476 #[allow(missing_docs)]
2477 pub _0: alloy::sol_types::private::Address,
2478 }
2479 #[allow(
2480 non_camel_case_types,
2481 non_snake_case,
2482 clippy::pub_underscore_fields,
2483 clippy::style
2484 )]
2485 const _: () = {
2486 use alloy::sol_types as alloy_sol_types;
2487 {
2488 #[doc(hidden)]
2489 #[allow(dead_code)]
2490 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2491 #[doc(hidden)]
2492 type UnderlyingRustTuple<'a> = (
2493 alloy::sol_types::private::primitives::aliases::U256,
2494 );
2495 #[cfg(test)]
2496 #[allow(dead_code, unreachable_patterns)]
2497 fn _type_assertion(
2498 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2499 ) {
2500 match _t {
2501 alloy_sol_types::private::AssertTypeEq::<
2502 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2503 >(_) => {}
2504 }
2505 }
2506 #[automatically_derived]
2507 #[doc(hidden)]
2508 impl ::core::convert::From<ownerOfCall> for UnderlyingRustTuple<'_> {
2509 fn from(value: ownerOfCall) -> Self {
2510 (value.tokenId,)
2511 }
2512 }
2513 #[automatically_derived]
2514 #[doc(hidden)]
2515 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerOfCall {
2516 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2517 Self { tokenId: tuple.0 }
2518 }
2519 }
2520 }
2521 {
2522 #[doc(hidden)]
2523 #[allow(dead_code)]
2524 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2525 #[doc(hidden)]
2526 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2527 #[cfg(test)]
2528 #[allow(dead_code, unreachable_patterns)]
2529 fn _type_assertion(
2530 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2531 ) {
2532 match _t {
2533 alloy_sol_types::private::AssertTypeEq::<
2534 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2535 >(_) => {}
2536 }
2537 }
2538 #[automatically_derived]
2539 #[doc(hidden)]
2540 impl ::core::convert::From<ownerOfReturn> for UnderlyingRustTuple<'_> {
2541 fn from(value: ownerOfReturn) -> Self {
2542 (value._0,)
2543 }
2544 }
2545 #[automatically_derived]
2546 #[doc(hidden)]
2547 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerOfReturn {
2548 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2549 Self { _0: tuple.0 }
2550 }
2551 }
2552 }
2553 #[automatically_derived]
2554 impl alloy_sol_types::SolCall for ownerOfCall {
2555 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2556 type Token<'a> = <Self::Parameters<
2557 'a,
2558 > as alloy_sol_types::SolType>::Token<'a>;
2559 type Return = alloy::sol_types::private::Address;
2560 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2561 type ReturnToken<'a> = <Self::ReturnTuple<
2562 'a,
2563 > as alloy_sol_types::SolType>::Token<'a>;
2564 const SIGNATURE: &'static str = "ownerOf(uint256)";
2565 const SELECTOR: [u8; 4] = [99u8, 82u8, 33u8, 30u8];
2566 #[inline]
2567 fn new<'a>(
2568 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2569 ) -> Self {
2570 tuple.into()
2571 }
2572 #[inline]
2573 fn tokenize(&self) -> Self::Token<'_> {
2574 (
2575 <alloy::sol_types::sol_data::Uint<
2576 256,
2577 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
2578 )
2579 }
2580 #[inline]
2581 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2582 (
2583 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2584 ret,
2585 ),
2586 )
2587 }
2588 #[inline]
2589 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2590 <Self::ReturnTuple<
2591 '_,
2592 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2593 .map(|r| {
2594 let r: ownerOfReturn = r.into();
2595 r._0
2596 })
2597 }
2598 #[inline]
2599 fn abi_decode_returns_validate(
2600 data: &[u8],
2601 ) -> alloy_sol_types::Result<Self::Return> {
2602 <Self::ReturnTuple<
2603 '_,
2604 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2605 .map(|r| {
2606 let r: ownerOfReturn = r.into();
2607 r._0
2608 })
2609 }
2610 }
2611 };
2612 #[derive(serde::Serialize, serde::Deserialize)]
2613 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2614 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2619 #[derive(Clone)]
2620 pub struct safeTransferFrom_0Call {
2621 #[allow(missing_docs)]
2622 pub from: alloy::sol_types::private::Address,
2623 #[allow(missing_docs)]
2624 pub to: alloy::sol_types::private::Address,
2625 #[allow(missing_docs)]
2626 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
2627 }
2628 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2630 #[derive(Clone)]
2631 pub struct safeTransferFrom_0Return {}
2632 #[allow(
2633 non_camel_case_types,
2634 non_snake_case,
2635 clippy::pub_underscore_fields,
2636 clippy::style
2637 )]
2638 const _: () = {
2639 use alloy::sol_types as alloy_sol_types;
2640 {
2641 #[doc(hidden)]
2642 #[allow(dead_code)]
2643 type UnderlyingSolTuple<'a> = (
2644 alloy::sol_types::sol_data::Address,
2645 alloy::sol_types::sol_data::Address,
2646 alloy::sol_types::sol_data::Uint<256>,
2647 );
2648 #[doc(hidden)]
2649 type UnderlyingRustTuple<'a> = (
2650 alloy::sol_types::private::Address,
2651 alloy::sol_types::private::Address,
2652 alloy::sol_types::private::primitives::aliases::U256,
2653 );
2654 #[cfg(test)]
2655 #[allow(dead_code, unreachable_patterns)]
2656 fn _type_assertion(
2657 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2658 ) {
2659 match _t {
2660 alloy_sol_types::private::AssertTypeEq::<
2661 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2662 >(_) => {}
2663 }
2664 }
2665 #[automatically_derived]
2666 #[doc(hidden)]
2667 impl ::core::convert::From<safeTransferFrom_0Call>
2668 for UnderlyingRustTuple<'_> {
2669 fn from(value: safeTransferFrom_0Call) -> Self {
2670 (value.from, value.to, value.tokenId)
2671 }
2672 }
2673 #[automatically_derived]
2674 #[doc(hidden)]
2675 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2676 for safeTransferFrom_0Call {
2677 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2678 Self {
2679 from: tuple.0,
2680 to: tuple.1,
2681 tokenId: tuple.2,
2682 }
2683 }
2684 }
2685 }
2686 {
2687 #[doc(hidden)]
2688 #[allow(dead_code)]
2689 type UnderlyingSolTuple<'a> = ();
2690 #[doc(hidden)]
2691 type UnderlyingRustTuple<'a> = ();
2692 #[cfg(test)]
2693 #[allow(dead_code, unreachable_patterns)]
2694 fn _type_assertion(
2695 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2696 ) {
2697 match _t {
2698 alloy_sol_types::private::AssertTypeEq::<
2699 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2700 >(_) => {}
2701 }
2702 }
2703 #[automatically_derived]
2704 #[doc(hidden)]
2705 impl ::core::convert::From<safeTransferFrom_0Return>
2706 for UnderlyingRustTuple<'_> {
2707 fn from(value: safeTransferFrom_0Return) -> Self {
2708 ()
2709 }
2710 }
2711 #[automatically_derived]
2712 #[doc(hidden)]
2713 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2714 for safeTransferFrom_0Return {
2715 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2716 Self {}
2717 }
2718 }
2719 }
2720 impl safeTransferFrom_0Return {
2721 fn _tokenize(
2722 &self,
2723 ) -> <safeTransferFrom_0Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
2724 ()
2725 }
2726 }
2727 #[automatically_derived]
2728 impl alloy_sol_types::SolCall for safeTransferFrom_0Call {
2729 type Parameters<'a> = (
2730 alloy::sol_types::sol_data::Address,
2731 alloy::sol_types::sol_data::Address,
2732 alloy::sol_types::sol_data::Uint<256>,
2733 );
2734 type Token<'a> = <Self::Parameters<
2735 'a,
2736 > as alloy_sol_types::SolType>::Token<'a>;
2737 type Return = safeTransferFrom_0Return;
2738 type ReturnTuple<'a> = ();
2739 type ReturnToken<'a> = <Self::ReturnTuple<
2740 'a,
2741 > as alloy_sol_types::SolType>::Token<'a>;
2742 const SIGNATURE: &'static str = "safeTransferFrom(address,address,uint256)";
2743 const SELECTOR: [u8; 4] = [66u8, 132u8, 46u8, 14u8];
2744 #[inline]
2745 fn new<'a>(
2746 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2747 ) -> Self {
2748 tuple.into()
2749 }
2750 #[inline]
2751 fn tokenize(&self) -> Self::Token<'_> {
2752 (
2753 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2754 &self.from,
2755 ),
2756 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2757 &self.to,
2758 ),
2759 <alloy::sol_types::sol_data::Uint<
2760 256,
2761 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
2762 )
2763 }
2764 #[inline]
2765 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2766 safeTransferFrom_0Return::_tokenize(ret)
2767 }
2768 #[inline]
2769 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2770 <Self::ReturnTuple<
2771 '_,
2772 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2773 .map(Into::into)
2774 }
2775 #[inline]
2776 fn abi_decode_returns_validate(
2777 data: &[u8],
2778 ) -> alloy_sol_types::Result<Self::Return> {
2779 <Self::ReturnTuple<
2780 '_,
2781 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2782 .map(Into::into)
2783 }
2784 }
2785 };
2786 #[derive(serde::Serialize, serde::Deserialize)]
2787 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2788 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2793 #[derive(Clone)]
2794 pub struct safeTransferFrom_1Call {
2795 #[allow(missing_docs)]
2796 pub from: alloy::sol_types::private::Address,
2797 #[allow(missing_docs)]
2798 pub to: alloy::sol_types::private::Address,
2799 #[allow(missing_docs)]
2800 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
2801 #[allow(missing_docs)]
2802 pub data: alloy::sol_types::private::Bytes,
2803 }
2804 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2806 #[derive(Clone)]
2807 pub struct safeTransferFrom_1Return {}
2808 #[allow(
2809 non_camel_case_types,
2810 non_snake_case,
2811 clippy::pub_underscore_fields,
2812 clippy::style
2813 )]
2814 const _: () = {
2815 use alloy::sol_types as alloy_sol_types;
2816 {
2817 #[doc(hidden)]
2818 #[allow(dead_code)]
2819 type UnderlyingSolTuple<'a> = (
2820 alloy::sol_types::sol_data::Address,
2821 alloy::sol_types::sol_data::Address,
2822 alloy::sol_types::sol_data::Uint<256>,
2823 alloy::sol_types::sol_data::Bytes,
2824 );
2825 #[doc(hidden)]
2826 type UnderlyingRustTuple<'a> = (
2827 alloy::sol_types::private::Address,
2828 alloy::sol_types::private::Address,
2829 alloy::sol_types::private::primitives::aliases::U256,
2830 alloy::sol_types::private::Bytes,
2831 );
2832 #[cfg(test)]
2833 #[allow(dead_code, unreachable_patterns)]
2834 fn _type_assertion(
2835 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2836 ) {
2837 match _t {
2838 alloy_sol_types::private::AssertTypeEq::<
2839 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2840 >(_) => {}
2841 }
2842 }
2843 #[automatically_derived]
2844 #[doc(hidden)]
2845 impl ::core::convert::From<safeTransferFrom_1Call>
2846 for UnderlyingRustTuple<'_> {
2847 fn from(value: safeTransferFrom_1Call) -> Self {
2848 (value.from, value.to, value.tokenId, value.data)
2849 }
2850 }
2851 #[automatically_derived]
2852 #[doc(hidden)]
2853 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2854 for safeTransferFrom_1Call {
2855 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2856 Self {
2857 from: tuple.0,
2858 to: tuple.1,
2859 tokenId: tuple.2,
2860 data: tuple.3,
2861 }
2862 }
2863 }
2864 }
2865 {
2866 #[doc(hidden)]
2867 #[allow(dead_code)]
2868 type UnderlyingSolTuple<'a> = ();
2869 #[doc(hidden)]
2870 type UnderlyingRustTuple<'a> = ();
2871 #[cfg(test)]
2872 #[allow(dead_code, unreachable_patterns)]
2873 fn _type_assertion(
2874 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2875 ) {
2876 match _t {
2877 alloy_sol_types::private::AssertTypeEq::<
2878 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2879 >(_) => {}
2880 }
2881 }
2882 #[automatically_derived]
2883 #[doc(hidden)]
2884 impl ::core::convert::From<safeTransferFrom_1Return>
2885 for UnderlyingRustTuple<'_> {
2886 fn from(value: safeTransferFrom_1Return) -> Self {
2887 ()
2888 }
2889 }
2890 #[automatically_derived]
2891 #[doc(hidden)]
2892 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2893 for safeTransferFrom_1Return {
2894 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2895 Self {}
2896 }
2897 }
2898 }
2899 impl safeTransferFrom_1Return {
2900 fn _tokenize(
2901 &self,
2902 ) -> <safeTransferFrom_1Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
2903 ()
2904 }
2905 }
2906 #[automatically_derived]
2907 impl alloy_sol_types::SolCall for safeTransferFrom_1Call {
2908 type Parameters<'a> = (
2909 alloy::sol_types::sol_data::Address,
2910 alloy::sol_types::sol_data::Address,
2911 alloy::sol_types::sol_data::Uint<256>,
2912 alloy::sol_types::sol_data::Bytes,
2913 );
2914 type Token<'a> = <Self::Parameters<
2915 'a,
2916 > as alloy_sol_types::SolType>::Token<'a>;
2917 type Return = safeTransferFrom_1Return;
2918 type ReturnTuple<'a> = ();
2919 type ReturnToken<'a> = <Self::ReturnTuple<
2920 'a,
2921 > as alloy_sol_types::SolType>::Token<'a>;
2922 const SIGNATURE: &'static str = "safeTransferFrom(address,address,uint256,bytes)";
2923 const SELECTOR: [u8; 4] = [184u8, 141u8, 79u8, 222u8];
2924 #[inline]
2925 fn new<'a>(
2926 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2927 ) -> Self {
2928 tuple.into()
2929 }
2930 #[inline]
2931 fn tokenize(&self) -> Self::Token<'_> {
2932 (
2933 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2934 &self.from,
2935 ),
2936 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2937 &self.to,
2938 ),
2939 <alloy::sol_types::sol_data::Uint<
2940 256,
2941 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
2942 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2943 &self.data,
2944 ),
2945 )
2946 }
2947 #[inline]
2948 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2949 safeTransferFrom_1Return::_tokenize(ret)
2950 }
2951 #[inline]
2952 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2953 <Self::ReturnTuple<
2954 '_,
2955 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2956 .map(Into::into)
2957 }
2958 #[inline]
2959 fn abi_decode_returns_validate(
2960 data: &[u8],
2961 ) -> alloy_sol_types::Result<Self::Return> {
2962 <Self::ReturnTuple<
2963 '_,
2964 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2965 .map(Into::into)
2966 }
2967 }
2968 };
2969 #[derive(serde::Serialize, serde::Deserialize)]
2970 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2971 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2976 #[derive(Clone)]
2977 pub struct setApprovalForAllCall {
2978 #[allow(missing_docs)]
2979 pub operator: alloy::sol_types::private::Address,
2980 #[allow(missing_docs)]
2981 pub approved: bool,
2982 }
2983 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2985 #[derive(Clone)]
2986 pub struct setApprovalForAllReturn {}
2987 #[allow(
2988 non_camel_case_types,
2989 non_snake_case,
2990 clippy::pub_underscore_fields,
2991 clippy::style
2992 )]
2993 const _: () = {
2994 use alloy::sol_types as alloy_sol_types;
2995 {
2996 #[doc(hidden)]
2997 #[allow(dead_code)]
2998 type UnderlyingSolTuple<'a> = (
2999 alloy::sol_types::sol_data::Address,
3000 alloy::sol_types::sol_data::Bool,
3001 );
3002 #[doc(hidden)]
3003 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, bool);
3004 #[cfg(test)]
3005 #[allow(dead_code, unreachable_patterns)]
3006 fn _type_assertion(
3007 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3008 ) {
3009 match _t {
3010 alloy_sol_types::private::AssertTypeEq::<
3011 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3012 >(_) => {}
3013 }
3014 }
3015 #[automatically_derived]
3016 #[doc(hidden)]
3017 impl ::core::convert::From<setApprovalForAllCall>
3018 for UnderlyingRustTuple<'_> {
3019 fn from(value: setApprovalForAllCall) -> Self {
3020 (value.operator, value.approved)
3021 }
3022 }
3023 #[automatically_derived]
3024 #[doc(hidden)]
3025 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3026 for setApprovalForAllCall {
3027 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3028 Self {
3029 operator: tuple.0,
3030 approved: tuple.1,
3031 }
3032 }
3033 }
3034 }
3035 {
3036 #[doc(hidden)]
3037 #[allow(dead_code)]
3038 type UnderlyingSolTuple<'a> = ();
3039 #[doc(hidden)]
3040 type UnderlyingRustTuple<'a> = ();
3041 #[cfg(test)]
3042 #[allow(dead_code, unreachable_patterns)]
3043 fn _type_assertion(
3044 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3045 ) {
3046 match _t {
3047 alloy_sol_types::private::AssertTypeEq::<
3048 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3049 >(_) => {}
3050 }
3051 }
3052 #[automatically_derived]
3053 #[doc(hidden)]
3054 impl ::core::convert::From<setApprovalForAllReturn>
3055 for UnderlyingRustTuple<'_> {
3056 fn from(value: setApprovalForAllReturn) -> Self {
3057 ()
3058 }
3059 }
3060 #[automatically_derived]
3061 #[doc(hidden)]
3062 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3063 for setApprovalForAllReturn {
3064 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3065 Self {}
3066 }
3067 }
3068 }
3069 impl setApprovalForAllReturn {
3070 fn _tokenize(
3071 &self,
3072 ) -> <setApprovalForAllCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3073 ()
3074 }
3075 }
3076 #[automatically_derived]
3077 impl alloy_sol_types::SolCall for setApprovalForAllCall {
3078 type Parameters<'a> = (
3079 alloy::sol_types::sol_data::Address,
3080 alloy::sol_types::sol_data::Bool,
3081 );
3082 type Token<'a> = <Self::Parameters<
3083 'a,
3084 > as alloy_sol_types::SolType>::Token<'a>;
3085 type Return = setApprovalForAllReturn;
3086 type ReturnTuple<'a> = ();
3087 type ReturnToken<'a> = <Self::ReturnTuple<
3088 'a,
3089 > as alloy_sol_types::SolType>::Token<'a>;
3090 const SIGNATURE: &'static str = "setApprovalForAll(address,bool)";
3091 const SELECTOR: [u8; 4] = [162u8, 44u8, 180u8, 101u8];
3092 #[inline]
3093 fn new<'a>(
3094 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3095 ) -> Self {
3096 tuple.into()
3097 }
3098 #[inline]
3099 fn tokenize(&self) -> Self::Token<'_> {
3100 (
3101 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3102 &self.operator,
3103 ),
3104 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
3105 &self.approved,
3106 ),
3107 )
3108 }
3109 #[inline]
3110 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3111 setApprovalForAllReturn::_tokenize(ret)
3112 }
3113 #[inline]
3114 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3115 <Self::ReturnTuple<
3116 '_,
3117 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3118 .map(Into::into)
3119 }
3120 #[inline]
3121 fn abi_decode_returns_validate(
3122 data: &[u8],
3123 ) -> alloy_sol_types::Result<Self::Return> {
3124 <Self::ReturnTuple<
3125 '_,
3126 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3127 .map(Into::into)
3128 }
3129 }
3130 };
3131 #[derive(serde::Serialize, serde::Deserialize)]
3132 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3133 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3138 #[derive(Clone)]
3139 pub struct supportsInterfaceCall {
3140 #[allow(missing_docs)]
3141 pub interfaceId: alloy::sol_types::private::FixedBytes<4>,
3142 }
3143 #[derive(serde::Serialize, serde::Deserialize)]
3144 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3145 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3147 #[derive(Clone)]
3148 pub struct supportsInterfaceReturn {
3149 #[allow(missing_docs)]
3150 pub _0: bool,
3151 }
3152 #[allow(
3153 non_camel_case_types,
3154 non_snake_case,
3155 clippy::pub_underscore_fields,
3156 clippy::style
3157 )]
3158 const _: () = {
3159 use alloy::sol_types as alloy_sol_types;
3160 {
3161 #[doc(hidden)]
3162 #[allow(dead_code)]
3163 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3164 #[doc(hidden)]
3165 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3166 #[cfg(test)]
3167 #[allow(dead_code, unreachable_patterns)]
3168 fn _type_assertion(
3169 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3170 ) {
3171 match _t {
3172 alloy_sol_types::private::AssertTypeEq::<
3173 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3174 >(_) => {}
3175 }
3176 }
3177 #[automatically_derived]
3178 #[doc(hidden)]
3179 impl ::core::convert::From<supportsInterfaceCall>
3180 for UnderlyingRustTuple<'_> {
3181 fn from(value: supportsInterfaceCall) -> Self {
3182 (value.interfaceId,)
3183 }
3184 }
3185 #[automatically_derived]
3186 #[doc(hidden)]
3187 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3188 for supportsInterfaceCall {
3189 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3190 Self { interfaceId: tuple.0 }
3191 }
3192 }
3193 }
3194 {
3195 #[doc(hidden)]
3196 #[allow(dead_code)]
3197 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3198 #[doc(hidden)]
3199 type UnderlyingRustTuple<'a> = (bool,);
3200 #[cfg(test)]
3201 #[allow(dead_code, unreachable_patterns)]
3202 fn _type_assertion(
3203 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3204 ) {
3205 match _t {
3206 alloy_sol_types::private::AssertTypeEq::<
3207 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3208 >(_) => {}
3209 }
3210 }
3211 #[automatically_derived]
3212 #[doc(hidden)]
3213 impl ::core::convert::From<supportsInterfaceReturn>
3214 for UnderlyingRustTuple<'_> {
3215 fn from(value: supportsInterfaceReturn) -> Self {
3216 (value._0,)
3217 }
3218 }
3219 #[automatically_derived]
3220 #[doc(hidden)]
3221 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3222 for supportsInterfaceReturn {
3223 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3224 Self { _0: tuple.0 }
3225 }
3226 }
3227 }
3228 #[automatically_derived]
3229 impl alloy_sol_types::SolCall for supportsInterfaceCall {
3230 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3231 type Token<'a> = <Self::Parameters<
3232 'a,
3233 > as alloy_sol_types::SolType>::Token<'a>;
3234 type Return = bool;
3235 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3236 type ReturnToken<'a> = <Self::ReturnTuple<
3237 'a,
3238 > as alloy_sol_types::SolType>::Token<'a>;
3239 const SIGNATURE: &'static str = "supportsInterface(bytes4)";
3240 const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
3241 #[inline]
3242 fn new<'a>(
3243 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3244 ) -> Self {
3245 tuple.into()
3246 }
3247 #[inline]
3248 fn tokenize(&self) -> Self::Token<'_> {
3249 (
3250 <alloy::sol_types::sol_data::FixedBytes<
3251 4,
3252 > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
3253 )
3254 }
3255 #[inline]
3256 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3257 (
3258 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
3259 ret,
3260 ),
3261 )
3262 }
3263 #[inline]
3264 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3265 <Self::ReturnTuple<
3266 '_,
3267 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3268 .map(|r| {
3269 let r: supportsInterfaceReturn = r.into();
3270 r._0
3271 })
3272 }
3273 #[inline]
3274 fn abi_decode_returns_validate(
3275 data: &[u8],
3276 ) -> alloy_sol_types::Result<Self::Return> {
3277 <Self::ReturnTuple<
3278 '_,
3279 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3280 .map(|r| {
3281 let r: supportsInterfaceReturn = r.into();
3282 r._0
3283 })
3284 }
3285 }
3286 };
3287 #[derive(serde::Serialize, serde::Deserialize)]
3288 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3289 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3294 #[derive(Clone)]
3295 pub struct symbolCall;
3296 #[derive(serde::Serialize, serde::Deserialize)]
3297 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3298 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3300 #[derive(Clone)]
3301 pub struct symbolReturn {
3302 #[allow(missing_docs)]
3303 pub _0: alloy::sol_types::private::String,
3304 }
3305 #[allow(
3306 non_camel_case_types,
3307 non_snake_case,
3308 clippy::pub_underscore_fields,
3309 clippy::style
3310 )]
3311 const _: () = {
3312 use alloy::sol_types as alloy_sol_types;
3313 {
3314 #[doc(hidden)]
3315 #[allow(dead_code)]
3316 type UnderlyingSolTuple<'a> = ();
3317 #[doc(hidden)]
3318 type UnderlyingRustTuple<'a> = ();
3319 #[cfg(test)]
3320 #[allow(dead_code, unreachable_patterns)]
3321 fn _type_assertion(
3322 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3323 ) {
3324 match _t {
3325 alloy_sol_types::private::AssertTypeEq::<
3326 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3327 >(_) => {}
3328 }
3329 }
3330 #[automatically_derived]
3331 #[doc(hidden)]
3332 impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
3333 fn from(value: symbolCall) -> Self {
3334 ()
3335 }
3336 }
3337 #[automatically_derived]
3338 #[doc(hidden)]
3339 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
3340 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3341 Self
3342 }
3343 }
3344 }
3345 {
3346 #[doc(hidden)]
3347 #[allow(dead_code)]
3348 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
3349 #[doc(hidden)]
3350 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
3351 #[cfg(test)]
3352 #[allow(dead_code, unreachable_patterns)]
3353 fn _type_assertion(
3354 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3355 ) {
3356 match _t {
3357 alloy_sol_types::private::AssertTypeEq::<
3358 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3359 >(_) => {}
3360 }
3361 }
3362 #[automatically_derived]
3363 #[doc(hidden)]
3364 impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
3365 fn from(value: symbolReturn) -> Self {
3366 (value._0,)
3367 }
3368 }
3369 #[automatically_derived]
3370 #[doc(hidden)]
3371 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
3372 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3373 Self { _0: tuple.0 }
3374 }
3375 }
3376 }
3377 #[automatically_derived]
3378 impl alloy_sol_types::SolCall for symbolCall {
3379 type Parameters<'a> = ();
3380 type Token<'a> = <Self::Parameters<
3381 'a,
3382 > as alloy_sol_types::SolType>::Token<'a>;
3383 type Return = alloy::sol_types::private::String;
3384 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
3385 type ReturnToken<'a> = <Self::ReturnTuple<
3386 'a,
3387 > as alloy_sol_types::SolType>::Token<'a>;
3388 const SIGNATURE: &'static str = "symbol()";
3389 const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
3390 #[inline]
3391 fn new<'a>(
3392 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3393 ) -> Self {
3394 tuple.into()
3395 }
3396 #[inline]
3397 fn tokenize(&self) -> Self::Token<'_> {
3398 ()
3399 }
3400 #[inline]
3401 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3402 (
3403 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
3404 ret,
3405 ),
3406 )
3407 }
3408 #[inline]
3409 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3410 <Self::ReturnTuple<
3411 '_,
3412 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3413 .map(|r| {
3414 let r: symbolReturn = r.into();
3415 r._0
3416 })
3417 }
3418 #[inline]
3419 fn abi_decode_returns_validate(
3420 data: &[u8],
3421 ) -> alloy_sol_types::Result<Self::Return> {
3422 <Self::ReturnTuple<
3423 '_,
3424 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3425 .map(|r| {
3426 let r: symbolReturn = r.into();
3427 r._0
3428 })
3429 }
3430 }
3431 };
3432 #[derive(serde::Serialize, serde::Deserialize)]
3433 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3434 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3439 #[derive(Clone)]
3440 pub struct tokenURICall {
3441 #[allow(missing_docs)]
3442 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
3443 }
3444 #[derive(serde::Serialize, serde::Deserialize)]
3445 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3446 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3448 #[derive(Clone)]
3449 pub struct tokenURIReturn {
3450 #[allow(missing_docs)]
3451 pub _0: alloy::sol_types::private::String,
3452 }
3453 #[allow(
3454 non_camel_case_types,
3455 non_snake_case,
3456 clippy::pub_underscore_fields,
3457 clippy::style
3458 )]
3459 const _: () = {
3460 use alloy::sol_types as alloy_sol_types;
3461 {
3462 #[doc(hidden)]
3463 #[allow(dead_code)]
3464 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3465 #[doc(hidden)]
3466 type UnderlyingRustTuple<'a> = (
3467 alloy::sol_types::private::primitives::aliases::U256,
3468 );
3469 #[cfg(test)]
3470 #[allow(dead_code, unreachable_patterns)]
3471 fn _type_assertion(
3472 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3473 ) {
3474 match _t {
3475 alloy_sol_types::private::AssertTypeEq::<
3476 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3477 >(_) => {}
3478 }
3479 }
3480 #[automatically_derived]
3481 #[doc(hidden)]
3482 impl ::core::convert::From<tokenURICall> for UnderlyingRustTuple<'_> {
3483 fn from(value: tokenURICall) -> Self {
3484 (value.tokenId,)
3485 }
3486 }
3487 #[automatically_derived]
3488 #[doc(hidden)]
3489 impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenURICall {
3490 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3491 Self { tokenId: tuple.0 }
3492 }
3493 }
3494 }
3495 {
3496 #[doc(hidden)]
3497 #[allow(dead_code)]
3498 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
3499 #[doc(hidden)]
3500 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
3501 #[cfg(test)]
3502 #[allow(dead_code, unreachable_patterns)]
3503 fn _type_assertion(
3504 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3505 ) {
3506 match _t {
3507 alloy_sol_types::private::AssertTypeEq::<
3508 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3509 >(_) => {}
3510 }
3511 }
3512 #[automatically_derived]
3513 #[doc(hidden)]
3514 impl ::core::convert::From<tokenURIReturn> for UnderlyingRustTuple<'_> {
3515 fn from(value: tokenURIReturn) -> Self {
3516 (value._0,)
3517 }
3518 }
3519 #[automatically_derived]
3520 #[doc(hidden)]
3521 impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenURIReturn {
3522 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3523 Self { _0: tuple.0 }
3524 }
3525 }
3526 }
3527 #[automatically_derived]
3528 impl alloy_sol_types::SolCall for tokenURICall {
3529 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3530 type Token<'a> = <Self::Parameters<
3531 'a,
3532 > as alloy_sol_types::SolType>::Token<'a>;
3533 type Return = alloy::sol_types::private::String;
3534 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
3535 type ReturnToken<'a> = <Self::ReturnTuple<
3536 'a,
3537 > as alloy_sol_types::SolType>::Token<'a>;
3538 const SIGNATURE: &'static str = "tokenURI(uint256)";
3539 const SELECTOR: [u8; 4] = [200u8, 123u8, 86u8, 221u8];
3540 #[inline]
3541 fn new<'a>(
3542 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3543 ) -> Self {
3544 tuple.into()
3545 }
3546 #[inline]
3547 fn tokenize(&self) -> Self::Token<'_> {
3548 (
3549 <alloy::sol_types::sol_data::Uint<
3550 256,
3551 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
3552 )
3553 }
3554 #[inline]
3555 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3556 (
3557 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
3558 ret,
3559 ),
3560 )
3561 }
3562 #[inline]
3563 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3564 <Self::ReturnTuple<
3565 '_,
3566 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3567 .map(|r| {
3568 let r: tokenURIReturn = r.into();
3569 r._0
3570 })
3571 }
3572 #[inline]
3573 fn abi_decode_returns_validate(
3574 data: &[u8],
3575 ) -> alloy_sol_types::Result<Self::Return> {
3576 <Self::ReturnTuple<
3577 '_,
3578 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3579 .map(|r| {
3580 let r: tokenURIReturn = r.into();
3581 r._0
3582 })
3583 }
3584 }
3585 };
3586 #[derive(serde::Serialize, serde::Deserialize)]
3587 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3588 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3593 #[derive(Clone)]
3594 pub struct transferFromCall {
3595 #[allow(missing_docs)]
3596 pub from: alloy::sol_types::private::Address,
3597 #[allow(missing_docs)]
3598 pub to: alloy::sol_types::private::Address,
3599 #[allow(missing_docs)]
3600 pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
3601 }
3602 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3604 #[derive(Clone)]
3605 pub struct transferFromReturn {}
3606 #[allow(
3607 non_camel_case_types,
3608 non_snake_case,
3609 clippy::pub_underscore_fields,
3610 clippy::style
3611 )]
3612 const _: () = {
3613 use alloy::sol_types as alloy_sol_types;
3614 {
3615 #[doc(hidden)]
3616 #[allow(dead_code)]
3617 type UnderlyingSolTuple<'a> = (
3618 alloy::sol_types::sol_data::Address,
3619 alloy::sol_types::sol_data::Address,
3620 alloy::sol_types::sol_data::Uint<256>,
3621 );
3622 #[doc(hidden)]
3623 type UnderlyingRustTuple<'a> = (
3624 alloy::sol_types::private::Address,
3625 alloy::sol_types::private::Address,
3626 alloy::sol_types::private::primitives::aliases::U256,
3627 );
3628 #[cfg(test)]
3629 #[allow(dead_code, unreachable_patterns)]
3630 fn _type_assertion(
3631 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3632 ) {
3633 match _t {
3634 alloy_sol_types::private::AssertTypeEq::<
3635 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3636 >(_) => {}
3637 }
3638 }
3639 #[automatically_derived]
3640 #[doc(hidden)]
3641 impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
3642 fn from(value: transferFromCall) -> Self {
3643 (value.from, value.to, value.tokenId)
3644 }
3645 }
3646 #[automatically_derived]
3647 #[doc(hidden)]
3648 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
3649 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3650 Self {
3651 from: tuple.0,
3652 to: tuple.1,
3653 tokenId: tuple.2,
3654 }
3655 }
3656 }
3657 }
3658 {
3659 #[doc(hidden)]
3660 #[allow(dead_code)]
3661 type UnderlyingSolTuple<'a> = ();
3662 #[doc(hidden)]
3663 type UnderlyingRustTuple<'a> = ();
3664 #[cfg(test)]
3665 #[allow(dead_code, unreachable_patterns)]
3666 fn _type_assertion(
3667 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3668 ) {
3669 match _t {
3670 alloy_sol_types::private::AssertTypeEq::<
3671 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3672 >(_) => {}
3673 }
3674 }
3675 #[automatically_derived]
3676 #[doc(hidden)]
3677 impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
3678 fn from(value: transferFromReturn) -> Self {
3679 ()
3680 }
3681 }
3682 #[automatically_derived]
3683 #[doc(hidden)]
3684 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
3685 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3686 Self {}
3687 }
3688 }
3689 }
3690 impl transferFromReturn {
3691 fn _tokenize(
3692 &self,
3693 ) -> <transferFromCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3694 ()
3695 }
3696 }
3697 #[automatically_derived]
3698 impl alloy_sol_types::SolCall for transferFromCall {
3699 type Parameters<'a> = (
3700 alloy::sol_types::sol_data::Address,
3701 alloy::sol_types::sol_data::Address,
3702 alloy::sol_types::sol_data::Uint<256>,
3703 );
3704 type Token<'a> = <Self::Parameters<
3705 'a,
3706 > as alloy_sol_types::SolType>::Token<'a>;
3707 type Return = transferFromReturn;
3708 type ReturnTuple<'a> = ();
3709 type ReturnToken<'a> = <Self::ReturnTuple<
3710 'a,
3711 > as alloy_sol_types::SolType>::Token<'a>;
3712 const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
3713 const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
3714 #[inline]
3715 fn new<'a>(
3716 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3717 ) -> Self {
3718 tuple.into()
3719 }
3720 #[inline]
3721 fn tokenize(&self) -> Self::Token<'_> {
3722 (
3723 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3724 &self.from,
3725 ),
3726 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3727 &self.to,
3728 ),
3729 <alloy::sol_types::sol_data::Uint<
3730 256,
3731 > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
3732 )
3733 }
3734 #[inline]
3735 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3736 transferFromReturn::_tokenize(ret)
3737 }
3738 #[inline]
3739 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3740 <Self::ReturnTuple<
3741 '_,
3742 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3743 .map(Into::into)
3744 }
3745 #[inline]
3746 fn abi_decode_returns_validate(
3747 data: &[u8],
3748 ) -> alloy_sol_types::Result<Self::Return> {
3749 <Self::ReturnTuple<
3750 '_,
3751 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3752 .map(Into::into)
3753 }
3754 }
3755 };
3756 #[derive(Clone)]
3758 #[derive(serde::Serialize, serde::Deserialize)]
3759 #[derive()]
3760 pub enum SimpleERC721Calls {
3761 #[allow(missing_docs)]
3762 approve(approveCall),
3763 #[allow(missing_docs)]
3764 balanceOf(balanceOfCall),
3765 #[allow(missing_docs)]
3766 getApproved(getApprovedCall),
3767 #[allow(missing_docs)]
3768 isApprovedForAll(isApprovedForAllCall),
3769 #[allow(missing_docs)]
3770 name(nameCall),
3771 #[allow(missing_docs)]
3772 ownerOf(ownerOfCall),
3773 #[allow(missing_docs)]
3774 safeTransferFrom_0(safeTransferFrom_0Call),
3775 #[allow(missing_docs)]
3776 safeTransferFrom_1(safeTransferFrom_1Call),
3777 #[allow(missing_docs)]
3778 setApprovalForAll(setApprovalForAllCall),
3779 #[allow(missing_docs)]
3780 supportsInterface(supportsInterfaceCall),
3781 #[allow(missing_docs)]
3782 symbol(symbolCall),
3783 #[allow(missing_docs)]
3784 tokenURI(tokenURICall),
3785 #[allow(missing_docs)]
3786 transferFrom(transferFromCall),
3787 }
3788 impl SimpleERC721Calls {
3789 pub const SELECTORS: &'static [[u8; 4usize]] = &[
3796 [1u8, 255u8, 201u8, 167u8],
3797 [6u8, 253u8, 222u8, 3u8],
3798 [8u8, 24u8, 18u8, 252u8],
3799 [9u8, 94u8, 167u8, 179u8],
3800 [35u8, 184u8, 114u8, 221u8],
3801 [66u8, 132u8, 46u8, 14u8],
3802 [99u8, 82u8, 33u8, 30u8],
3803 [112u8, 160u8, 130u8, 49u8],
3804 [149u8, 216u8, 155u8, 65u8],
3805 [162u8, 44u8, 180u8, 101u8],
3806 [184u8, 141u8, 79u8, 222u8],
3807 [200u8, 123u8, 86u8, 221u8],
3808 [233u8, 133u8, 233u8, 197u8],
3809 ];
3810 pub const VARIANT_NAMES: &'static [&'static str] = &[
3812 ::core::stringify!(supportsInterface),
3813 ::core::stringify!(name),
3814 ::core::stringify!(getApproved),
3815 ::core::stringify!(approve),
3816 ::core::stringify!(transferFrom),
3817 ::core::stringify!(safeTransferFrom_0),
3818 ::core::stringify!(ownerOf),
3819 ::core::stringify!(balanceOf),
3820 ::core::stringify!(symbol),
3821 ::core::stringify!(setApprovalForAll),
3822 ::core::stringify!(safeTransferFrom_1),
3823 ::core::stringify!(tokenURI),
3824 ::core::stringify!(isApprovedForAll),
3825 ];
3826 pub const SIGNATURES: &'static [&'static str] = &[
3828 <supportsInterfaceCall as alloy_sol_types::SolCall>::SIGNATURE,
3829 <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
3830 <getApprovedCall as alloy_sol_types::SolCall>::SIGNATURE,
3831 <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
3832 <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
3833 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::SIGNATURE,
3834 <ownerOfCall as alloy_sol_types::SolCall>::SIGNATURE,
3835 <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
3836 <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
3837 <setApprovalForAllCall as alloy_sol_types::SolCall>::SIGNATURE,
3838 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::SIGNATURE,
3839 <tokenURICall as alloy_sol_types::SolCall>::SIGNATURE,
3840 <isApprovedForAllCall as alloy_sol_types::SolCall>::SIGNATURE,
3841 ];
3842 #[inline]
3844 pub fn signature_by_selector(
3845 selector: [u8; 4usize],
3846 ) -> ::core::option::Option<&'static str> {
3847 match Self::SELECTORS.binary_search(&selector) {
3848 ::core::result::Result::Ok(idx) => {
3849 ::core::option::Option::Some(Self::SIGNATURES[idx])
3850 }
3851 ::core::result::Result::Err(_) => ::core::option::Option::None,
3852 }
3853 }
3854 #[inline]
3856 pub fn name_by_selector(
3857 selector: [u8; 4usize],
3858 ) -> ::core::option::Option<&'static str> {
3859 let sig = Self::signature_by_selector(selector)?;
3860 sig.split_once('(').map(|(name, _)| name)
3861 }
3862 }
3863 #[automatically_derived]
3864 impl alloy_sol_types::SolInterface for SimpleERC721Calls {
3865 const NAME: &'static str = "SimpleERC721Calls";
3866 const MIN_DATA_LENGTH: usize = 0usize;
3867 const COUNT: usize = 13usize;
3868 #[inline]
3869 fn selector(&self) -> [u8; 4] {
3870 match self {
3871 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
3872 Self::balanceOf(_) => {
3873 <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR
3874 }
3875 Self::getApproved(_) => {
3876 <getApprovedCall as alloy_sol_types::SolCall>::SELECTOR
3877 }
3878 Self::isApprovedForAll(_) => {
3879 <isApprovedForAllCall as alloy_sol_types::SolCall>::SELECTOR
3880 }
3881 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
3882 Self::ownerOf(_) => <ownerOfCall as alloy_sol_types::SolCall>::SELECTOR,
3883 Self::safeTransferFrom_0(_) => {
3884 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::SELECTOR
3885 }
3886 Self::safeTransferFrom_1(_) => {
3887 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::SELECTOR
3888 }
3889 Self::setApprovalForAll(_) => {
3890 <setApprovalForAllCall as alloy_sol_types::SolCall>::SELECTOR
3891 }
3892 Self::supportsInterface(_) => {
3893 <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
3894 }
3895 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
3896 Self::tokenURI(_) => <tokenURICall as alloy_sol_types::SolCall>::SELECTOR,
3897 Self::transferFrom(_) => {
3898 <transferFromCall as alloy_sol_types::SolCall>::SELECTOR
3899 }
3900 }
3901 }
3902 #[inline]
3903 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
3904 Self::SELECTORS.get(i).copied()
3905 }
3906 #[inline]
3907 fn valid_selector(selector: [u8; 4]) -> bool {
3908 Self::SELECTORS.binary_search(&selector).is_ok()
3909 }
3910 #[inline]
3911 #[allow(non_snake_case)]
3912 fn abi_decode_raw(
3913 selector: [u8; 4],
3914 data: &[u8],
3915 ) -> alloy_sol_types::Result<Self> {
3916 static DECODE_SHIMS: &[fn(
3917 &[u8],
3918 ) -> alloy_sol_types::Result<SimpleERC721Calls>] = &[
3919 {
3920 fn supportsInterface(
3921 data: &[u8],
3922 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
3923 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(
3924 data,
3925 )
3926 .map(SimpleERC721Calls::supportsInterface)
3927 }
3928 supportsInterface
3929 },
3930 {
3931 fn name(data: &[u8]) -> alloy_sol_types::Result<SimpleERC721Calls> {
3932 <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
3933 .map(SimpleERC721Calls::name)
3934 }
3935 name
3936 },
3937 {
3938 fn getApproved(
3939 data: &[u8],
3940 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
3941 <getApprovedCall as alloy_sol_types::SolCall>::abi_decode_raw(
3942 data,
3943 )
3944 .map(SimpleERC721Calls::getApproved)
3945 }
3946 getApproved
3947 },
3948 {
3949 fn approve(
3950 data: &[u8],
3951 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
3952 <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
3953 .map(SimpleERC721Calls::approve)
3954 }
3955 approve
3956 },
3957 {
3958 fn transferFrom(
3959 data: &[u8],
3960 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
3961 <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(
3962 data,
3963 )
3964 .map(SimpleERC721Calls::transferFrom)
3965 }
3966 transferFrom
3967 },
3968 {
3969 fn safeTransferFrom_0(
3970 data: &[u8],
3971 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
3972 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
3973 data,
3974 )
3975 .map(SimpleERC721Calls::safeTransferFrom_0)
3976 }
3977 safeTransferFrom_0
3978 },
3979 {
3980 fn ownerOf(
3981 data: &[u8],
3982 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
3983 <ownerOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
3984 .map(SimpleERC721Calls::ownerOf)
3985 }
3986 ownerOf
3987 },
3988 {
3989 fn balanceOf(
3990 data: &[u8],
3991 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
3992 <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
3993 .map(SimpleERC721Calls::balanceOf)
3994 }
3995 balanceOf
3996 },
3997 {
3998 fn symbol(
3999 data: &[u8],
4000 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4001 <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4002 .map(SimpleERC721Calls::symbol)
4003 }
4004 symbol
4005 },
4006 {
4007 fn setApprovalForAll(
4008 data: &[u8],
4009 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4010 <setApprovalForAllCall as alloy_sol_types::SolCall>::abi_decode_raw(
4011 data,
4012 )
4013 .map(SimpleERC721Calls::setApprovalForAll)
4014 }
4015 setApprovalForAll
4016 },
4017 {
4018 fn safeTransferFrom_1(
4019 data: &[u8],
4020 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4021 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
4022 data,
4023 )
4024 .map(SimpleERC721Calls::safeTransferFrom_1)
4025 }
4026 safeTransferFrom_1
4027 },
4028 {
4029 fn tokenURI(
4030 data: &[u8],
4031 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4032 <tokenURICall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4033 .map(SimpleERC721Calls::tokenURI)
4034 }
4035 tokenURI
4036 },
4037 {
4038 fn isApprovedForAll(
4039 data: &[u8],
4040 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4041 <isApprovedForAllCall as alloy_sol_types::SolCall>::abi_decode_raw(
4042 data,
4043 )
4044 .map(SimpleERC721Calls::isApprovedForAll)
4045 }
4046 isApprovedForAll
4047 },
4048 ];
4049 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4050 return Err(
4051 alloy_sol_types::Error::unknown_selector(
4052 <Self as alloy_sol_types::SolInterface>::NAME,
4053 selector,
4054 ),
4055 );
4056 };
4057 DECODE_SHIMS[idx](data)
4058 }
4059 #[inline]
4060 #[allow(non_snake_case)]
4061 fn abi_decode_raw_validate(
4062 selector: [u8; 4],
4063 data: &[u8],
4064 ) -> alloy_sol_types::Result<Self> {
4065 static DECODE_VALIDATE_SHIMS: &[fn(
4066 &[u8],
4067 ) -> alloy_sol_types::Result<SimpleERC721Calls>] = &[
4068 {
4069 fn supportsInterface(
4070 data: &[u8],
4071 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4072 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4073 data,
4074 )
4075 .map(SimpleERC721Calls::supportsInterface)
4076 }
4077 supportsInterface
4078 },
4079 {
4080 fn name(data: &[u8]) -> alloy_sol_types::Result<SimpleERC721Calls> {
4081 <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4082 data,
4083 )
4084 .map(SimpleERC721Calls::name)
4085 }
4086 name
4087 },
4088 {
4089 fn getApproved(
4090 data: &[u8],
4091 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4092 <getApprovedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4093 data,
4094 )
4095 .map(SimpleERC721Calls::getApproved)
4096 }
4097 getApproved
4098 },
4099 {
4100 fn approve(
4101 data: &[u8],
4102 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4103 <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4104 data,
4105 )
4106 .map(SimpleERC721Calls::approve)
4107 }
4108 approve
4109 },
4110 {
4111 fn transferFrom(
4112 data: &[u8],
4113 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4114 <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4115 data,
4116 )
4117 .map(SimpleERC721Calls::transferFrom)
4118 }
4119 transferFrom
4120 },
4121 {
4122 fn safeTransferFrom_0(
4123 data: &[u8],
4124 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4125 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4126 data,
4127 )
4128 .map(SimpleERC721Calls::safeTransferFrom_0)
4129 }
4130 safeTransferFrom_0
4131 },
4132 {
4133 fn ownerOf(
4134 data: &[u8],
4135 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4136 <ownerOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4137 data,
4138 )
4139 .map(SimpleERC721Calls::ownerOf)
4140 }
4141 ownerOf
4142 },
4143 {
4144 fn balanceOf(
4145 data: &[u8],
4146 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4147 <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4148 data,
4149 )
4150 .map(SimpleERC721Calls::balanceOf)
4151 }
4152 balanceOf
4153 },
4154 {
4155 fn symbol(
4156 data: &[u8],
4157 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4158 <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4159 data,
4160 )
4161 .map(SimpleERC721Calls::symbol)
4162 }
4163 symbol
4164 },
4165 {
4166 fn setApprovalForAll(
4167 data: &[u8],
4168 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4169 <setApprovalForAllCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4170 data,
4171 )
4172 .map(SimpleERC721Calls::setApprovalForAll)
4173 }
4174 setApprovalForAll
4175 },
4176 {
4177 fn safeTransferFrom_1(
4178 data: &[u8],
4179 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4180 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4181 data,
4182 )
4183 .map(SimpleERC721Calls::safeTransferFrom_1)
4184 }
4185 safeTransferFrom_1
4186 },
4187 {
4188 fn tokenURI(
4189 data: &[u8],
4190 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4191 <tokenURICall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4192 data,
4193 )
4194 .map(SimpleERC721Calls::tokenURI)
4195 }
4196 tokenURI
4197 },
4198 {
4199 fn isApprovedForAll(
4200 data: &[u8],
4201 ) -> alloy_sol_types::Result<SimpleERC721Calls> {
4202 <isApprovedForAllCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4203 data,
4204 )
4205 .map(SimpleERC721Calls::isApprovedForAll)
4206 }
4207 isApprovedForAll
4208 },
4209 ];
4210 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4211 return Err(
4212 alloy_sol_types::Error::unknown_selector(
4213 <Self as alloy_sol_types::SolInterface>::NAME,
4214 selector,
4215 ),
4216 );
4217 };
4218 DECODE_VALIDATE_SHIMS[idx](data)
4219 }
4220 #[inline]
4221 fn abi_encoded_size(&self) -> usize {
4222 match self {
4223 Self::approve(inner) => {
4224 <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4225 }
4226 Self::balanceOf(inner) => {
4227 <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4228 }
4229 Self::getApproved(inner) => {
4230 <getApprovedCall as alloy_sol_types::SolCall>::abi_encoded_size(
4231 inner,
4232 )
4233 }
4234 Self::isApprovedForAll(inner) => {
4235 <isApprovedForAllCall as alloy_sol_types::SolCall>::abi_encoded_size(
4236 inner,
4237 )
4238 }
4239 Self::name(inner) => {
4240 <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4241 }
4242 Self::ownerOf(inner) => {
4243 <ownerOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4244 }
4245 Self::safeTransferFrom_0(inner) => {
4246 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::abi_encoded_size(
4247 inner,
4248 )
4249 }
4250 Self::safeTransferFrom_1(inner) => {
4251 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::abi_encoded_size(
4252 inner,
4253 )
4254 }
4255 Self::setApprovalForAll(inner) => {
4256 <setApprovalForAllCall as alloy_sol_types::SolCall>::abi_encoded_size(
4257 inner,
4258 )
4259 }
4260 Self::supportsInterface(inner) => {
4261 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
4262 inner,
4263 )
4264 }
4265 Self::symbol(inner) => {
4266 <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4267 }
4268 Self::tokenURI(inner) => {
4269 <tokenURICall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4270 }
4271 Self::transferFrom(inner) => {
4272 <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
4273 inner,
4274 )
4275 }
4276 }
4277 }
4278 #[inline]
4279 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4280 match self {
4281 Self::approve(inner) => {
4282 <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4283 }
4284 Self::balanceOf(inner) => {
4285 <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(
4286 inner,
4287 out,
4288 )
4289 }
4290 Self::getApproved(inner) => {
4291 <getApprovedCall as alloy_sol_types::SolCall>::abi_encode_raw(
4292 inner,
4293 out,
4294 )
4295 }
4296 Self::isApprovedForAll(inner) => {
4297 <isApprovedForAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
4298 inner,
4299 out,
4300 )
4301 }
4302 Self::name(inner) => {
4303 <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4304 }
4305 Self::ownerOf(inner) => {
4306 <ownerOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4307 }
4308 Self::safeTransferFrom_0(inner) => {
4309 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
4310 inner,
4311 out,
4312 )
4313 }
4314 Self::safeTransferFrom_1(inner) => {
4315 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
4316 inner,
4317 out,
4318 )
4319 }
4320 Self::setApprovalForAll(inner) => {
4321 <setApprovalForAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
4322 inner,
4323 out,
4324 )
4325 }
4326 Self::supportsInterface(inner) => {
4327 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
4328 inner,
4329 out,
4330 )
4331 }
4332 Self::symbol(inner) => {
4333 <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4334 }
4335 Self::tokenURI(inner) => {
4336 <tokenURICall as alloy_sol_types::SolCall>::abi_encode_raw(
4337 inner,
4338 out,
4339 )
4340 }
4341 Self::transferFrom(inner) => {
4342 <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
4343 inner,
4344 out,
4345 )
4346 }
4347 }
4348 }
4349 }
4350 #[derive(Clone)]
4352 #[derive(serde::Serialize, serde::Deserialize)]
4353 #[derive(Debug, PartialEq, Eq, Hash)]
4354 pub enum SimpleERC721Errors {
4355 #[allow(missing_docs)]
4356 ERC721IncorrectOwner(ERC721IncorrectOwner),
4357 #[allow(missing_docs)]
4358 ERC721InsufficientApproval(ERC721InsufficientApproval),
4359 #[allow(missing_docs)]
4360 ERC721InvalidApprover(ERC721InvalidApprover),
4361 #[allow(missing_docs)]
4362 ERC721InvalidOperator(ERC721InvalidOperator),
4363 #[allow(missing_docs)]
4364 ERC721InvalidOwner(ERC721InvalidOwner),
4365 #[allow(missing_docs)]
4366 ERC721InvalidReceiver(ERC721InvalidReceiver),
4367 #[allow(missing_docs)]
4368 ERC721InvalidSender(ERC721InvalidSender),
4369 #[allow(missing_docs)]
4370 ERC721NonexistentToken(ERC721NonexistentToken),
4371 }
4372 impl SimpleERC721Errors {
4373 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4380 [23u8, 126u8, 128u8, 47u8],
4381 [91u8, 8u8, 186u8, 24u8],
4382 [100u8, 40u8, 61u8, 123u8],
4383 [100u8, 160u8, 174u8, 146u8],
4384 [115u8, 198u8, 172u8, 110u8],
4385 [126u8, 39u8, 50u8, 137u8],
4386 [137u8, 198u8, 43u8, 100u8],
4387 [169u8, 251u8, 245u8, 31u8],
4388 ];
4389 pub const VARIANT_NAMES: &'static [&'static str] = &[
4391 ::core::stringify!(ERC721InsufficientApproval),
4392 ::core::stringify!(ERC721InvalidOperator),
4393 ::core::stringify!(ERC721IncorrectOwner),
4394 ::core::stringify!(ERC721InvalidReceiver),
4395 ::core::stringify!(ERC721InvalidSender),
4396 ::core::stringify!(ERC721NonexistentToken),
4397 ::core::stringify!(ERC721InvalidOwner),
4398 ::core::stringify!(ERC721InvalidApprover),
4399 ];
4400 pub const SIGNATURES: &'static [&'static str] = &[
4402 <ERC721InsufficientApproval as alloy_sol_types::SolError>::SIGNATURE,
4403 <ERC721InvalidOperator as alloy_sol_types::SolError>::SIGNATURE,
4404 <ERC721IncorrectOwner as alloy_sol_types::SolError>::SIGNATURE,
4405 <ERC721InvalidReceiver as alloy_sol_types::SolError>::SIGNATURE,
4406 <ERC721InvalidSender as alloy_sol_types::SolError>::SIGNATURE,
4407 <ERC721NonexistentToken as alloy_sol_types::SolError>::SIGNATURE,
4408 <ERC721InvalidOwner as alloy_sol_types::SolError>::SIGNATURE,
4409 <ERC721InvalidApprover as alloy_sol_types::SolError>::SIGNATURE,
4410 ];
4411 #[inline]
4413 pub fn signature_by_selector(
4414 selector: [u8; 4usize],
4415 ) -> ::core::option::Option<&'static str> {
4416 match Self::SELECTORS.binary_search(&selector) {
4417 ::core::result::Result::Ok(idx) => {
4418 ::core::option::Option::Some(Self::SIGNATURES[idx])
4419 }
4420 ::core::result::Result::Err(_) => ::core::option::Option::None,
4421 }
4422 }
4423 #[inline]
4425 pub fn name_by_selector(
4426 selector: [u8; 4usize],
4427 ) -> ::core::option::Option<&'static str> {
4428 let sig = Self::signature_by_selector(selector)?;
4429 sig.split_once('(').map(|(name, _)| name)
4430 }
4431 }
4432 #[automatically_derived]
4433 impl alloy_sol_types::SolInterface for SimpleERC721Errors {
4434 const NAME: &'static str = "SimpleERC721Errors";
4435 const MIN_DATA_LENGTH: usize = 32usize;
4436 const COUNT: usize = 8usize;
4437 #[inline]
4438 fn selector(&self) -> [u8; 4] {
4439 match self {
4440 Self::ERC721IncorrectOwner(_) => {
4441 <ERC721IncorrectOwner as alloy_sol_types::SolError>::SELECTOR
4442 }
4443 Self::ERC721InsufficientApproval(_) => {
4444 <ERC721InsufficientApproval as alloy_sol_types::SolError>::SELECTOR
4445 }
4446 Self::ERC721InvalidApprover(_) => {
4447 <ERC721InvalidApprover as alloy_sol_types::SolError>::SELECTOR
4448 }
4449 Self::ERC721InvalidOperator(_) => {
4450 <ERC721InvalidOperator as alloy_sol_types::SolError>::SELECTOR
4451 }
4452 Self::ERC721InvalidOwner(_) => {
4453 <ERC721InvalidOwner as alloy_sol_types::SolError>::SELECTOR
4454 }
4455 Self::ERC721InvalidReceiver(_) => {
4456 <ERC721InvalidReceiver as alloy_sol_types::SolError>::SELECTOR
4457 }
4458 Self::ERC721InvalidSender(_) => {
4459 <ERC721InvalidSender as alloy_sol_types::SolError>::SELECTOR
4460 }
4461 Self::ERC721NonexistentToken(_) => {
4462 <ERC721NonexistentToken as alloy_sol_types::SolError>::SELECTOR
4463 }
4464 }
4465 }
4466 #[inline]
4467 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4468 Self::SELECTORS.get(i).copied()
4469 }
4470 #[inline]
4471 fn valid_selector(selector: [u8; 4]) -> bool {
4472 Self::SELECTORS.binary_search(&selector).is_ok()
4473 }
4474 #[inline]
4475 #[allow(non_snake_case)]
4476 fn abi_decode_raw(
4477 selector: [u8; 4],
4478 data: &[u8],
4479 ) -> alloy_sol_types::Result<Self> {
4480 static DECODE_SHIMS: &[fn(
4481 &[u8],
4482 ) -> alloy_sol_types::Result<SimpleERC721Errors>] = &[
4483 {
4484 fn ERC721InsufficientApproval(
4485 data: &[u8],
4486 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4487 <ERC721InsufficientApproval as alloy_sol_types::SolError>::abi_decode_raw(
4488 data,
4489 )
4490 .map(SimpleERC721Errors::ERC721InsufficientApproval)
4491 }
4492 ERC721InsufficientApproval
4493 },
4494 {
4495 fn ERC721InvalidOperator(
4496 data: &[u8],
4497 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4498 <ERC721InvalidOperator as alloy_sol_types::SolError>::abi_decode_raw(
4499 data,
4500 )
4501 .map(SimpleERC721Errors::ERC721InvalidOperator)
4502 }
4503 ERC721InvalidOperator
4504 },
4505 {
4506 fn ERC721IncorrectOwner(
4507 data: &[u8],
4508 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4509 <ERC721IncorrectOwner as alloy_sol_types::SolError>::abi_decode_raw(
4510 data,
4511 )
4512 .map(SimpleERC721Errors::ERC721IncorrectOwner)
4513 }
4514 ERC721IncorrectOwner
4515 },
4516 {
4517 fn ERC721InvalidReceiver(
4518 data: &[u8],
4519 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4520 <ERC721InvalidReceiver as alloy_sol_types::SolError>::abi_decode_raw(
4521 data,
4522 )
4523 .map(SimpleERC721Errors::ERC721InvalidReceiver)
4524 }
4525 ERC721InvalidReceiver
4526 },
4527 {
4528 fn ERC721InvalidSender(
4529 data: &[u8],
4530 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4531 <ERC721InvalidSender as alloy_sol_types::SolError>::abi_decode_raw(
4532 data,
4533 )
4534 .map(SimpleERC721Errors::ERC721InvalidSender)
4535 }
4536 ERC721InvalidSender
4537 },
4538 {
4539 fn ERC721NonexistentToken(
4540 data: &[u8],
4541 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4542 <ERC721NonexistentToken as alloy_sol_types::SolError>::abi_decode_raw(
4543 data,
4544 )
4545 .map(SimpleERC721Errors::ERC721NonexistentToken)
4546 }
4547 ERC721NonexistentToken
4548 },
4549 {
4550 fn ERC721InvalidOwner(
4551 data: &[u8],
4552 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4553 <ERC721InvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
4554 data,
4555 )
4556 .map(SimpleERC721Errors::ERC721InvalidOwner)
4557 }
4558 ERC721InvalidOwner
4559 },
4560 {
4561 fn ERC721InvalidApprover(
4562 data: &[u8],
4563 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4564 <ERC721InvalidApprover as alloy_sol_types::SolError>::abi_decode_raw(
4565 data,
4566 )
4567 .map(SimpleERC721Errors::ERC721InvalidApprover)
4568 }
4569 ERC721InvalidApprover
4570 },
4571 ];
4572 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4573 return Err(
4574 alloy_sol_types::Error::unknown_selector(
4575 <Self as alloy_sol_types::SolInterface>::NAME,
4576 selector,
4577 ),
4578 );
4579 };
4580 DECODE_SHIMS[idx](data)
4581 }
4582 #[inline]
4583 #[allow(non_snake_case)]
4584 fn abi_decode_raw_validate(
4585 selector: [u8; 4],
4586 data: &[u8],
4587 ) -> alloy_sol_types::Result<Self> {
4588 static DECODE_VALIDATE_SHIMS: &[fn(
4589 &[u8],
4590 ) -> alloy_sol_types::Result<SimpleERC721Errors>] = &[
4591 {
4592 fn ERC721InsufficientApproval(
4593 data: &[u8],
4594 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4595 <ERC721InsufficientApproval as alloy_sol_types::SolError>::abi_decode_raw_validate(
4596 data,
4597 )
4598 .map(SimpleERC721Errors::ERC721InsufficientApproval)
4599 }
4600 ERC721InsufficientApproval
4601 },
4602 {
4603 fn ERC721InvalidOperator(
4604 data: &[u8],
4605 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4606 <ERC721InvalidOperator as alloy_sol_types::SolError>::abi_decode_raw_validate(
4607 data,
4608 )
4609 .map(SimpleERC721Errors::ERC721InvalidOperator)
4610 }
4611 ERC721InvalidOperator
4612 },
4613 {
4614 fn ERC721IncorrectOwner(
4615 data: &[u8],
4616 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4617 <ERC721IncorrectOwner as alloy_sol_types::SolError>::abi_decode_raw_validate(
4618 data,
4619 )
4620 .map(SimpleERC721Errors::ERC721IncorrectOwner)
4621 }
4622 ERC721IncorrectOwner
4623 },
4624 {
4625 fn ERC721InvalidReceiver(
4626 data: &[u8],
4627 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4628 <ERC721InvalidReceiver as alloy_sol_types::SolError>::abi_decode_raw_validate(
4629 data,
4630 )
4631 .map(SimpleERC721Errors::ERC721InvalidReceiver)
4632 }
4633 ERC721InvalidReceiver
4634 },
4635 {
4636 fn ERC721InvalidSender(
4637 data: &[u8],
4638 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4639 <ERC721InvalidSender as alloy_sol_types::SolError>::abi_decode_raw_validate(
4640 data,
4641 )
4642 .map(SimpleERC721Errors::ERC721InvalidSender)
4643 }
4644 ERC721InvalidSender
4645 },
4646 {
4647 fn ERC721NonexistentToken(
4648 data: &[u8],
4649 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4650 <ERC721NonexistentToken as alloy_sol_types::SolError>::abi_decode_raw_validate(
4651 data,
4652 )
4653 .map(SimpleERC721Errors::ERC721NonexistentToken)
4654 }
4655 ERC721NonexistentToken
4656 },
4657 {
4658 fn ERC721InvalidOwner(
4659 data: &[u8],
4660 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4661 <ERC721InvalidOwner as alloy_sol_types::SolError>::abi_decode_raw_validate(
4662 data,
4663 )
4664 .map(SimpleERC721Errors::ERC721InvalidOwner)
4665 }
4666 ERC721InvalidOwner
4667 },
4668 {
4669 fn ERC721InvalidApprover(
4670 data: &[u8],
4671 ) -> alloy_sol_types::Result<SimpleERC721Errors> {
4672 <ERC721InvalidApprover as alloy_sol_types::SolError>::abi_decode_raw_validate(
4673 data,
4674 )
4675 .map(SimpleERC721Errors::ERC721InvalidApprover)
4676 }
4677 ERC721InvalidApprover
4678 },
4679 ];
4680 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4681 return Err(
4682 alloy_sol_types::Error::unknown_selector(
4683 <Self as alloy_sol_types::SolInterface>::NAME,
4684 selector,
4685 ),
4686 );
4687 };
4688 DECODE_VALIDATE_SHIMS[idx](data)
4689 }
4690 #[inline]
4691 fn abi_encoded_size(&self) -> usize {
4692 match self {
4693 Self::ERC721IncorrectOwner(inner) => {
4694 <ERC721IncorrectOwner as alloy_sol_types::SolError>::abi_encoded_size(
4695 inner,
4696 )
4697 }
4698 Self::ERC721InsufficientApproval(inner) => {
4699 <ERC721InsufficientApproval as alloy_sol_types::SolError>::abi_encoded_size(
4700 inner,
4701 )
4702 }
4703 Self::ERC721InvalidApprover(inner) => {
4704 <ERC721InvalidApprover as alloy_sol_types::SolError>::abi_encoded_size(
4705 inner,
4706 )
4707 }
4708 Self::ERC721InvalidOperator(inner) => {
4709 <ERC721InvalidOperator as alloy_sol_types::SolError>::abi_encoded_size(
4710 inner,
4711 )
4712 }
4713 Self::ERC721InvalidOwner(inner) => {
4714 <ERC721InvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
4715 inner,
4716 )
4717 }
4718 Self::ERC721InvalidReceiver(inner) => {
4719 <ERC721InvalidReceiver as alloy_sol_types::SolError>::abi_encoded_size(
4720 inner,
4721 )
4722 }
4723 Self::ERC721InvalidSender(inner) => {
4724 <ERC721InvalidSender as alloy_sol_types::SolError>::abi_encoded_size(
4725 inner,
4726 )
4727 }
4728 Self::ERC721NonexistentToken(inner) => {
4729 <ERC721NonexistentToken as alloy_sol_types::SolError>::abi_encoded_size(
4730 inner,
4731 )
4732 }
4733 }
4734 }
4735 #[inline]
4736 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4737 match self {
4738 Self::ERC721IncorrectOwner(inner) => {
4739 <ERC721IncorrectOwner as alloy_sol_types::SolError>::abi_encode_raw(
4740 inner,
4741 out,
4742 )
4743 }
4744 Self::ERC721InsufficientApproval(inner) => {
4745 <ERC721InsufficientApproval as alloy_sol_types::SolError>::abi_encode_raw(
4746 inner,
4747 out,
4748 )
4749 }
4750 Self::ERC721InvalidApprover(inner) => {
4751 <ERC721InvalidApprover as alloy_sol_types::SolError>::abi_encode_raw(
4752 inner,
4753 out,
4754 )
4755 }
4756 Self::ERC721InvalidOperator(inner) => {
4757 <ERC721InvalidOperator as alloy_sol_types::SolError>::abi_encode_raw(
4758 inner,
4759 out,
4760 )
4761 }
4762 Self::ERC721InvalidOwner(inner) => {
4763 <ERC721InvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
4764 inner,
4765 out,
4766 )
4767 }
4768 Self::ERC721InvalidReceiver(inner) => {
4769 <ERC721InvalidReceiver as alloy_sol_types::SolError>::abi_encode_raw(
4770 inner,
4771 out,
4772 )
4773 }
4774 Self::ERC721InvalidSender(inner) => {
4775 <ERC721InvalidSender as alloy_sol_types::SolError>::abi_encode_raw(
4776 inner,
4777 out,
4778 )
4779 }
4780 Self::ERC721NonexistentToken(inner) => {
4781 <ERC721NonexistentToken as alloy_sol_types::SolError>::abi_encode_raw(
4782 inner,
4783 out,
4784 )
4785 }
4786 }
4787 }
4788 }
4789 #[derive(Clone)]
4791 #[derive(serde::Serialize, serde::Deserialize)]
4792 #[derive(Debug, PartialEq, Eq, Hash)]
4793 pub enum SimpleERC721Events {
4794 #[allow(missing_docs)]
4795 Approval(Approval),
4796 #[allow(missing_docs)]
4797 ApprovalForAll(ApprovalForAll),
4798 #[allow(missing_docs)]
4799 Transfer(Transfer),
4800 }
4801 impl SimpleERC721Events {
4802 pub const SELECTORS: &'static [[u8; 32usize]] = &[
4809 [
4810 23u8, 48u8, 126u8, 171u8, 57u8, 171u8, 97u8, 7u8, 232u8, 137u8, 152u8,
4811 69u8, 173u8, 61u8, 89u8, 189u8, 150u8, 83u8, 242u8, 0u8, 242u8, 32u8,
4812 146u8, 4u8, 137u8, 202u8, 43u8, 89u8, 55u8, 105u8, 108u8, 49u8,
4813 ],
4814 [
4815 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8,
4816 66u8, 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8,
4817 41u8, 30u8, 91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
4818 ],
4819 [
4820 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8,
4821 176u8, 104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8,
4822 196u8, 161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
4823 ],
4824 ];
4825 pub const VARIANT_NAMES: &'static [&'static str] = &[
4827 ::core::stringify!(ApprovalForAll),
4828 ::core::stringify!(Approval),
4829 ::core::stringify!(Transfer),
4830 ];
4831 pub const SIGNATURES: &'static [&'static str] = &[
4833 <ApprovalForAll as alloy_sol_types::SolEvent>::SIGNATURE,
4834 <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
4835 <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
4836 ];
4837 #[inline]
4839 pub fn signature_by_selector(
4840 selector: [u8; 32usize],
4841 ) -> ::core::option::Option<&'static str> {
4842 match Self::SELECTORS.binary_search(&selector) {
4843 ::core::result::Result::Ok(idx) => {
4844 ::core::option::Option::Some(Self::SIGNATURES[idx])
4845 }
4846 ::core::result::Result::Err(_) => ::core::option::Option::None,
4847 }
4848 }
4849 #[inline]
4851 pub fn name_by_selector(
4852 selector: [u8; 32usize],
4853 ) -> ::core::option::Option<&'static str> {
4854 let sig = Self::signature_by_selector(selector)?;
4855 sig.split_once('(').map(|(name, _)| name)
4856 }
4857 }
4858 #[automatically_derived]
4859 impl alloy_sol_types::SolEventInterface for SimpleERC721Events {
4860 const NAME: &'static str = "SimpleERC721Events";
4861 const COUNT: usize = 3usize;
4862 fn decode_raw_log(
4863 topics: &[alloy_sol_types::Word],
4864 data: &[u8],
4865 ) -> alloy_sol_types::Result<Self> {
4866 match topics.first().copied() {
4867 Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4868 <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
4869 .map(Self::Approval)
4870 }
4871 Some(<ApprovalForAll as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4872 <ApprovalForAll as alloy_sol_types::SolEvent>::decode_raw_log(
4873 topics,
4874 data,
4875 )
4876 .map(Self::ApprovalForAll)
4877 }
4878 Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4879 <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
4880 .map(Self::Transfer)
4881 }
4882 _ => {
4883 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
4884 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
4885 log: alloy_sol_types::private::Box::new(
4886 alloy_sol_types::private::LogData::new_unchecked(
4887 topics.to_vec(),
4888 data.to_vec().into(),
4889 ),
4890 ),
4891 })
4892 }
4893 }
4894 }
4895 }
4896 #[automatically_derived]
4897 impl alloy_sol_types::private::IntoLogData for SimpleERC721Events {
4898 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4899 match self {
4900 Self::Approval(inner) => {
4901 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4902 }
4903 Self::ApprovalForAll(inner) => {
4904 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4905 }
4906 Self::Transfer(inner) => {
4907 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4908 }
4909 }
4910 }
4911 fn into_log_data(self) -> alloy_sol_types::private::LogData {
4912 match self {
4913 Self::Approval(inner) => {
4914 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4915 }
4916 Self::ApprovalForAll(inner) => {
4917 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4918 }
4919 Self::Transfer(inner) => {
4920 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4921 }
4922 }
4923 }
4924 }
4925 use alloy::contract as alloy_contract;
4926 #[inline]
4930 pub const fn new<
4931 P: alloy_contract::private::Provider<N>,
4932 N: alloy_contract::private::Network,
4933 >(
4934 address: alloy_sol_types::private::Address,
4935 __provider: P,
4936 ) -> SimpleERC721Instance<P, N> {
4937 SimpleERC721Instance::<P, N>::new(address, __provider)
4938 }
4939 #[inline]
4945 pub fn deploy<
4946 P: alloy_contract::private::Provider<N>,
4947 N: alloy_contract::private::Network,
4948 >(
4949 __provider: P,
4950 minter: alloy::sol_types::private::Address,
4951 tokenId: alloy::sol_types::private::primitives::aliases::U256,
4952 ) -> impl ::core::future::Future<
4953 Output = alloy_contract::Result<SimpleERC721Instance<P, N>>,
4954 > {
4955 SimpleERC721Instance::<P, N>::deploy(__provider, minter, tokenId)
4956 }
4957 #[inline]
4963 pub fn deploy_builder<
4964 P: alloy_contract::private::Provider<N>,
4965 N: alloy_contract::private::Network,
4966 >(
4967 __provider: P,
4968 minter: alloy::sol_types::private::Address,
4969 tokenId: alloy::sol_types::private::primitives::aliases::U256,
4970 ) -> alloy_contract::RawCallBuilder<P, N> {
4971 SimpleERC721Instance::<P, N>::deploy_builder(__provider, minter, tokenId)
4972 }
4973 #[derive(Clone)]
4985 pub struct SimpleERC721Instance<P, N = alloy_contract::private::Ethereum> {
4986 address: alloy_sol_types::private::Address,
4987 provider: P,
4988 _network: ::core::marker::PhantomData<N>,
4989 }
4990 #[automatically_derived]
4991 impl<P, N> ::core::fmt::Debug for SimpleERC721Instance<P, N> {
4992 #[inline]
4993 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4994 f.debug_tuple("SimpleERC721Instance").field(&self.address).finish()
4995 }
4996 }
4997 impl<
4999 P: alloy_contract::private::Provider<N>,
5000 N: alloy_contract::private::Network,
5001 > SimpleERC721Instance<P, N> {
5002 #[inline]
5006 pub const fn new(
5007 address: alloy_sol_types::private::Address,
5008 __provider: P,
5009 ) -> Self {
5010 Self {
5011 address,
5012 provider: __provider,
5013 _network: ::core::marker::PhantomData,
5014 }
5015 }
5016 #[inline]
5022 pub async fn deploy(
5023 __provider: P,
5024 minter: alloy::sol_types::private::Address,
5025 tokenId: alloy::sol_types::private::primitives::aliases::U256,
5026 ) -> alloy_contract::Result<SimpleERC721Instance<P, N>> {
5027 let call_builder = Self::deploy_builder(__provider, minter, tokenId);
5028 let contract_address = call_builder.deploy().await?;
5029 Ok(Self::new(contract_address, call_builder.provider))
5030 }
5031 #[inline]
5037 pub fn deploy_builder(
5038 __provider: P,
5039 minter: alloy::sol_types::private::Address,
5040 tokenId: alloy::sol_types::private::primitives::aliases::U256,
5041 ) -> alloy_contract::RawCallBuilder<P, N> {
5042 alloy_contract::RawCallBuilder::new_raw_deploy(
5043 __provider,
5044 [
5045 &BYTECODE[..],
5046 &alloy_sol_types::SolConstructor::abi_encode(
5047 &constructorCall { minter, tokenId },
5048 )[..],
5049 ]
5050 .concat()
5051 .into(),
5052 )
5053 }
5054 #[inline]
5056 pub const fn address(&self) -> &alloy_sol_types::private::Address {
5057 &self.address
5058 }
5059 #[inline]
5061 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
5062 self.address = address;
5063 }
5064 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
5066 self.set_address(address);
5067 self
5068 }
5069 #[inline]
5071 pub const fn provider(&self) -> &P {
5072 &self.provider
5073 }
5074 }
5075 impl<P: ::core::clone::Clone, N> SimpleERC721Instance<&P, N> {
5076 #[inline]
5078 pub fn with_cloned_provider(self) -> SimpleERC721Instance<P, N> {
5079 SimpleERC721Instance {
5080 address: self.address,
5081 provider: ::core::clone::Clone::clone(&self.provider),
5082 _network: ::core::marker::PhantomData,
5083 }
5084 }
5085 }
5086 impl<
5088 P: alloy_contract::private::Provider<N>,
5089 N: alloy_contract::private::Network,
5090 > SimpleERC721Instance<P, N> {
5091 pub fn call_builder<C: alloy_sol_types::SolCall>(
5096 &self,
5097 call: &C,
5098 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
5099 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
5100 }
5101 pub fn approve(
5103 &self,
5104 to: alloy::sol_types::private::Address,
5105 tokenId: alloy::sol_types::private::primitives::aliases::U256,
5106 ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
5107 self.call_builder(&approveCall { to, tokenId })
5108 }
5109 pub fn balanceOf(
5111 &self,
5112 owner: alloy::sol_types::private::Address,
5113 ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
5114 self.call_builder(&balanceOfCall { owner })
5115 }
5116 pub fn getApproved(
5118 &self,
5119 tokenId: alloy::sol_types::private::primitives::aliases::U256,
5120 ) -> alloy_contract::SolCallBuilder<&P, getApprovedCall, N> {
5121 self.call_builder(&getApprovedCall { tokenId })
5122 }
5123 pub fn isApprovedForAll(
5125 &self,
5126 owner: alloy::sol_types::private::Address,
5127 operator: alloy::sol_types::private::Address,
5128 ) -> alloy_contract::SolCallBuilder<&P, isApprovedForAllCall, N> {
5129 self.call_builder(
5130 &isApprovedForAllCall {
5131 owner,
5132 operator,
5133 },
5134 )
5135 }
5136 pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
5138 self.call_builder(&nameCall)
5139 }
5140 pub fn ownerOf(
5142 &self,
5143 tokenId: alloy::sol_types::private::primitives::aliases::U256,
5144 ) -> alloy_contract::SolCallBuilder<&P, ownerOfCall, N> {
5145 self.call_builder(&ownerOfCall { tokenId })
5146 }
5147 pub fn safeTransferFrom_0(
5149 &self,
5150 from: alloy::sol_types::private::Address,
5151 to: alloy::sol_types::private::Address,
5152 tokenId: alloy::sol_types::private::primitives::aliases::U256,
5153 ) -> alloy_contract::SolCallBuilder<&P, safeTransferFrom_0Call, N> {
5154 self.call_builder(
5155 &safeTransferFrom_0Call {
5156 from,
5157 to,
5158 tokenId,
5159 },
5160 )
5161 }
5162 pub fn safeTransferFrom_1(
5164 &self,
5165 from: alloy::sol_types::private::Address,
5166 to: alloy::sol_types::private::Address,
5167 tokenId: alloy::sol_types::private::primitives::aliases::U256,
5168 data: alloy::sol_types::private::Bytes,
5169 ) -> alloy_contract::SolCallBuilder<&P, safeTransferFrom_1Call, N> {
5170 self.call_builder(
5171 &safeTransferFrom_1Call {
5172 from,
5173 to,
5174 tokenId,
5175 data,
5176 },
5177 )
5178 }
5179 pub fn setApprovalForAll(
5181 &self,
5182 operator: alloy::sol_types::private::Address,
5183 approved: bool,
5184 ) -> alloy_contract::SolCallBuilder<&P, setApprovalForAllCall, N> {
5185 self.call_builder(
5186 &setApprovalForAllCall {
5187 operator,
5188 approved,
5189 },
5190 )
5191 }
5192 pub fn supportsInterface(
5194 &self,
5195 interfaceId: alloy::sol_types::private::FixedBytes<4>,
5196 ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
5197 self.call_builder(
5198 &supportsInterfaceCall {
5199 interfaceId,
5200 },
5201 )
5202 }
5203 pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
5205 self.call_builder(&symbolCall)
5206 }
5207 pub fn tokenURI(
5209 &self,
5210 tokenId: alloy::sol_types::private::primitives::aliases::U256,
5211 ) -> alloy_contract::SolCallBuilder<&P, tokenURICall, N> {
5212 self.call_builder(&tokenURICall { tokenId })
5213 }
5214 pub fn transferFrom(
5216 &self,
5217 from: alloy::sol_types::private::Address,
5218 to: alloy::sol_types::private::Address,
5219 tokenId: alloy::sol_types::private::primitives::aliases::U256,
5220 ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
5221 self.call_builder(
5222 &transferFromCall {
5223 from,
5224 to,
5225 tokenId,
5226 },
5227 )
5228 }
5229 }
5230 impl<
5232 P: alloy_contract::private::Provider<N>,
5233 N: alloy_contract::private::Network,
5234 > SimpleERC721Instance<P, N> {
5235 pub fn event_filter<E: alloy_sol_types::SolEvent>(
5240 &self,
5241 ) -> alloy_contract::Event<&P, E, N> {
5242 alloy_contract::Event::new_sol(&self.provider, &self.address)
5243 }
5244 pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
5246 self.event_filter::<Approval>()
5247 }
5248 pub fn ApprovalForAll_filter(
5250 &self,
5251 ) -> alloy_contract::Event<&P, ApprovalForAll, N> {
5252 self.event_filter::<ApprovalForAll>()
5253 }
5254 pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
5256 self.event_filter::<Transfer>()
5257 }
5258 }
5259}