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