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