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#\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#\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::abi_decode_raw_with_config(
551 data,
552 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
553 )
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::abi_decode_raw_with_config(
625 data,
626 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
627 )
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::abi_decode_raw_with_config(
699 data,
700 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
701 )
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::abi_decode_raw_with_config(
782 data,
783 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
784 )
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::abi_decode_raw_with_config(
856 data,
857 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
858 )
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::abi_decode_raw_with_config(
930 data,
931 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
932 )
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::abi_decode_raw_with_config(
1004 data,
1005 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1006 )
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::abi_decode_raw_with_config(
1078 data,
1079 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1080 )
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::abi_decode_raw_with_config(
1152 data,
1153 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1154 )
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::abi_decode_raw_with_config(
1226 data,
1227 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1228 )
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::abi_decode_raw_with_config(
1300 data,
1301 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1302 )
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::abi_decode_raw_with_config(
1381 data,
1382 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1383 )
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::abi_decode_raw_with_config(
1464 data,
1465 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1466 )
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::abi_decode_raw_with_config(
1540 data,
1541 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1542 )
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::abi_decode_raw_with_config(
1616 data,
1617 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1618 )
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::abi_decode_raw_with_config(
1699 data,
1700 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1701 )
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_with_config(
2567 data: &[u8],
2568 config: alloy_sol_types::abi::AbiDecoderConfig,
2569 ) -> alloy_sol_types::Result<Self::Return> {
2570 <Self::ReturnTuple<
2571 '_,
2572 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
2573 data,
2574 config,
2575 )
2576 .map(|r| {
2577 let r: UPGRADE_INTERFACE_VERSIONReturn = r.into();
2578 r._0
2579 })
2580 }
2581 #[inline]
2582 fn abi_decode_returns_validate(
2583 data: &[u8],
2584 ) -> alloy_sol_types::Result<Self::Return> {
2585 Self::abi_decode_returns_with_config(
2586 data,
2587 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2588 )
2589 }
2590 }
2591 };
2592 #[derive(serde::Serialize, serde::Deserialize)]
2593 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2594 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2599 #[derive(Clone)]
2600 pub struct balancesCall {
2601 #[allow(missing_docs)]
2602 pub user: alloy::sol_types::private::Address,
2603 }
2604 #[derive(serde::Serialize, serde::Deserialize)]
2605 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2606 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2608 #[derive(Clone)]
2609 pub struct balancesReturn {
2610 #[allow(missing_docs)]
2611 pub amount: alloy::sol_types::private::primitives::aliases::U256,
2612 }
2613 #[allow(
2614 non_camel_case_types,
2615 non_snake_case,
2616 clippy::pub_underscore_fields,
2617 clippy::style
2618 )]
2619 const _: () = {
2620 use alloy::sol_types as alloy_sol_types;
2621 {
2622 #[doc(hidden)]
2623 #[allow(dead_code)]
2624 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2625 #[doc(hidden)]
2626 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2627 #[cfg(test)]
2628 #[allow(dead_code, unreachable_patterns)]
2629 fn _type_assertion(
2630 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2631 ) {
2632 match _t {
2633 alloy_sol_types::private::AssertTypeEq::<
2634 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2635 >(_) => {}
2636 }
2637 }
2638 #[automatically_derived]
2639 #[doc(hidden)]
2640 impl ::core::convert::From<balancesCall> for UnderlyingRustTuple<'_> {
2641 fn from(value: balancesCall) -> Self {
2642 (value.user,)
2643 }
2644 }
2645 #[automatically_derived]
2646 #[doc(hidden)]
2647 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balancesCall {
2648 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2649 Self { user: tuple.0 }
2650 }
2651 }
2652 }
2653 {
2654 #[doc(hidden)]
2655 #[allow(dead_code)]
2656 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2657 #[doc(hidden)]
2658 type UnderlyingRustTuple<'a> = (
2659 alloy::sol_types::private::primitives::aliases::U256,
2660 );
2661 #[cfg(test)]
2662 #[allow(dead_code, unreachable_patterns)]
2663 fn _type_assertion(
2664 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2665 ) {
2666 match _t {
2667 alloy_sol_types::private::AssertTypeEq::<
2668 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2669 >(_) => {}
2670 }
2671 }
2672 #[automatically_derived]
2673 #[doc(hidden)]
2674 impl ::core::convert::From<balancesReturn> for UnderlyingRustTuple<'_> {
2675 fn from(value: balancesReturn) -> Self {
2676 (value.amount,)
2677 }
2678 }
2679 #[automatically_derived]
2680 #[doc(hidden)]
2681 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balancesReturn {
2682 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2683 Self { amount: tuple.0 }
2684 }
2685 }
2686 }
2687 #[automatically_derived]
2688 impl alloy_sol_types::SolCall for balancesCall {
2689 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2690 type Token<'a> = <Self::Parameters<
2691 'a,
2692 > as alloy_sol_types::SolType>::Token<'a>;
2693 type Return = alloy::sol_types::private::primitives::aliases::U256;
2694 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2695 type ReturnToken<'a> = <Self::ReturnTuple<
2696 'a,
2697 > as alloy_sol_types::SolType>::Token<'a>;
2698 const SIGNATURE: &'static str = "balances(address)";
2699 const SELECTOR: [u8; 4] = [39u8, 226u8, 53u8, 227u8];
2700 #[inline]
2701 fn new<'a>(
2702 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2703 ) -> Self {
2704 tuple.into()
2705 }
2706 #[inline]
2707 fn tokenize(&self) -> Self::Token<'_> {
2708 (
2709 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2710 &self.user,
2711 ),
2712 )
2713 }
2714 #[inline]
2715 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2716 (
2717 <alloy::sol_types::sol_data::Uint<
2718 256,
2719 > as alloy_sol_types::SolType>::tokenize(ret),
2720 )
2721 }
2722 #[inline]
2723 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2724 <Self::ReturnTuple<
2725 '_,
2726 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2727 .map(|r| {
2728 let r: balancesReturn = r.into();
2729 r.amount
2730 })
2731 }
2732 #[inline]
2733 fn abi_decode_returns_with_config(
2734 data: &[u8],
2735 config: alloy_sol_types::abi::AbiDecoderConfig,
2736 ) -> alloy_sol_types::Result<Self::Return> {
2737 <Self::ReturnTuple<
2738 '_,
2739 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
2740 data,
2741 config,
2742 )
2743 .map(|r| {
2744 let r: balancesReturn = r.into();
2745 r.amount
2746 })
2747 }
2748 #[inline]
2749 fn abi_decode_returns_validate(
2750 data: &[u8],
2751 ) -> alloy_sol_types::Result<Self::Return> {
2752 Self::abi_decode_returns_with_config(
2753 data,
2754 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2755 )
2756 }
2757 }
2758 };
2759 #[derive(serde::Serialize, serde::Deserialize)]
2760 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2761 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2766 #[derive(Clone)]
2767 pub struct depositCall {
2768 #[allow(missing_docs)]
2769 pub user: alloy::sol_types::private::Address,
2770 }
2771 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2773 #[derive(Clone)]
2774 pub struct depositReturn {}
2775 #[allow(
2776 non_camel_case_types,
2777 non_snake_case,
2778 clippy::pub_underscore_fields,
2779 clippy::style
2780 )]
2781 const _: () = {
2782 use alloy::sol_types as alloy_sol_types;
2783 {
2784 #[doc(hidden)]
2785 #[allow(dead_code)]
2786 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2787 #[doc(hidden)]
2788 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2789 #[cfg(test)]
2790 #[allow(dead_code, unreachable_patterns)]
2791 fn _type_assertion(
2792 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2793 ) {
2794 match _t {
2795 alloy_sol_types::private::AssertTypeEq::<
2796 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2797 >(_) => {}
2798 }
2799 }
2800 #[automatically_derived]
2801 #[doc(hidden)]
2802 impl ::core::convert::From<depositCall> for UnderlyingRustTuple<'_> {
2803 fn from(value: depositCall) -> Self {
2804 (value.user,)
2805 }
2806 }
2807 #[automatically_derived]
2808 #[doc(hidden)]
2809 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositCall {
2810 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2811 Self { user: tuple.0 }
2812 }
2813 }
2814 }
2815 {
2816 #[doc(hidden)]
2817 #[allow(dead_code)]
2818 type UnderlyingSolTuple<'a> = ();
2819 #[doc(hidden)]
2820 type UnderlyingRustTuple<'a> = ();
2821 #[cfg(test)]
2822 #[allow(dead_code, unreachable_patterns)]
2823 fn _type_assertion(
2824 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2825 ) {
2826 match _t {
2827 alloy_sol_types::private::AssertTypeEq::<
2828 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2829 >(_) => {}
2830 }
2831 }
2832 #[automatically_derived]
2833 #[doc(hidden)]
2834 impl ::core::convert::From<depositReturn> for UnderlyingRustTuple<'_> {
2835 fn from(value: depositReturn) -> Self {
2836 ()
2837 }
2838 }
2839 #[automatically_derived]
2840 #[doc(hidden)]
2841 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositReturn {
2842 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2843 Self {}
2844 }
2845 }
2846 }
2847 impl depositReturn {
2848 fn _tokenize(
2849 &self,
2850 ) -> <depositCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2851 ()
2852 }
2853 }
2854 #[automatically_derived]
2855 impl alloy_sol_types::SolCall for depositCall {
2856 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2857 type Token<'a> = <Self::Parameters<
2858 'a,
2859 > as alloy_sol_types::SolType>::Token<'a>;
2860 type Return = depositReturn;
2861 type ReturnTuple<'a> = ();
2862 type ReturnToken<'a> = <Self::ReturnTuple<
2863 'a,
2864 > as alloy_sol_types::SolType>::Token<'a>;
2865 const SIGNATURE: &'static str = "deposit(address)";
2866 const SELECTOR: [u8; 4] = [243u8, 64u8, 250u8, 1u8];
2867 #[inline]
2868 fn new<'a>(
2869 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2870 ) -> Self {
2871 tuple.into()
2872 }
2873 #[inline]
2874 fn tokenize(&self) -> Self::Token<'_> {
2875 (
2876 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2877 &self.user,
2878 ),
2879 )
2880 }
2881 #[inline]
2882 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2883 depositReturn::_tokenize(ret)
2884 }
2885 #[inline]
2886 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2887 <Self::ReturnTuple<
2888 '_,
2889 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2890 .map(Into::into)
2891 }
2892 #[inline]
2893 fn abi_decode_returns_with_config(
2894 data: &[u8],
2895 config: alloy_sol_types::abi::AbiDecoderConfig,
2896 ) -> alloy_sol_types::Result<Self::Return> {
2897 <Self::ReturnTuple<
2898 '_,
2899 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
2900 data,
2901 config,
2902 )
2903 .map(Into::into)
2904 }
2905 #[inline]
2906 fn abi_decode_returns_validate(
2907 data: &[u8],
2908 ) -> alloy_sol_types::Result<Self::Return> {
2909 Self::abi_decode_returns_with_config(
2910 data,
2911 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2912 )
2913 }
2914 }
2915 };
2916 #[derive(serde::Serialize, serde::Deserialize)]
2917 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2918 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2923 #[derive(Clone)]
2924 pub struct getVersionCall;
2925 #[derive(serde::Serialize, serde::Deserialize)]
2926 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2927 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2929 #[derive(Clone)]
2930 pub struct getVersionReturn {
2931 #[allow(missing_docs)]
2932 pub majorVersion: u8,
2933 #[allow(missing_docs)]
2934 pub minorVersion: u8,
2935 #[allow(missing_docs)]
2936 pub patchVersion: u8,
2937 }
2938 #[allow(
2939 non_camel_case_types,
2940 non_snake_case,
2941 clippy::pub_underscore_fields,
2942 clippy::style
2943 )]
2944 const _: () = {
2945 use alloy::sol_types as alloy_sol_types;
2946 {
2947 #[doc(hidden)]
2948 #[allow(dead_code)]
2949 type UnderlyingSolTuple<'a> = ();
2950 #[doc(hidden)]
2951 type UnderlyingRustTuple<'a> = ();
2952 #[cfg(test)]
2953 #[allow(dead_code, unreachable_patterns)]
2954 fn _type_assertion(
2955 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2956 ) {
2957 match _t {
2958 alloy_sol_types::private::AssertTypeEq::<
2959 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2960 >(_) => {}
2961 }
2962 }
2963 #[automatically_derived]
2964 #[doc(hidden)]
2965 impl ::core::convert::From<getVersionCall> for UnderlyingRustTuple<'_> {
2966 fn from(value: getVersionCall) -> Self {
2967 ()
2968 }
2969 }
2970 #[automatically_derived]
2971 #[doc(hidden)]
2972 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionCall {
2973 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2974 Self
2975 }
2976 }
2977 }
2978 {
2979 #[doc(hidden)]
2980 #[allow(dead_code)]
2981 type UnderlyingSolTuple<'a> = (
2982 alloy::sol_types::sol_data::Uint<8>,
2983 alloy::sol_types::sol_data::Uint<8>,
2984 alloy::sol_types::sol_data::Uint<8>,
2985 );
2986 #[doc(hidden)]
2987 type UnderlyingRustTuple<'a> = (u8, u8, u8);
2988 #[cfg(test)]
2989 #[allow(dead_code, unreachable_patterns)]
2990 fn _type_assertion(
2991 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2992 ) {
2993 match _t {
2994 alloy_sol_types::private::AssertTypeEq::<
2995 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2996 >(_) => {}
2997 }
2998 }
2999 #[automatically_derived]
3000 #[doc(hidden)]
3001 impl ::core::convert::From<getVersionReturn> for UnderlyingRustTuple<'_> {
3002 fn from(value: getVersionReturn) -> Self {
3003 (value.majorVersion, value.minorVersion, value.patchVersion)
3004 }
3005 }
3006 #[automatically_derived]
3007 #[doc(hidden)]
3008 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionReturn {
3009 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3010 Self {
3011 majorVersion: tuple.0,
3012 minorVersion: tuple.1,
3013 patchVersion: tuple.2,
3014 }
3015 }
3016 }
3017 }
3018 impl getVersionReturn {
3019 fn _tokenize(
3020 &self,
3021 ) -> <getVersionCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3022 (
3023 <alloy::sol_types::sol_data::Uint<
3024 8,
3025 > as alloy_sol_types::SolType>::tokenize(&self.majorVersion),
3026 <alloy::sol_types::sol_data::Uint<
3027 8,
3028 > as alloy_sol_types::SolType>::tokenize(&self.minorVersion),
3029 <alloy::sol_types::sol_data::Uint<
3030 8,
3031 > as alloy_sol_types::SolType>::tokenize(&self.patchVersion),
3032 )
3033 }
3034 }
3035 #[automatically_derived]
3036 impl alloy_sol_types::SolCall for getVersionCall {
3037 type Parameters<'a> = ();
3038 type Token<'a> = <Self::Parameters<
3039 'a,
3040 > as alloy_sol_types::SolType>::Token<'a>;
3041 type Return = getVersionReturn;
3042 type ReturnTuple<'a> = (
3043 alloy::sol_types::sol_data::Uint<8>,
3044 alloy::sol_types::sol_data::Uint<8>,
3045 alloy::sol_types::sol_data::Uint<8>,
3046 );
3047 type ReturnToken<'a> = <Self::ReturnTuple<
3048 'a,
3049 > as alloy_sol_types::SolType>::Token<'a>;
3050 const SIGNATURE: &'static str = "getVersion()";
3051 const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8];
3052 #[inline]
3053 fn new<'a>(
3054 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3055 ) -> Self {
3056 tuple.into()
3057 }
3058 #[inline]
3059 fn tokenize(&self) -> Self::Token<'_> {
3060 ()
3061 }
3062 #[inline]
3063 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3064 getVersionReturn::_tokenize(ret)
3065 }
3066 #[inline]
3067 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3068 <Self::ReturnTuple<
3069 '_,
3070 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3071 .map(Into::into)
3072 }
3073 #[inline]
3074 fn abi_decode_returns_with_config(
3075 data: &[u8],
3076 config: alloy_sol_types::abi::AbiDecoderConfig,
3077 ) -> alloy_sol_types::Result<Self::Return> {
3078 <Self::ReturnTuple<
3079 '_,
3080 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3081 data,
3082 config,
3083 )
3084 .map(Into::into)
3085 }
3086 #[inline]
3087 fn abi_decode_returns_validate(
3088 data: &[u8],
3089 ) -> alloy_sol_types::Result<Self::Return> {
3090 Self::abi_decode_returns_with_config(
3091 data,
3092 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3093 )
3094 }
3095 }
3096 };
3097 #[derive(serde::Serialize, serde::Deserialize)]
3098 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3099 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3104 #[derive(Clone)]
3105 pub struct initializeCall {
3106 #[allow(missing_docs)]
3107 pub multisig: alloy::sol_types::private::Address,
3108 }
3109 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3111 #[derive(Clone)]
3112 pub struct initializeReturn {}
3113 #[allow(
3114 non_camel_case_types,
3115 non_snake_case,
3116 clippy::pub_underscore_fields,
3117 clippy::style
3118 )]
3119 const _: () = {
3120 use alloy::sol_types as alloy_sol_types;
3121 {
3122 #[doc(hidden)]
3123 #[allow(dead_code)]
3124 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3125 #[doc(hidden)]
3126 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3127 #[cfg(test)]
3128 #[allow(dead_code, unreachable_patterns)]
3129 fn _type_assertion(
3130 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3131 ) {
3132 match _t {
3133 alloy_sol_types::private::AssertTypeEq::<
3134 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3135 >(_) => {}
3136 }
3137 }
3138 #[automatically_derived]
3139 #[doc(hidden)]
3140 impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
3141 fn from(value: initializeCall) -> Self {
3142 (value.multisig,)
3143 }
3144 }
3145 #[automatically_derived]
3146 #[doc(hidden)]
3147 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
3148 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3149 Self { multisig: tuple.0 }
3150 }
3151 }
3152 }
3153 {
3154 #[doc(hidden)]
3155 #[allow(dead_code)]
3156 type UnderlyingSolTuple<'a> = ();
3157 #[doc(hidden)]
3158 type UnderlyingRustTuple<'a> = ();
3159 #[cfg(test)]
3160 #[allow(dead_code, unreachable_patterns)]
3161 fn _type_assertion(
3162 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3163 ) {
3164 match _t {
3165 alloy_sol_types::private::AssertTypeEq::<
3166 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3167 >(_) => {}
3168 }
3169 }
3170 #[automatically_derived]
3171 #[doc(hidden)]
3172 impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
3173 fn from(value: initializeReturn) -> Self {
3174 ()
3175 }
3176 }
3177 #[automatically_derived]
3178 #[doc(hidden)]
3179 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
3180 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3181 Self {}
3182 }
3183 }
3184 }
3185 impl initializeReturn {
3186 fn _tokenize(
3187 &self,
3188 ) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3189 ()
3190 }
3191 }
3192 #[automatically_derived]
3193 impl alloy_sol_types::SolCall for initializeCall {
3194 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3195 type Token<'a> = <Self::Parameters<
3196 'a,
3197 > as alloy_sol_types::SolType>::Token<'a>;
3198 type Return = initializeReturn;
3199 type ReturnTuple<'a> = ();
3200 type ReturnToken<'a> = <Self::ReturnTuple<
3201 'a,
3202 > as alloy_sol_types::SolType>::Token<'a>;
3203 const SIGNATURE: &'static str = "initialize(address)";
3204 const SELECTOR: [u8; 4] = [196u8, 214u8, 109u8, 232u8];
3205 #[inline]
3206 fn new<'a>(
3207 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3208 ) -> Self {
3209 tuple.into()
3210 }
3211 #[inline]
3212 fn tokenize(&self) -> Self::Token<'_> {
3213 (
3214 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3215 &self.multisig,
3216 ),
3217 )
3218 }
3219 #[inline]
3220 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3221 initializeReturn::_tokenize(ret)
3222 }
3223 #[inline]
3224 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3225 <Self::ReturnTuple<
3226 '_,
3227 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3228 .map(Into::into)
3229 }
3230 #[inline]
3231 fn abi_decode_returns_with_config(
3232 data: &[u8],
3233 config: alloy_sol_types::abi::AbiDecoderConfig,
3234 ) -> alloy_sol_types::Result<Self::Return> {
3235 <Self::ReturnTuple<
3236 '_,
3237 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3238 data,
3239 config,
3240 )
3241 .map(Into::into)
3242 }
3243 #[inline]
3244 fn abi_decode_returns_validate(
3245 data: &[u8],
3246 ) -> alloy_sol_types::Result<Self::Return> {
3247 Self::abi_decode_returns_with_config(
3248 data,
3249 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3250 )
3251 }
3252 }
3253 };
3254 #[derive(serde::Serialize, serde::Deserialize)]
3255 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3256 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3261 #[derive(Clone)]
3262 pub struct maxDepositAmountCall;
3263 #[derive(serde::Serialize, serde::Deserialize)]
3264 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3265 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3267 #[derive(Clone)]
3268 pub struct maxDepositAmountReturn {
3269 #[allow(missing_docs)]
3270 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3271 }
3272 #[allow(
3273 non_camel_case_types,
3274 non_snake_case,
3275 clippy::pub_underscore_fields,
3276 clippy::style
3277 )]
3278 const _: () = {
3279 use alloy::sol_types as alloy_sol_types;
3280 {
3281 #[doc(hidden)]
3282 #[allow(dead_code)]
3283 type UnderlyingSolTuple<'a> = ();
3284 #[doc(hidden)]
3285 type UnderlyingRustTuple<'a> = ();
3286 #[cfg(test)]
3287 #[allow(dead_code, unreachable_patterns)]
3288 fn _type_assertion(
3289 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3290 ) {
3291 match _t {
3292 alloy_sol_types::private::AssertTypeEq::<
3293 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3294 >(_) => {}
3295 }
3296 }
3297 #[automatically_derived]
3298 #[doc(hidden)]
3299 impl ::core::convert::From<maxDepositAmountCall>
3300 for UnderlyingRustTuple<'_> {
3301 fn from(value: maxDepositAmountCall) -> Self {
3302 ()
3303 }
3304 }
3305 #[automatically_derived]
3306 #[doc(hidden)]
3307 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3308 for maxDepositAmountCall {
3309 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3310 Self
3311 }
3312 }
3313 }
3314 {
3315 #[doc(hidden)]
3316 #[allow(dead_code)]
3317 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3318 #[doc(hidden)]
3319 type UnderlyingRustTuple<'a> = (
3320 alloy::sol_types::private::primitives::aliases::U256,
3321 );
3322 #[cfg(test)]
3323 #[allow(dead_code, unreachable_patterns)]
3324 fn _type_assertion(
3325 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3326 ) {
3327 match _t {
3328 alloy_sol_types::private::AssertTypeEq::<
3329 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3330 >(_) => {}
3331 }
3332 }
3333 #[automatically_derived]
3334 #[doc(hidden)]
3335 impl ::core::convert::From<maxDepositAmountReturn>
3336 for UnderlyingRustTuple<'_> {
3337 fn from(value: maxDepositAmountReturn) -> Self {
3338 (value._0,)
3339 }
3340 }
3341 #[automatically_derived]
3342 #[doc(hidden)]
3343 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3344 for maxDepositAmountReturn {
3345 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3346 Self { _0: tuple.0 }
3347 }
3348 }
3349 }
3350 #[automatically_derived]
3351 impl alloy_sol_types::SolCall for maxDepositAmountCall {
3352 type Parameters<'a> = ();
3353 type Token<'a> = <Self::Parameters<
3354 'a,
3355 > as alloy_sol_types::SolType>::Token<'a>;
3356 type Return = alloy::sol_types::private::primitives::aliases::U256;
3357 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3358 type ReturnToken<'a> = <Self::ReturnTuple<
3359 'a,
3360 > as alloy_sol_types::SolType>::Token<'a>;
3361 const SIGNATURE: &'static str = "maxDepositAmount()";
3362 const SELECTOR: [u8; 4] = [142u8, 216u8, 50u8, 113u8];
3363 #[inline]
3364 fn new<'a>(
3365 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3366 ) -> Self {
3367 tuple.into()
3368 }
3369 #[inline]
3370 fn tokenize(&self) -> Self::Token<'_> {
3371 ()
3372 }
3373 #[inline]
3374 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3375 (
3376 <alloy::sol_types::sol_data::Uint<
3377 256,
3378 > as alloy_sol_types::SolType>::tokenize(ret),
3379 )
3380 }
3381 #[inline]
3382 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3383 <Self::ReturnTuple<
3384 '_,
3385 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3386 .map(|r| {
3387 let r: maxDepositAmountReturn = r.into();
3388 r._0
3389 })
3390 }
3391 #[inline]
3392 fn abi_decode_returns_with_config(
3393 data: &[u8],
3394 config: alloy_sol_types::abi::AbiDecoderConfig,
3395 ) -> alloy_sol_types::Result<Self::Return> {
3396 <Self::ReturnTuple<
3397 '_,
3398 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3399 data,
3400 config,
3401 )
3402 .map(|r| {
3403 let r: maxDepositAmountReturn = r.into();
3404 r._0
3405 })
3406 }
3407 #[inline]
3408 fn abi_decode_returns_validate(
3409 data: &[u8],
3410 ) -> alloy_sol_types::Result<Self::Return> {
3411 Self::abi_decode_returns_with_config(
3412 data,
3413 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3414 )
3415 }
3416 }
3417 };
3418 #[derive(serde::Serialize, serde::Deserialize)]
3419 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3420 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3425 #[derive(Clone)]
3426 pub struct minDepositAmountCall;
3427 #[derive(serde::Serialize, serde::Deserialize)]
3428 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3429 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3431 #[derive(Clone)]
3432 pub struct minDepositAmountReturn {
3433 #[allow(missing_docs)]
3434 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3435 }
3436 #[allow(
3437 non_camel_case_types,
3438 non_snake_case,
3439 clippy::pub_underscore_fields,
3440 clippy::style
3441 )]
3442 const _: () = {
3443 use alloy::sol_types as alloy_sol_types;
3444 {
3445 #[doc(hidden)]
3446 #[allow(dead_code)]
3447 type UnderlyingSolTuple<'a> = ();
3448 #[doc(hidden)]
3449 type UnderlyingRustTuple<'a> = ();
3450 #[cfg(test)]
3451 #[allow(dead_code, unreachable_patterns)]
3452 fn _type_assertion(
3453 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3454 ) {
3455 match _t {
3456 alloy_sol_types::private::AssertTypeEq::<
3457 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3458 >(_) => {}
3459 }
3460 }
3461 #[automatically_derived]
3462 #[doc(hidden)]
3463 impl ::core::convert::From<minDepositAmountCall>
3464 for UnderlyingRustTuple<'_> {
3465 fn from(value: minDepositAmountCall) -> Self {
3466 ()
3467 }
3468 }
3469 #[automatically_derived]
3470 #[doc(hidden)]
3471 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3472 for minDepositAmountCall {
3473 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3474 Self
3475 }
3476 }
3477 }
3478 {
3479 #[doc(hidden)]
3480 #[allow(dead_code)]
3481 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3482 #[doc(hidden)]
3483 type UnderlyingRustTuple<'a> = (
3484 alloy::sol_types::private::primitives::aliases::U256,
3485 );
3486 #[cfg(test)]
3487 #[allow(dead_code, unreachable_patterns)]
3488 fn _type_assertion(
3489 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3490 ) {
3491 match _t {
3492 alloy_sol_types::private::AssertTypeEq::<
3493 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3494 >(_) => {}
3495 }
3496 }
3497 #[automatically_derived]
3498 #[doc(hidden)]
3499 impl ::core::convert::From<minDepositAmountReturn>
3500 for UnderlyingRustTuple<'_> {
3501 fn from(value: minDepositAmountReturn) -> Self {
3502 (value._0,)
3503 }
3504 }
3505 #[automatically_derived]
3506 #[doc(hidden)]
3507 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3508 for minDepositAmountReturn {
3509 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3510 Self { _0: tuple.0 }
3511 }
3512 }
3513 }
3514 #[automatically_derived]
3515 impl alloy_sol_types::SolCall for minDepositAmountCall {
3516 type Parameters<'a> = ();
3517 type Token<'a> = <Self::Parameters<
3518 'a,
3519 > as alloy_sol_types::SolType>::Token<'a>;
3520 type Return = alloy::sol_types::private::primitives::aliases::U256;
3521 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3522 type ReturnToken<'a> = <Self::ReturnTuple<
3523 'a,
3524 > as alloy_sol_types::SolType>::Token<'a>;
3525 const SIGNATURE: &'static str = "minDepositAmount()";
3526 const SELECTOR: [u8; 4] = [100u8, 80u8, 6u8, 202u8];
3527 #[inline]
3528 fn new<'a>(
3529 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3530 ) -> Self {
3531 tuple.into()
3532 }
3533 #[inline]
3534 fn tokenize(&self) -> Self::Token<'_> {
3535 ()
3536 }
3537 #[inline]
3538 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3539 (
3540 <alloy::sol_types::sol_data::Uint<
3541 256,
3542 > as alloy_sol_types::SolType>::tokenize(ret),
3543 )
3544 }
3545 #[inline]
3546 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3547 <Self::ReturnTuple<
3548 '_,
3549 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3550 .map(|r| {
3551 let r: minDepositAmountReturn = r.into();
3552 r._0
3553 })
3554 }
3555 #[inline]
3556 fn abi_decode_returns_with_config(
3557 data: &[u8],
3558 config: alloy_sol_types::abi::AbiDecoderConfig,
3559 ) -> alloy_sol_types::Result<Self::Return> {
3560 <Self::ReturnTuple<
3561 '_,
3562 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3563 data,
3564 config,
3565 )
3566 .map(|r| {
3567 let r: minDepositAmountReturn = r.into();
3568 r._0
3569 })
3570 }
3571 #[inline]
3572 fn abi_decode_returns_validate(
3573 data: &[u8],
3574 ) -> alloy_sol_types::Result<Self::Return> {
3575 Self::abi_decode_returns_with_config(
3576 data,
3577 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3578 )
3579 }
3580 }
3581 };
3582 #[derive(serde::Serialize, serde::Deserialize)]
3583 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3584 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3589 #[derive(Clone)]
3590 pub struct ownerCall;
3591 #[derive(serde::Serialize, serde::Deserialize)]
3592 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3593 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3595 #[derive(Clone)]
3596 pub struct ownerReturn {
3597 #[allow(missing_docs)]
3598 pub _0: alloy::sol_types::private::Address,
3599 }
3600 #[allow(
3601 non_camel_case_types,
3602 non_snake_case,
3603 clippy::pub_underscore_fields,
3604 clippy::style
3605 )]
3606 const _: () = {
3607 use alloy::sol_types as alloy_sol_types;
3608 {
3609 #[doc(hidden)]
3610 #[allow(dead_code)]
3611 type UnderlyingSolTuple<'a> = ();
3612 #[doc(hidden)]
3613 type UnderlyingRustTuple<'a> = ();
3614 #[cfg(test)]
3615 #[allow(dead_code, unreachable_patterns)]
3616 fn _type_assertion(
3617 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3618 ) {
3619 match _t {
3620 alloy_sol_types::private::AssertTypeEq::<
3621 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3622 >(_) => {}
3623 }
3624 }
3625 #[automatically_derived]
3626 #[doc(hidden)]
3627 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
3628 fn from(value: ownerCall) -> Self {
3629 ()
3630 }
3631 }
3632 #[automatically_derived]
3633 #[doc(hidden)]
3634 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
3635 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3636 Self
3637 }
3638 }
3639 }
3640 {
3641 #[doc(hidden)]
3642 #[allow(dead_code)]
3643 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3644 #[doc(hidden)]
3645 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3646 #[cfg(test)]
3647 #[allow(dead_code, unreachable_patterns)]
3648 fn _type_assertion(
3649 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3650 ) {
3651 match _t {
3652 alloy_sol_types::private::AssertTypeEq::<
3653 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3654 >(_) => {}
3655 }
3656 }
3657 #[automatically_derived]
3658 #[doc(hidden)]
3659 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
3660 fn from(value: ownerReturn) -> Self {
3661 (value._0,)
3662 }
3663 }
3664 #[automatically_derived]
3665 #[doc(hidden)]
3666 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
3667 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3668 Self { _0: tuple.0 }
3669 }
3670 }
3671 }
3672 #[automatically_derived]
3673 impl alloy_sol_types::SolCall for ownerCall {
3674 type Parameters<'a> = ();
3675 type Token<'a> = <Self::Parameters<
3676 'a,
3677 > as alloy_sol_types::SolType>::Token<'a>;
3678 type Return = alloy::sol_types::private::Address;
3679 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3680 type ReturnToken<'a> = <Self::ReturnTuple<
3681 'a,
3682 > as alloy_sol_types::SolType>::Token<'a>;
3683 const SIGNATURE: &'static str = "owner()";
3684 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
3685 #[inline]
3686 fn new<'a>(
3687 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3688 ) -> Self {
3689 tuple.into()
3690 }
3691 #[inline]
3692 fn tokenize(&self) -> Self::Token<'_> {
3693 ()
3694 }
3695 #[inline]
3696 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3697 (
3698 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3699 ret,
3700 ),
3701 )
3702 }
3703 #[inline]
3704 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3705 <Self::ReturnTuple<
3706 '_,
3707 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3708 .map(|r| {
3709 let r: ownerReturn = r.into();
3710 r._0
3711 })
3712 }
3713 #[inline]
3714 fn abi_decode_returns_with_config(
3715 data: &[u8],
3716 config: alloy_sol_types::abi::AbiDecoderConfig,
3717 ) -> alloy_sol_types::Result<Self::Return> {
3718 <Self::ReturnTuple<
3719 '_,
3720 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3721 data,
3722 config,
3723 )
3724 .map(|r| {
3725 let r: ownerReturn = r.into();
3726 r._0
3727 })
3728 }
3729 #[inline]
3730 fn abi_decode_returns_validate(
3731 data: &[u8],
3732 ) -> alloy_sol_types::Result<Self::Return> {
3733 Self::abi_decode_returns_with_config(
3734 data,
3735 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3736 )
3737 }
3738 }
3739 };
3740 #[derive(serde::Serialize, serde::Deserialize)]
3741 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3742 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3747 #[derive(Clone)]
3748 pub struct proxiableUUIDCall;
3749 #[derive(serde::Serialize, serde::Deserialize)]
3750 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3751 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3753 #[derive(Clone)]
3754 pub struct proxiableUUIDReturn {
3755 #[allow(missing_docs)]
3756 pub _0: alloy::sol_types::private::FixedBytes<32>,
3757 }
3758 #[allow(
3759 non_camel_case_types,
3760 non_snake_case,
3761 clippy::pub_underscore_fields,
3762 clippy::style
3763 )]
3764 const _: () = {
3765 use alloy::sol_types as alloy_sol_types;
3766 {
3767 #[doc(hidden)]
3768 #[allow(dead_code)]
3769 type UnderlyingSolTuple<'a> = ();
3770 #[doc(hidden)]
3771 type UnderlyingRustTuple<'a> = ();
3772 #[cfg(test)]
3773 #[allow(dead_code, unreachable_patterns)]
3774 fn _type_assertion(
3775 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3776 ) {
3777 match _t {
3778 alloy_sol_types::private::AssertTypeEq::<
3779 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3780 >(_) => {}
3781 }
3782 }
3783 #[automatically_derived]
3784 #[doc(hidden)]
3785 impl ::core::convert::From<proxiableUUIDCall> for UnderlyingRustTuple<'_> {
3786 fn from(value: proxiableUUIDCall) -> Self {
3787 ()
3788 }
3789 }
3790 #[automatically_derived]
3791 #[doc(hidden)]
3792 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDCall {
3793 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3794 Self
3795 }
3796 }
3797 }
3798 {
3799 #[doc(hidden)]
3800 #[allow(dead_code)]
3801 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3802 #[doc(hidden)]
3803 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3804 #[cfg(test)]
3805 #[allow(dead_code, unreachable_patterns)]
3806 fn _type_assertion(
3807 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3808 ) {
3809 match _t {
3810 alloy_sol_types::private::AssertTypeEq::<
3811 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3812 >(_) => {}
3813 }
3814 }
3815 #[automatically_derived]
3816 #[doc(hidden)]
3817 impl ::core::convert::From<proxiableUUIDReturn> for UnderlyingRustTuple<'_> {
3818 fn from(value: proxiableUUIDReturn) -> Self {
3819 (value._0,)
3820 }
3821 }
3822 #[automatically_derived]
3823 #[doc(hidden)]
3824 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDReturn {
3825 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3826 Self { _0: tuple.0 }
3827 }
3828 }
3829 }
3830 #[automatically_derived]
3831 impl alloy_sol_types::SolCall for proxiableUUIDCall {
3832 type Parameters<'a> = ();
3833 type Token<'a> = <Self::Parameters<
3834 'a,
3835 > as alloy_sol_types::SolType>::Token<'a>;
3836 type Return = alloy::sol_types::private::FixedBytes<32>;
3837 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3838 type ReturnToken<'a> = <Self::ReturnTuple<
3839 'a,
3840 > as alloy_sol_types::SolType>::Token<'a>;
3841 const SIGNATURE: &'static str = "proxiableUUID()";
3842 const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8];
3843 #[inline]
3844 fn new<'a>(
3845 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3846 ) -> Self {
3847 tuple.into()
3848 }
3849 #[inline]
3850 fn tokenize(&self) -> Self::Token<'_> {
3851 ()
3852 }
3853 #[inline]
3854 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3855 (
3856 <alloy::sol_types::sol_data::FixedBytes<
3857 32,
3858 > as alloy_sol_types::SolType>::tokenize(ret),
3859 )
3860 }
3861 #[inline]
3862 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3863 <Self::ReturnTuple<
3864 '_,
3865 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3866 .map(|r| {
3867 let r: proxiableUUIDReturn = r.into();
3868 r._0
3869 })
3870 }
3871 #[inline]
3872 fn abi_decode_returns_with_config(
3873 data: &[u8],
3874 config: alloy_sol_types::abi::AbiDecoderConfig,
3875 ) -> alloy_sol_types::Result<Self::Return> {
3876 <Self::ReturnTuple<
3877 '_,
3878 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
3879 data,
3880 config,
3881 )
3882 .map(|r| {
3883 let r: proxiableUUIDReturn = r.into();
3884 r._0
3885 })
3886 }
3887 #[inline]
3888 fn abi_decode_returns_validate(
3889 data: &[u8],
3890 ) -> alloy_sol_types::Result<Self::Return> {
3891 Self::abi_decode_returns_with_config(
3892 data,
3893 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
3894 )
3895 }
3896 }
3897 };
3898 #[derive(serde::Serialize, serde::Deserialize)]
3899 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3900 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3905 #[derive(Clone)]
3906 pub struct renounceOwnershipCall;
3907 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3909 #[derive(Clone)]
3910 pub struct renounceOwnershipReturn {}
3911 #[allow(
3912 non_camel_case_types,
3913 non_snake_case,
3914 clippy::pub_underscore_fields,
3915 clippy::style
3916 )]
3917 const _: () = {
3918 use alloy::sol_types as alloy_sol_types;
3919 {
3920 #[doc(hidden)]
3921 #[allow(dead_code)]
3922 type UnderlyingSolTuple<'a> = ();
3923 #[doc(hidden)]
3924 type UnderlyingRustTuple<'a> = ();
3925 #[cfg(test)]
3926 #[allow(dead_code, unreachable_patterns)]
3927 fn _type_assertion(
3928 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3929 ) {
3930 match _t {
3931 alloy_sol_types::private::AssertTypeEq::<
3932 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3933 >(_) => {}
3934 }
3935 }
3936 #[automatically_derived]
3937 #[doc(hidden)]
3938 impl ::core::convert::From<renounceOwnershipCall>
3939 for UnderlyingRustTuple<'_> {
3940 fn from(value: renounceOwnershipCall) -> Self {
3941 ()
3942 }
3943 }
3944 #[automatically_derived]
3945 #[doc(hidden)]
3946 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3947 for renounceOwnershipCall {
3948 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3949 Self
3950 }
3951 }
3952 }
3953 {
3954 #[doc(hidden)]
3955 #[allow(dead_code)]
3956 type UnderlyingSolTuple<'a> = ();
3957 #[doc(hidden)]
3958 type UnderlyingRustTuple<'a> = ();
3959 #[cfg(test)]
3960 #[allow(dead_code, unreachable_patterns)]
3961 fn _type_assertion(
3962 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3963 ) {
3964 match _t {
3965 alloy_sol_types::private::AssertTypeEq::<
3966 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3967 >(_) => {}
3968 }
3969 }
3970 #[automatically_derived]
3971 #[doc(hidden)]
3972 impl ::core::convert::From<renounceOwnershipReturn>
3973 for UnderlyingRustTuple<'_> {
3974 fn from(value: renounceOwnershipReturn) -> Self {
3975 ()
3976 }
3977 }
3978 #[automatically_derived]
3979 #[doc(hidden)]
3980 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3981 for renounceOwnershipReturn {
3982 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3983 Self {}
3984 }
3985 }
3986 }
3987 impl renounceOwnershipReturn {
3988 fn _tokenize(
3989 &self,
3990 ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3991 ()
3992 }
3993 }
3994 #[automatically_derived]
3995 impl alloy_sol_types::SolCall for renounceOwnershipCall {
3996 type Parameters<'a> = ();
3997 type Token<'a> = <Self::Parameters<
3998 'a,
3999 > as alloy_sol_types::SolType>::Token<'a>;
4000 type Return = renounceOwnershipReturn;
4001 type ReturnTuple<'a> = ();
4002 type ReturnToken<'a> = <Self::ReturnTuple<
4003 'a,
4004 > as alloy_sol_types::SolType>::Token<'a>;
4005 const SIGNATURE: &'static str = "renounceOwnership()";
4006 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
4007 #[inline]
4008 fn new<'a>(
4009 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4010 ) -> Self {
4011 tuple.into()
4012 }
4013 #[inline]
4014 fn tokenize(&self) -> Self::Token<'_> {
4015 ()
4016 }
4017 #[inline]
4018 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4019 renounceOwnershipReturn::_tokenize(ret)
4020 }
4021 #[inline]
4022 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4023 <Self::ReturnTuple<
4024 '_,
4025 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4026 .map(Into::into)
4027 }
4028 #[inline]
4029 fn abi_decode_returns_with_config(
4030 data: &[u8],
4031 config: alloy_sol_types::abi::AbiDecoderConfig,
4032 ) -> alloy_sol_types::Result<Self::Return> {
4033 <Self::ReturnTuple<
4034 '_,
4035 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
4036 data,
4037 config,
4038 )
4039 .map(Into::into)
4040 }
4041 #[inline]
4042 fn abi_decode_returns_validate(
4043 data: &[u8],
4044 ) -> alloy_sol_types::Result<Self::Return> {
4045 Self::abi_decode_returns_with_config(
4046 data,
4047 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4048 )
4049 }
4050 }
4051 };
4052 #[derive(serde::Serialize, serde::Deserialize)]
4053 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4054 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4059 #[derive(Clone)]
4060 pub struct transferOwnershipCall {
4061 #[allow(missing_docs)]
4062 pub newOwner: alloy::sol_types::private::Address,
4063 }
4064 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4066 #[derive(Clone)]
4067 pub struct transferOwnershipReturn {}
4068 #[allow(
4069 non_camel_case_types,
4070 non_snake_case,
4071 clippy::pub_underscore_fields,
4072 clippy::style
4073 )]
4074 const _: () = {
4075 use alloy::sol_types as alloy_sol_types;
4076 {
4077 #[doc(hidden)]
4078 #[allow(dead_code)]
4079 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4080 #[doc(hidden)]
4081 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4082 #[cfg(test)]
4083 #[allow(dead_code, unreachable_patterns)]
4084 fn _type_assertion(
4085 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4086 ) {
4087 match _t {
4088 alloy_sol_types::private::AssertTypeEq::<
4089 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4090 >(_) => {}
4091 }
4092 }
4093 #[automatically_derived]
4094 #[doc(hidden)]
4095 impl ::core::convert::From<transferOwnershipCall>
4096 for UnderlyingRustTuple<'_> {
4097 fn from(value: transferOwnershipCall) -> Self {
4098 (value.newOwner,)
4099 }
4100 }
4101 #[automatically_derived]
4102 #[doc(hidden)]
4103 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4104 for transferOwnershipCall {
4105 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4106 Self { newOwner: tuple.0 }
4107 }
4108 }
4109 }
4110 {
4111 #[doc(hidden)]
4112 #[allow(dead_code)]
4113 type UnderlyingSolTuple<'a> = ();
4114 #[doc(hidden)]
4115 type UnderlyingRustTuple<'a> = ();
4116 #[cfg(test)]
4117 #[allow(dead_code, unreachable_patterns)]
4118 fn _type_assertion(
4119 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4120 ) {
4121 match _t {
4122 alloy_sol_types::private::AssertTypeEq::<
4123 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4124 >(_) => {}
4125 }
4126 }
4127 #[automatically_derived]
4128 #[doc(hidden)]
4129 impl ::core::convert::From<transferOwnershipReturn>
4130 for UnderlyingRustTuple<'_> {
4131 fn from(value: transferOwnershipReturn) -> Self {
4132 ()
4133 }
4134 }
4135 #[automatically_derived]
4136 #[doc(hidden)]
4137 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4138 for transferOwnershipReturn {
4139 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4140 Self {}
4141 }
4142 }
4143 }
4144 impl transferOwnershipReturn {
4145 fn _tokenize(
4146 &self,
4147 ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4148 ()
4149 }
4150 }
4151 #[automatically_derived]
4152 impl alloy_sol_types::SolCall for transferOwnershipCall {
4153 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4154 type Token<'a> = <Self::Parameters<
4155 'a,
4156 > as alloy_sol_types::SolType>::Token<'a>;
4157 type Return = transferOwnershipReturn;
4158 type ReturnTuple<'a> = ();
4159 type ReturnToken<'a> = <Self::ReturnTuple<
4160 'a,
4161 > as alloy_sol_types::SolType>::Token<'a>;
4162 const SIGNATURE: &'static str = "transferOwnership(address)";
4163 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
4164 #[inline]
4165 fn new<'a>(
4166 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4167 ) -> Self {
4168 tuple.into()
4169 }
4170 #[inline]
4171 fn tokenize(&self) -> Self::Token<'_> {
4172 (
4173 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4174 &self.newOwner,
4175 ),
4176 )
4177 }
4178 #[inline]
4179 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4180 transferOwnershipReturn::_tokenize(ret)
4181 }
4182 #[inline]
4183 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4184 <Self::ReturnTuple<
4185 '_,
4186 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4187 .map(Into::into)
4188 }
4189 #[inline]
4190 fn abi_decode_returns_with_config(
4191 data: &[u8],
4192 config: alloy_sol_types::abi::AbiDecoderConfig,
4193 ) -> alloy_sol_types::Result<Self::Return> {
4194 <Self::ReturnTuple<
4195 '_,
4196 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
4197 data,
4198 config,
4199 )
4200 .map(Into::into)
4201 }
4202 #[inline]
4203 fn abi_decode_returns_validate(
4204 data: &[u8],
4205 ) -> alloy_sol_types::Result<Self::Return> {
4206 Self::abi_decode_returns_with_config(
4207 data,
4208 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4209 )
4210 }
4211 }
4212 };
4213 #[derive(serde::Serialize, serde::Deserialize)]
4214 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4215 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4220 #[derive(Clone)]
4221 pub struct upgradeToAndCallCall {
4222 #[allow(missing_docs)]
4223 pub newImplementation: alloy::sol_types::private::Address,
4224 #[allow(missing_docs)]
4225 pub data: alloy::sol_types::private::Bytes,
4226 }
4227 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4229 #[derive(Clone)]
4230 pub struct upgradeToAndCallReturn {}
4231 #[allow(
4232 non_camel_case_types,
4233 non_snake_case,
4234 clippy::pub_underscore_fields,
4235 clippy::style
4236 )]
4237 const _: () = {
4238 use alloy::sol_types as alloy_sol_types;
4239 {
4240 #[doc(hidden)]
4241 #[allow(dead_code)]
4242 type UnderlyingSolTuple<'a> = (
4243 alloy::sol_types::sol_data::Address,
4244 alloy::sol_types::sol_data::Bytes,
4245 );
4246 #[doc(hidden)]
4247 type UnderlyingRustTuple<'a> = (
4248 alloy::sol_types::private::Address,
4249 alloy::sol_types::private::Bytes,
4250 );
4251 #[cfg(test)]
4252 #[allow(dead_code, unreachable_patterns)]
4253 fn _type_assertion(
4254 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4255 ) {
4256 match _t {
4257 alloy_sol_types::private::AssertTypeEq::<
4258 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4259 >(_) => {}
4260 }
4261 }
4262 #[automatically_derived]
4263 #[doc(hidden)]
4264 impl ::core::convert::From<upgradeToAndCallCall>
4265 for UnderlyingRustTuple<'_> {
4266 fn from(value: upgradeToAndCallCall) -> Self {
4267 (value.newImplementation, value.data)
4268 }
4269 }
4270 #[automatically_derived]
4271 #[doc(hidden)]
4272 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4273 for upgradeToAndCallCall {
4274 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4275 Self {
4276 newImplementation: tuple.0,
4277 data: tuple.1,
4278 }
4279 }
4280 }
4281 }
4282 {
4283 #[doc(hidden)]
4284 #[allow(dead_code)]
4285 type UnderlyingSolTuple<'a> = ();
4286 #[doc(hidden)]
4287 type UnderlyingRustTuple<'a> = ();
4288 #[cfg(test)]
4289 #[allow(dead_code, unreachable_patterns)]
4290 fn _type_assertion(
4291 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4292 ) {
4293 match _t {
4294 alloy_sol_types::private::AssertTypeEq::<
4295 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4296 >(_) => {}
4297 }
4298 }
4299 #[automatically_derived]
4300 #[doc(hidden)]
4301 impl ::core::convert::From<upgradeToAndCallReturn>
4302 for UnderlyingRustTuple<'_> {
4303 fn from(value: upgradeToAndCallReturn) -> Self {
4304 ()
4305 }
4306 }
4307 #[automatically_derived]
4308 #[doc(hidden)]
4309 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4310 for upgradeToAndCallReturn {
4311 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4312 Self {}
4313 }
4314 }
4315 }
4316 impl upgradeToAndCallReturn {
4317 fn _tokenize(
4318 &self,
4319 ) -> <upgradeToAndCallCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4320 ()
4321 }
4322 }
4323 #[automatically_derived]
4324 impl alloy_sol_types::SolCall for upgradeToAndCallCall {
4325 type Parameters<'a> = (
4326 alloy::sol_types::sol_data::Address,
4327 alloy::sol_types::sol_data::Bytes,
4328 );
4329 type Token<'a> = <Self::Parameters<
4330 'a,
4331 > as alloy_sol_types::SolType>::Token<'a>;
4332 type Return = upgradeToAndCallReturn;
4333 type ReturnTuple<'a> = ();
4334 type ReturnToken<'a> = <Self::ReturnTuple<
4335 'a,
4336 > as alloy_sol_types::SolType>::Token<'a>;
4337 const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)";
4338 const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8];
4339 #[inline]
4340 fn new<'a>(
4341 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4342 ) -> Self {
4343 tuple.into()
4344 }
4345 #[inline]
4346 fn tokenize(&self) -> Self::Token<'_> {
4347 (
4348 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4349 &self.newImplementation,
4350 ),
4351 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
4352 &self.data,
4353 ),
4354 )
4355 }
4356 #[inline]
4357 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4358 upgradeToAndCallReturn::_tokenize(ret)
4359 }
4360 #[inline]
4361 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4362 <Self::ReturnTuple<
4363 '_,
4364 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4365 .map(Into::into)
4366 }
4367 #[inline]
4368 fn abi_decode_returns_with_config(
4369 data: &[u8],
4370 config: alloy_sol_types::abi::AbiDecoderConfig,
4371 ) -> alloy_sol_types::Result<Self::Return> {
4372 <Self::ReturnTuple<
4373 '_,
4374 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
4375 data,
4376 config,
4377 )
4378 .map(Into::into)
4379 }
4380 #[inline]
4381 fn abi_decode_returns_validate(
4382 data: &[u8],
4383 ) -> alloy_sol_types::Result<Self::Return> {
4384 Self::abi_decode_returns_with_config(
4385 data,
4386 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4387 )
4388 }
4389 }
4390 };
4391 #[derive(Clone)]
4393 #[derive(serde::Serialize, serde::Deserialize)]
4394 #[derive(Debug, PartialEq, Eq, Hash)]
4395 pub enum FeeContractCalls {
4396 #[allow(missing_docs)]
4397 UPGRADE_INTERFACE_VERSION(UPGRADE_INTERFACE_VERSIONCall),
4398 #[allow(missing_docs)]
4399 balances(balancesCall),
4400 #[allow(missing_docs)]
4401 deposit(depositCall),
4402 #[allow(missing_docs)]
4403 getVersion(getVersionCall),
4404 #[allow(missing_docs)]
4405 initialize(initializeCall),
4406 #[allow(missing_docs)]
4407 maxDepositAmount(maxDepositAmountCall),
4408 #[allow(missing_docs)]
4409 minDepositAmount(minDepositAmountCall),
4410 #[allow(missing_docs)]
4411 owner(ownerCall),
4412 #[allow(missing_docs)]
4413 proxiableUUID(proxiableUUIDCall),
4414 #[allow(missing_docs)]
4415 renounceOwnership(renounceOwnershipCall),
4416 #[allow(missing_docs)]
4417 transferOwnership(transferOwnershipCall),
4418 #[allow(missing_docs)]
4419 upgradeToAndCall(upgradeToAndCallCall),
4420 }
4421 impl FeeContractCalls {
4422 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4429 [13u8, 142u8, 110u8, 44u8],
4430 [39u8, 226u8, 53u8, 227u8],
4431 [79u8, 30u8, 242u8, 134u8],
4432 [82u8, 209u8, 144u8, 45u8],
4433 [100u8, 80u8, 6u8, 202u8],
4434 [113u8, 80u8, 24u8, 166u8],
4435 [141u8, 165u8, 203u8, 91u8],
4436 [142u8, 216u8, 50u8, 113u8],
4437 [173u8, 60u8, 177u8, 204u8],
4438 [196u8, 214u8, 109u8, 232u8],
4439 [242u8, 253u8, 227u8, 139u8],
4440 [243u8, 64u8, 250u8, 1u8],
4441 ];
4442 pub const VARIANT_NAMES: &'static [&'static str] = &[
4444 ::core::stringify!(getVersion),
4445 ::core::stringify!(balances),
4446 ::core::stringify!(upgradeToAndCall),
4447 ::core::stringify!(proxiableUUID),
4448 ::core::stringify!(minDepositAmount),
4449 ::core::stringify!(renounceOwnership),
4450 ::core::stringify!(owner),
4451 ::core::stringify!(maxDepositAmount),
4452 ::core::stringify!(UPGRADE_INTERFACE_VERSION),
4453 ::core::stringify!(initialize),
4454 ::core::stringify!(transferOwnership),
4455 ::core::stringify!(deposit),
4456 ];
4457 pub const SIGNATURES: &'static [&'static str] = &[
4459 <getVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
4460 <balancesCall as alloy_sol_types::SolCall>::SIGNATURE,
4461 <upgradeToAndCallCall as alloy_sol_types::SolCall>::SIGNATURE,
4462 <proxiableUUIDCall as alloy_sol_types::SolCall>::SIGNATURE,
4463 <minDepositAmountCall as alloy_sol_types::SolCall>::SIGNATURE,
4464 <renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
4465 <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
4466 <maxDepositAmountCall as alloy_sol_types::SolCall>::SIGNATURE,
4467 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SIGNATURE,
4468 <initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
4469 <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
4470 <depositCall as alloy_sol_types::SolCall>::SIGNATURE,
4471 ];
4472 #[inline]
4474 pub fn signature_by_selector(
4475 selector: [u8; 4usize],
4476 ) -> ::core::option::Option<&'static str> {
4477 match Self::SELECTORS.binary_search(&selector) {
4478 ::core::result::Result::Ok(idx) => {
4479 ::core::option::Option::Some(Self::SIGNATURES[idx])
4480 }
4481 ::core::result::Result::Err(_) => ::core::option::Option::None,
4482 }
4483 }
4484 #[inline]
4486 pub fn name_by_selector(
4487 selector: [u8; 4usize],
4488 ) -> ::core::option::Option<&'static str> {
4489 let sig = Self::signature_by_selector(selector)?;
4490 sig.split_once('(').map(|(name, _)| name)
4491 }
4492 }
4493 #[automatically_derived]
4494 impl alloy_sol_types::SolInterface for FeeContractCalls {
4495 const NAME: &'static str = "FeeContractCalls";
4496 const MIN_DATA_LENGTH: usize = 0usize;
4497 const COUNT: usize = 12usize;
4498 #[inline]
4499 fn selector(&self) -> [u8; 4] {
4500 match self {
4501 Self::UPGRADE_INTERFACE_VERSION(_) => {
4502 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SELECTOR
4503 }
4504 Self::balances(_) => <balancesCall as alloy_sol_types::SolCall>::SELECTOR,
4505 Self::deposit(_) => <depositCall as alloy_sol_types::SolCall>::SELECTOR,
4506 Self::getVersion(_) => {
4507 <getVersionCall as alloy_sol_types::SolCall>::SELECTOR
4508 }
4509 Self::initialize(_) => {
4510 <initializeCall as alloy_sol_types::SolCall>::SELECTOR
4511 }
4512 Self::maxDepositAmount(_) => {
4513 <maxDepositAmountCall as alloy_sol_types::SolCall>::SELECTOR
4514 }
4515 Self::minDepositAmount(_) => {
4516 <minDepositAmountCall as alloy_sol_types::SolCall>::SELECTOR
4517 }
4518 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
4519 Self::proxiableUUID(_) => {
4520 <proxiableUUIDCall as alloy_sol_types::SolCall>::SELECTOR
4521 }
4522 Self::renounceOwnership(_) => {
4523 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4524 }
4525 Self::transferOwnership(_) => {
4526 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4527 }
4528 Self::upgradeToAndCall(_) => {
4529 <upgradeToAndCallCall as alloy_sol_types::SolCall>::SELECTOR
4530 }
4531 }
4532 }
4533 #[inline]
4534 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4535 Self::SELECTORS.get(i).copied()
4536 }
4537 #[inline]
4538 fn valid_selector(selector: [u8; 4]) -> bool {
4539 Self::SELECTORS.binary_search(&selector).is_ok()
4540 }
4541 #[inline]
4542 #[allow(non_snake_case)]
4543 fn abi_decode_raw(
4544 selector: [u8; 4],
4545 data: &[u8],
4546 ) -> alloy_sol_types::Result<Self> {
4547 Self::abi_decode_raw_with_config(
4548 selector,
4549 data,
4550 alloy_sol_types::abi::AbiDecoderConfig::default(),
4551 )
4552 }
4553 #[inline]
4554 #[allow(non_snake_case)]
4555 fn abi_decode_raw_with_config(
4556 selector: [u8; 4],
4557 data: &[u8],
4558 config: alloy_sol_types::abi::AbiDecoderConfig,
4559 ) -> alloy_sol_types::Result<Self> {
4560 static DECODE_SHIMS: &[fn(
4561 &[u8],
4562 alloy_sol_types::abi::AbiDecoderConfig,
4563 ) -> alloy_sol_types::Result<FeeContractCalls>] = &[
4564 {
4565 fn getVersion(
4566 data: &[u8],
4567 config: alloy_sol_types::abi::AbiDecoderConfig,
4568 ) -> alloy_sol_types::Result<FeeContractCalls> {
4569 <getVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4570 data,
4571 config,
4572 )
4573 .map(FeeContractCalls::getVersion)
4574 }
4575 getVersion
4576 },
4577 {
4578 fn balances(
4579 data: &[u8],
4580 config: alloy_sol_types::abi::AbiDecoderConfig,
4581 ) -> alloy_sol_types::Result<FeeContractCalls> {
4582 <balancesCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4583 data,
4584 config,
4585 )
4586 .map(FeeContractCalls::balances)
4587 }
4588 balances
4589 },
4590 {
4591 fn upgradeToAndCall(
4592 data: &[u8],
4593 config: alloy_sol_types::abi::AbiDecoderConfig,
4594 ) -> alloy_sol_types::Result<FeeContractCalls> {
4595 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4596 data,
4597 config,
4598 )
4599 .map(FeeContractCalls::upgradeToAndCall)
4600 }
4601 upgradeToAndCall
4602 },
4603 {
4604 fn proxiableUUID(
4605 data: &[u8],
4606 config: alloy_sol_types::abi::AbiDecoderConfig,
4607 ) -> alloy_sol_types::Result<FeeContractCalls> {
4608 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4609 data,
4610 config,
4611 )
4612 .map(FeeContractCalls::proxiableUUID)
4613 }
4614 proxiableUUID
4615 },
4616 {
4617 fn minDepositAmount(
4618 data: &[u8],
4619 config: alloy_sol_types::abi::AbiDecoderConfig,
4620 ) -> alloy_sol_types::Result<FeeContractCalls> {
4621 <minDepositAmountCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4622 data,
4623 config,
4624 )
4625 .map(FeeContractCalls::minDepositAmount)
4626 }
4627 minDepositAmount
4628 },
4629 {
4630 fn renounceOwnership(
4631 data: &[u8],
4632 config: alloy_sol_types::abi::AbiDecoderConfig,
4633 ) -> alloy_sol_types::Result<FeeContractCalls> {
4634 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4635 data,
4636 config,
4637 )
4638 .map(FeeContractCalls::renounceOwnership)
4639 }
4640 renounceOwnership
4641 },
4642 {
4643 fn owner(
4644 data: &[u8],
4645 config: alloy_sol_types::abi::AbiDecoderConfig,
4646 ) -> alloy_sol_types::Result<FeeContractCalls> {
4647 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4648 data,
4649 config,
4650 )
4651 .map(FeeContractCalls::owner)
4652 }
4653 owner
4654 },
4655 {
4656 fn maxDepositAmount(
4657 data: &[u8],
4658 config: alloy_sol_types::abi::AbiDecoderConfig,
4659 ) -> alloy_sol_types::Result<FeeContractCalls> {
4660 <maxDepositAmountCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4661 data,
4662 config,
4663 )
4664 .map(FeeContractCalls::maxDepositAmount)
4665 }
4666 maxDepositAmount
4667 },
4668 {
4669 fn UPGRADE_INTERFACE_VERSION(
4670 data: &[u8],
4671 config: alloy_sol_types::abi::AbiDecoderConfig,
4672 ) -> alloy_sol_types::Result<FeeContractCalls> {
4673 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4674 data,
4675 config,
4676 )
4677 .map(FeeContractCalls::UPGRADE_INTERFACE_VERSION)
4678 }
4679 UPGRADE_INTERFACE_VERSION
4680 },
4681 {
4682 fn initialize(
4683 data: &[u8],
4684 config: alloy_sol_types::abi::AbiDecoderConfig,
4685 ) -> alloy_sol_types::Result<FeeContractCalls> {
4686 <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4687 data,
4688 config,
4689 )
4690 .map(FeeContractCalls::initialize)
4691 }
4692 initialize
4693 },
4694 {
4695 fn transferOwnership(
4696 data: &[u8],
4697 config: alloy_sol_types::abi::AbiDecoderConfig,
4698 ) -> alloy_sol_types::Result<FeeContractCalls> {
4699 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4700 data,
4701 config,
4702 )
4703 .map(FeeContractCalls::transferOwnership)
4704 }
4705 transferOwnership
4706 },
4707 {
4708 fn deposit(
4709 data: &[u8],
4710 config: alloy_sol_types::abi::AbiDecoderConfig,
4711 ) -> alloy_sol_types::Result<FeeContractCalls> {
4712 <depositCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
4713 data,
4714 config,
4715 )
4716 .map(FeeContractCalls::deposit)
4717 }
4718 deposit
4719 },
4720 ];
4721 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4722 return Err(
4723 alloy_sol_types::Error::unknown_selector(
4724 <Self as alloy_sol_types::SolInterface>::NAME,
4725 selector,
4726 ),
4727 );
4728 };
4729 DECODE_SHIMS[idx](data, config)
4730 }
4731 #[inline]
4732 #[allow(non_snake_case)]
4733 fn abi_decode_raw_validate(
4734 selector: [u8; 4],
4735 data: &[u8],
4736 ) -> alloy_sol_types::Result<Self> {
4737 Self::abi_decode_raw_with_config(
4738 selector,
4739 data,
4740 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
4741 )
4742 }
4743 #[inline]
4744 fn abi_encoded_size(&self) -> usize {
4745 match self {
4746 Self::UPGRADE_INTERFACE_VERSION(inner) => {
4747 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
4748 inner,
4749 )
4750 }
4751 Self::balances(inner) => {
4752 <balancesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4753 }
4754 Self::deposit(inner) => {
4755 <depositCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4756 }
4757 Self::getVersion(inner) => {
4758 <getVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4759 }
4760 Self::initialize(inner) => {
4761 <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4762 }
4763 Self::maxDepositAmount(inner) => {
4764 <maxDepositAmountCall as alloy_sol_types::SolCall>::abi_encoded_size(
4765 inner,
4766 )
4767 }
4768 Self::minDepositAmount(inner) => {
4769 <minDepositAmountCall as alloy_sol_types::SolCall>::abi_encoded_size(
4770 inner,
4771 )
4772 }
4773 Self::owner(inner) => {
4774 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4775 }
4776 Self::proxiableUUID(inner) => {
4777 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encoded_size(
4778 inner,
4779 )
4780 }
4781 Self::renounceOwnership(inner) => {
4782 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
4783 inner,
4784 )
4785 }
4786 Self::transferOwnership(inner) => {
4787 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
4788 inner,
4789 )
4790 }
4791 Self::upgradeToAndCall(inner) => {
4792 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(
4793 inner,
4794 )
4795 }
4796 }
4797 }
4798 #[inline]
4799 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4800 match self {
4801 Self::UPGRADE_INTERFACE_VERSION(inner) => {
4802 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
4803 inner,
4804 out,
4805 )
4806 }
4807 Self::balances(inner) => {
4808 <balancesCall as alloy_sol_types::SolCall>::abi_encode_raw(
4809 inner,
4810 out,
4811 )
4812 }
4813 Self::deposit(inner) => {
4814 <depositCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4815 }
4816 Self::getVersion(inner) => {
4817 <getVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
4818 inner,
4819 out,
4820 )
4821 }
4822 Self::initialize(inner) => {
4823 <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
4824 inner,
4825 out,
4826 )
4827 }
4828 Self::maxDepositAmount(inner) => {
4829 <maxDepositAmountCall as alloy_sol_types::SolCall>::abi_encode_raw(
4830 inner,
4831 out,
4832 )
4833 }
4834 Self::minDepositAmount(inner) => {
4835 <minDepositAmountCall as alloy_sol_types::SolCall>::abi_encode_raw(
4836 inner,
4837 out,
4838 )
4839 }
4840 Self::owner(inner) => {
4841 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4842 }
4843 Self::proxiableUUID(inner) => {
4844 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encode_raw(
4845 inner,
4846 out,
4847 )
4848 }
4849 Self::renounceOwnership(inner) => {
4850 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
4851 inner,
4852 out,
4853 )
4854 }
4855 Self::transferOwnership(inner) => {
4856 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
4857 inner,
4858 out,
4859 )
4860 }
4861 Self::upgradeToAndCall(inner) => {
4862 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(
4863 inner,
4864 out,
4865 )
4866 }
4867 }
4868 }
4869 }
4870 #[derive(Clone)]
4872 #[derive(serde::Serialize, serde::Deserialize)]
4873 #[derive(Debug, PartialEq, Eq, Hash)]
4874 pub enum FeeContractErrors {
4875 #[allow(missing_docs)]
4876 AddressEmptyCode(AddressEmptyCode),
4877 #[allow(missing_docs)]
4878 DepositTooLarge(DepositTooLarge),
4879 #[allow(missing_docs)]
4880 DepositTooSmall(DepositTooSmall),
4881 #[allow(missing_docs)]
4882 ERC1967InvalidImplementation(ERC1967InvalidImplementation),
4883 #[allow(missing_docs)]
4884 ERC1967NonPayable(ERC1967NonPayable),
4885 #[allow(missing_docs)]
4886 FailedInnerCall(FailedInnerCall),
4887 #[allow(missing_docs)]
4888 FunctionDoesNotExist(FunctionDoesNotExist),
4889 #[allow(missing_docs)]
4890 InvalidInitialization(InvalidInitialization),
4891 #[allow(missing_docs)]
4892 InvalidUserAddress(InvalidUserAddress),
4893 #[allow(missing_docs)]
4894 NoFunctionCalled(NoFunctionCalled),
4895 #[allow(missing_docs)]
4896 NotInitializing(NotInitializing),
4897 #[allow(missing_docs)]
4898 OwnableInvalidOwner(OwnableInvalidOwner),
4899 #[allow(missing_docs)]
4900 OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
4901 #[allow(missing_docs)]
4902 OwnershipCannotBeRenounced(OwnershipCannotBeRenounced),
4903 #[allow(missing_docs)]
4904 UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext),
4905 #[allow(missing_docs)]
4906 UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID),
4907 }
4908 impl FeeContractErrors {
4909 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4916 [17u8, 140u8, 218u8, 167u8],
4917 [20u8, 37u8, 234u8, 66u8],
4918 [30u8, 79u8, 189u8, 247u8],
4919 [47u8, 171u8, 146u8, 202u8],
4920 [76u8, 156u8, 140u8, 227u8],
4921 [107u8, 164u8, 161u8, 199u8],
4922 [112u8, 43u8, 61u8, 144u8],
4923 [153u8, 150u8, 179u8, 21u8],
4924 [169u8, 173u8, 98u8, 248u8],
4925 [170u8, 29u8, 73u8, 164u8],
4926 [179u8, 152u8, 151u8, 159u8],
4927 [188u8, 142u8, 202u8, 27u8],
4928 [197u8, 109u8, 70u8, 211u8],
4929 [215u8, 230u8, 188u8, 248u8],
4930 [224u8, 124u8, 141u8, 186u8],
4931 [249u8, 46u8, 232u8, 169u8],
4932 ];
4933 pub const VARIANT_NAMES: &'static [&'static str] = &[
4935 ::core::stringify!(OwnableUnauthorizedAccount),
4936 ::core::stringify!(FailedInnerCall),
4937 ::core::stringify!(OwnableInvalidOwner),
4938 ::core::stringify!(OwnershipCannotBeRenounced),
4939 ::core::stringify!(ERC1967InvalidImplementation),
4940 ::core::stringify!(DepositTooSmall),
4941 ::core::stringify!(InvalidUserAddress),
4942 ::core::stringify!(AddressEmptyCode),
4943 ::core::stringify!(FunctionDoesNotExist),
4944 ::core::stringify!(UUPSUnsupportedProxiableUUID),
4945 ::core::stringify!(ERC1967NonPayable),
4946 ::core::stringify!(NoFunctionCalled),
4947 ::core::stringify!(DepositTooLarge),
4948 ::core::stringify!(NotInitializing),
4949 ::core::stringify!(UUPSUnauthorizedCallContext),
4950 ::core::stringify!(InvalidInitialization),
4951 ];
4952 pub const SIGNATURES: &'static [&'static str] = &[
4954 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SIGNATURE,
4955 <FailedInnerCall as alloy_sol_types::SolError>::SIGNATURE,
4956 <OwnableInvalidOwner as alloy_sol_types::SolError>::SIGNATURE,
4957 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::SIGNATURE,
4958 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SIGNATURE,
4959 <DepositTooSmall as alloy_sol_types::SolError>::SIGNATURE,
4960 <InvalidUserAddress as alloy_sol_types::SolError>::SIGNATURE,
4961 <AddressEmptyCode as alloy_sol_types::SolError>::SIGNATURE,
4962 <FunctionDoesNotExist as alloy_sol_types::SolError>::SIGNATURE,
4963 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SIGNATURE,
4964 <ERC1967NonPayable as alloy_sol_types::SolError>::SIGNATURE,
4965 <NoFunctionCalled as alloy_sol_types::SolError>::SIGNATURE,
4966 <DepositTooLarge as alloy_sol_types::SolError>::SIGNATURE,
4967 <NotInitializing as alloy_sol_types::SolError>::SIGNATURE,
4968 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SIGNATURE,
4969 <InvalidInitialization as alloy_sol_types::SolError>::SIGNATURE,
4970 ];
4971 #[inline]
4973 pub fn signature_by_selector(
4974 selector: [u8; 4usize],
4975 ) -> ::core::option::Option<&'static str> {
4976 match Self::SELECTORS.binary_search(&selector) {
4977 ::core::result::Result::Ok(idx) => {
4978 ::core::option::Option::Some(Self::SIGNATURES[idx])
4979 }
4980 ::core::result::Result::Err(_) => ::core::option::Option::None,
4981 }
4982 }
4983 #[inline]
4985 pub fn name_by_selector(
4986 selector: [u8; 4usize],
4987 ) -> ::core::option::Option<&'static str> {
4988 let sig = Self::signature_by_selector(selector)?;
4989 sig.split_once('(').map(|(name, _)| name)
4990 }
4991 }
4992 #[automatically_derived]
4993 impl alloy_sol_types::SolInterface for FeeContractErrors {
4994 const NAME: &'static str = "FeeContractErrors";
4995 const MIN_DATA_LENGTH: usize = 0usize;
4996 const COUNT: usize = 16usize;
4997 #[inline]
4998 fn selector(&self) -> [u8; 4] {
4999 match self {
5000 Self::AddressEmptyCode(_) => {
5001 <AddressEmptyCode as alloy_sol_types::SolError>::SELECTOR
5002 }
5003 Self::DepositTooLarge(_) => {
5004 <DepositTooLarge as alloy_sol_types::SolError>::SELECTOR
5005 }
5006 Self::DepositTooSmall(_) => {
5007 <DepositTooSmall as alloy_sol_types::SolError>::SELECTOR
5008 }
5009 Self::ERC1967InvalidImplementation(_) => {
5010 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SELECTOR
5011 }
5012 Self::ERC1967NonPayable(_) => {
5013 <ERC1967NonPayable as alloy_sol_types::SolError>::SELECTOR
5014 }
5015 Self::FailedInnerCall(_) => {
5016 <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
5017 }
5018 Self::FunctionDoesNotExist(_) => {
5019 <FunctionDoesNotExist as alloy_sol_types::SolError>::SELECTOR
5020 }
5021 Self::InvalidInitialization(_) => {
5022 <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
5023 }
5024 Self::InvalidUserAddress(_) => {
5025 <InvalidUserAddress as alloy_sol_types::SolError>::SELECTOR
5026 }
5027 Self::NoFunctionCalled(_) => {
5028 <NoFunctionCalled as alloy_sol_types::SolError>::SELECTOR
5029 }
5030 Self::NotInitializing(_) => {
5031 <NotInitializing as alloy_sol_types::SolError>::SELECTOR
5032 }
5033 Self::OwnableInvalidOwner(_) => {
5034 <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
5035 }
5036 Self::OwnableUnauthorizedAccount(_) => {
5037 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
5038 }
5039 Self::OwnershipCannotBeRenounced(_) => {
5040 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::SELECTOR
5041 }
5042 Self::UUPSUnauthorizedCallContext(_) => {
5043 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SELECTOR
5044 }
5045 Self::UUPSUnsupportedProxiableUUID(_) => {
5046 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SELECTOR
5047 }
5048 }
5049 }
5050 #[inline]
5051 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5052 Self::SELECTORS.get(i).copied()
5053 }
5054 #[inline]
5055 fn valid_selector(selector: [u8; 4]) -> bool {
5056 Self::SELECTORS.binary_search(&selector).is_ok()
5057 }
5058 #[inline]
5059 #[allow(non_snake_case)]
5060 fn abi_decode_raw(
5061 selector: [u8; 4],
5062 data: &[u8],
5063 ) -> alloy_sol_types::Result<Self> {
5064 Self::abi_decode_raw_with_config(
5065 selector,
5066 data,
5067 alloy_sol_types::abi::AbiDecoderConfig::default(),
5068 )
5069 }
5070 #[inline]
5071 #[allow(non_snake_case)]
5072 fn abi_decode_raw_with_config(
5073 selector: [u8; 4],
5074 data: &[u8],
5075 config: alloy_sol_types::abi::AbiDecoderConfig,
5076 ) -> alloy_sol_types::Result<Self> {
5077 static DECODE_SHIMS: &[fn(
5078 &[u8],
5079 alloy_sol_types::abi::AbiDecoderConfig,
5080 ) -> alloy_sol_types::Result<FeeContractErrors>] = &[
5081 {
5082 fn OwnableUnauthorizedAccount(
5083 data: &[u8],
5084 config: alloy_sol_types::abi::AbiDecoderConfig,
5085 ) -> alloy_sol_types::Result<FeeContractErrors> {
5086 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5087 data,
5088 config,
5089 )
5090 .map(FeeContractErrors::OwnableUnauthorizedAccount)
5091 }
5092 OwnableUnauthorizedAccount
5093 },
5094 {
5095 fn FailedInnerCall(
5096 data: &[u8],
5097 config: alloy_sol_types::abi::AbiDecoderConfig,
5098 ) -> alloy_sol_types::Result<FeeContractErrors> {
5099 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5100 data,
5101 config,
5102 )
5103 .map(FeeContractErrors::FailedInnerCall)
5104 }
5105 FailedInnerCall
5106 },
5107 {
5108 fn OwnableInvalidOwner(
5109 data: &[u8],
5110 config: alloy_sol_types::abi::AbiDecoderConfig,
5111 ) -> alloy_sol_types::Result<FeeContractErrors> {
5112 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5113 data,
5114 config,
5115 )
5116 .map(FeeContractErrors::OwnableInvalidOwner)
5117 }
5118 OwnableInvalidOwner
5119 },
5120 {
5121 fn OwnershipCannotBeRenounced(
5122 data: &[u8],
5123 config: alloy_sol_types::abi::AbiDecoderConfig,
5124 ) -> alloy_sol_types::Result<FeeContractErrors> {
5125 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5126 data,
5127 config,
5128 )
5129 .map(FeeContractErrors::OwnershipCannotBeRenounced)
5130 }
5131 OwnershipCannotBeRenounced
5132 },
5133 {
5134 fn ERC1967InvalidImplementation(
5135 data: &[u8],
5136 config: alloy_sol_types::abi::AbiDecoderConfig,
5137 ) -> alloy_sol_types::Result<FeeContractErrors> {
5138 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5139 data,
5140 config,
5141 )
5142 .map(FeeContractErrors::ERC1967InvalidImplementation)
5143 }
5144 ERC1967InvalidImplementation
5145 },
5146 {
5147 fn DepositTooSmall(
5148 data: &[u8],
5149 config: alloy_sol_types::abi::AbiDecoderConfig,
5150 ) -> alloy_sol_types::Result<FeeContractErrors> {
5151 <DepositTooSmall as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5152 data,
5153 config,
5154 )
5155 .map(FeeContractErrors::DepositTooSmall)
5156 }
5157 DepositTooSmall
5158 },
5159 {
5160 fn InvalidUserAddress(
5161 data: &[u8],
5162 config: alloy_sol_types::abi::AbiDecoderConfig,
5163 ) -> alloy_sol_types::Result<FeeContractErrors> {
5164 <InvalidUserAddress as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5165 data,
5166 config,
5167 )
5168 .map(FeeContractErrors::InvalidUserAddress)
5169 }
5170 InvalidUserAddress
5171 },
5172 {
5173 fn AddressEmptyCode(
5174 data: &[u8],
5175 config: alloy_sol_types::abi::AbiDecoderConfig,
5176 ) -> alloy_sol_types::Result<FeeContractErrors> {
5177 <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5178 data,
5179 config,
5180 )
5181 .map(FeeContractErrors::AddressEmptyCode)
5182 }
5183 AddressEmptyCode
5184 },
5185 {
5186 fn FunctionDoesNotExist(
5187 data: &[u8],
5188 config: alloy_sol_types::abi::AbiDecoderConfig,
5189 ) -> alloy_sol_types::Result<FeeContractErrors> {
5190 <FunctionDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5191 data,
5192 config,
5193 )
5194 .map(FeeContractErrors::FunctionDoesNotExist)
5195 }
5196 FunctionDoesNotExist
5197 },
5198 {
5199 fn UUPSUnsupportedProxiableUUID(
5200 data: &[u8],
5201 config: alloy_sol_types::abi::AbiDecoderConfig,
5202 ) -> alloy_sol_types::Result<FeeContractErrors> {
5203 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5204 data,
5205 config,
5206 )
5207 .map(FeeContractErrors::UUPSUnsupportedProxiableUUID)
5208 }
5209 UUPSUnsupportedProxiableUUID
5210 },
5211 {
5212 fn ERC1967NonPayable(
5213 data: &[u8],
5214 config: alloy_sol_types::abi::AbiDecoderConfig,
5215 ) -> alloy_sol_types::Result<FeeContractErrors> {
5216 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5217 data,
5218 config,
5219 )
5220 .map(FeeContractErrors::ERC1967NonPayable)
5221 }
5222 ERC1967NonPayable
5223 },
5224 {
5225 fn NoFunctionCalled(
5226 data: &[u8],
5227 config: alloy_sol_types::abi::AbiDecoderConfig,
5228 ) -> alloy_sol_types::Result<FeeContractErrors> {
5229 <NoFunctionCalled as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5230 data,
5231 config,
5232 )
5233 .map(FeeContractErrors::NoFunctionCalled)
5234 }
5235 NoFunctionCalled
5236 },
5237 {
5238 fn DepositTooLarge(
5239 data: &[u8],
5240 config: alloy_sol_types::abi::AbiDecoderConfig,
5241 ) -> alloy_sol_types::Result<FeeContractErrors> {
5242 <DepositTooLarge as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5243 data,
5244 config,
5245 )
5246 .map(FeeContractErrors::DepositTooLarge)
5247 }
5248 DepositTooLarge
5249 },
5250 {
5251 fn NotInitializing(
5252 data: &[u8],
5253 config: alloy_sol_types::abi::AbiDecoderConfig,
5254 ) -> alloy_sol_types::Result<FeeContractErrors> {
5255 <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5256 data,
5257 config,
5258 )
5259 .map(FeeContractErrors::NotInitializing)
5260 }
5261 NotInitializing
5262 },
5263 {
5264 fn UUPSUnauthorizedCallContext(
5265 data: &[u8],
5266 config: alloy_sol_types::abi::AbiDecoderConfig,
5267 ) -> alloy_sol_types::Result<FeeContractErrors> {
5268 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5269 data,
5270 config,
5271 )
5272 .map(FeeContractErrors::UUPSUnauthorizedCallContext)
5273 }
5274 UUPSUnauthorizedCallContext
5275 },
5276 {
5277 fn InvalidInitialization(
5278 data: &[u8],
5279 config: alloy_sol_types::abi::AbiDecoderConfig,
5280 ) -> alloy_sol_types::Result<FeeContractErrors> {
5281 <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw_with_config(
5282 data,
5283 config,
5284 )
5285 .map(FeeContractErrors::InvalidInitialization)
5286 }
5287 InvalidInitialization
5288 },
5289 ];
5290 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5291 return Err(
5292 alloy_sol_types::Error::unknown_selector(
5293 <Self as alloy_sol_types::SolInterface>::NAME,
5294 selector,
5295 ),
5296 );
5297 };
5298 DECODE_SHIMS[idx](data, config)
5299 }
5300 #[inline]
5301 #[allow(non_snake_case)]
5302 fn abi_decode_raw_validate(
5303 selector: [u8; 4],
5304 data: &[u8],
5305 ) -> alloy_sol_types::Result<Self> {
5306 Self::abi_decode_raw_with_config(
5307 selector,
5308 data,
5309 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
5310 )
5311 }
5312 #[inline]
5313 fn abi_encoded_size(&self) -> usize {
5314 match self {
5315 Self::AddressEmptyCode(inner) => {
5316 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encoded_size(
5317 inner,
5318 )
5319 }
5320 Self::DepositTooLarge(inner) => {
5321 <DepositTooLarge as alloy_sol_types::SolError>::abi_encoded_size(
5322 inner,
5323 )
5324 }
5325 Self::DepositTooSmall(inner) => {
5326 <DepositTooSmall as alloy_sol_types::SolError>::abi_encoded_size(
5327 inner,
5328 )
5329 }
5330 Self::ERC1967InvalidImplementation(inner) => {
5331 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encoded_size(
5332 inner,
5333 )
5334 }
5335 Self::ERC1967NonPayable(inner) => {
5336 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encoded_size(
5337 inner,
5338 )
5339 }
5340 Self::FailedInnerCall(inner) => {
5341 <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(
5342 inner,
5343 )
5344 }
5345 Self::FunctionDoesNotExist(inner) => {
5346 <FunctionDoesNotExist as alloy_sol_types::SolError>::abi_encoded_size(
5347 inner,
5348 )
5349 }
5350 Self::InvalidInitialization(inner) => {
5351 <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(
5352 inner,
5353 )
5354 }
5355 Self::InvalidUserAddress(inner) => {
5356 <InvalidUserAddress as alloy_sol_types::SolError>::abi_encoded_size(
5357 inner,
5358 )
5359 }
5360 Self::NoFunctionCalled(inner) => {
5361 <NoFunctionCalled as alloy_sol_types::SolError>::abi_encoded_size(
5362 inner,
5363 )
5364 }
5365 Self::NotInitializing(inner) => {
5366 <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(
5367 inner,
5368 )
5369 }
5370 Self::OwnableInvalidOwner(inner) => {
5371 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
5372 inner,
5373 )
5374 }
5375 Self::OwnableUnauthorizedAccount(inner) => {
5376 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
5377 inner,
5378 )
5379 }
5380 Self::OwnershipCannotBeRenounced(inner) => {
5381 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_encoded_size(
5382 inner,
5383 )
5384 }
5385 Self::UUPSUnauthorizedCallContext(inner) => {
5386 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encoded_size(
5387 inner,
5388 )
5389 }
5390 Self::UUPSUnsupportedProxiableUUID(inner) => {
5391 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encoded_size(
5392 inner,
5393 )
5394 }
5395 }
5396 }
5397 #[inline]
5398 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5399 match self {
5400 Self::AddressEmptyCode(inner) => {
5401 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encode_raw(
5402 inner,
5403 out,
5404 )
5405 }
5406 Self::DepositTooLarge(inner) => {
5407 <DepositTooLarge as alloy_sol_types::SolError>::abi_encode_raw(
5408 inner,
5409 out,
5410 )
5411 }
5412 Self::DepositTooSmall(inner) => {
5413 <DepositTooSmall as alloy_sol_types::SolError>::abi_encode_raw(
5414 inner,
5415 out,
5416 )
5417 }
5418 Self::ERC1967InvalidImplementation(inner) => {
5419 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encode_raw(
5420 inner,
5421 out,
5422 )
5423 }
5424 Self::ERC1967NonPayable(inner) => {
5425 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encode_raw(
5426 inner,
5427 out,
5428 )
5429 }
5430 Self::FailedInnerCall(inner) => {
5431 <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(
5432 inner,
5433 out,
5434 )
5435 }
5436 Self::FunctionDoesNotExist(inner) => {
5437 <FunctionDoesNotExist as alloy_sol_types::SolError>::abi_encode_raw(
5438 inner,
5439 out,
5440 )
5441 }
5442 Self::InvalidInitialization(inner) => {
5443 <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(
5444 inner,
5445 out,
5446 )
5447 }
5448 Self::InvalidUserAddress(inner) => {
5449 <InvalidUserAddress as alloy_sol_types::SolError>::abi_encode_raw(
5450 inner,
5451 out,
5452 )
5453 }
5454 Self::NoFunctionCalled(inner) => {
5455 <NoFunctionCalled as alloy_sol_types::SolError>::abi_encode_raw(
5456 inner,
5457 out,
5458 )
5459 }
5460 Self::NotInitializing(inner) => {
5461 <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(
5462 inner,
5463 out,
5464 )
5465 }
5466 Self::OwnableInvalidOwner(inner) => {
5467 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
5468 inner,
5469 out,
5470 )
5471 }
5472 Self::OwnableUnauthorizedAccount(inner) => {
5473 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
5474 inner,
5475 out,
5476 )
5477 }
5478 Self::OwnershipCannotBeRenounced(inner) => {
5479 <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_encode_raw(
5480 inner,
5481 out,
5482 )
5483 }
5484 Self::UUPSUnauthorizedCallContext(inner) => {
5485 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encode_raw(
5486 inner,
5487 out,
5488 )
5489 }
5490 Self::UUPSUnsupportedProxiableUUID(inner) => {
5491 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encode_raw(
5492 inner,
5493 out,
5494 )
5495 }
5496 }
5497 }
5498 }
5499 #[automatically_derived]
5500 impl FeeContractErrors {
5501 #[inline]
5507 pub fn address_empty_code(target: alloy::sol_types::private::Address) -> Self {
5508 Self::AddressEmptyCode(AddressEmptyCode { target: target })
5509 }
5510 #[inline]
5516 pub fn deposit_too_large() -> Self {
5517 Self::DepositTooLarge(DepositTooLarge)
5518 }
5519 #[inline]
5525 pub fn deposit_too_small() -> Self {
5526 Self::DepositTooSmall(DepositTooSmall)
5527 }
5528 #[inline]
5534 pub fn erc_1967_invalid_implementation(
5535 implementation: alloy::sol_types::private::Address,
5536 ) -> Self {
5537 Self::ERC1967InvalidImplementation(ERC1967InvalidImplementation {
5538 implementation: implementation,
5539 })
5540 }
5541 #[inline]
5547 pub fn erc_1967_non_payable() -> Self {
5548 Self::ERC1967NonPayable(ERC1967NonPayable)
5549 }
5550 #[inline]
5556 pub fn failed_inner_call() -> Self {
5557 Self::FailedInnerCall(FailedInnerCall)
5558 }
5559 #[inline]
5565 pub fn function_does_not_exist() -> Self {
5566 Self::FunctionDoesNotExist(FunctionDoesNotExist)
5567 }
5568 #[inline]
5574 pub fn invalid_initialization() -> Self {
5575 Self::InvalidInitialization(InvalidInitialization)
5576 }
5577 #[inline]
5583 pub fn invalid_user_address() -> Self {
5584 Self::InvalidUserAddress(InvalidUserAddress)
5585 }
5586 #[inline]
5592 pub fn no_function_called() -> Self {
5593 Self::NoFunctionCalled(NoFunctionCalled)
5594 }
5595 #[inline]
5601 pub fn not_initializing() -> Self {
5602 Self::NotInitializing(NotInitializing)
5603 }
5604 #[inline]
5610 pub fn ownable_invalid_owner(owner: alloy::sol_types::private::Address) -> Self {
5611 Self::OwnableInvalidOwner(OwnableInvalidOwner {
5612 owner: owner,
5613 })
5614 }
5615 #[inline]
5621 pub fn ownable_unauthorized_account(
5622 account: alloy::sol_types::private::Address,
5623 ) -> Self {
5624 Self::OwnableUnauthorizedAccount(OwnableUnauthorizedAccount {
5625 account: account,
5626 })
5627 }
5628 #[inline]
5634 pub fn ownership_cannot_be_renounced() -> Self {
5635 Self::OwnershipCannotBeRenounced(OwnershipCannotBeRenounced)
5636 }
5637 #[inline]
5643 pub fn uups_unauthorized_call_context() -> Self {
5644 Self::UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext)
5645 }
5646 #[inline]
5652 pub fn uups_unsupported_proxiable_uuid(
5653 slot: alloy::sol_types::private::FixedBytes<32>,
5654 ) -> Self {
5655 Self::UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID {
5656 slot: slot,
5657 })
5658 }
5659 }
5660 #[derive(Clone)]
5662 #[derive(serde::Serialize, serde::Deserialize)]
5663 #[derive(Debug, PartialEq, Eq, Hash)]
5664 pub enum FeeContractEvents {
5665 #[allow(missing_docs)]
5666 Deposit(Deposit),
5667 #[allow(missing_docs)]
5668 Initialized(Initialized),
5669 #[allow(missing_docs)]
5670 Log(Log),
5671 #[allow(missing_docs)]
5672 OwnershipTransferred(OwnershipTransferred),
5673 #[allow(missing_docs)]
5674 Upgrade(Upgrade),
5675 #[allow(missing_docs)]
5676 Upgraded(Upgraded),
5677 }
5678 impl FeeContractEvents {
5679 pub const SELECTORS: &'static [[u8; 32usize]] = &[
5686 [
5687 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
5688 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
5689 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
5690 ],
5691 [
5692 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
5693 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8,
5694 12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
5695 ],
5696 [
5697 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
5698 19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
5699 33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
5700 ],
5701 [
5702 221u8, 151u8, 13u8, 217u8, 181u8, 191u8, 231u8, 7u8, 146u8, 33u8, 85u8,
5703 176u8, 88u8, 164u8, 7u8, 101u8, 92u8, 177u8, 130u8, 136u8, 184u8, 7u8,
5704 226u8, 33u8, 100u8, 66u8, 188u8, 168u8, 173u8, 131u8, 214u8, 181u8,
5705 ],
5706 [
5707 225u8, 255u8, 252u8, 196u8, 146u8, 61u8, 4u8, 181u8, 89u8, 244u8, 210u8,
5708 154u8, 139u8, 252u8, 108u8, 218u8, 4u8, 235u8, 91u8, 13u8, 60u8, 70u8,
5709 7u8, 81u8, 194u8, 64u8, 44u8, 92u8, 92u8, 201u8, 16u8, 156u8,
5710 ],
5711 [
5712 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8,
5713 154u8, 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8,
5714 185u8, 62u8, 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
5715 ],
5716 ];
5717 pub const VARIANT_NAMES: &'static [&'static str] = &[
5719 ::core::stringify!(OwnershipTransferred),
5720 ::core::stringify!(Upgraded),
5721 ::core::stringify!(Initialized),
5722 ::core::stringify!(Log),
5723 ::core::stringify!(Deposit),
5724 ::core::stringify!(Upgrade),
5725 ];
5726 pub const SIGNATURES: &'static [&'static str] = &[
5728 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
5729 <Upgraded as alloy_sol_types::SolEvent>::SIGNATURE,
5730 <Initialized as alloy_sol_types::SolEvent>::SIGNATURE,
5731 <Log as alloy_sol_types::SolEvent>::SIGNATURE,
5732 <Deposit as alloy_sol_types::SolEvent>::SIGNATURE,
5733 <Upgrade as alloy_sol_types::SolEvent>::SIGNATURE,
5734 ];
5735 #[inline]
5737 pub fn signature_by_selector(
5738 selector: [u8; 32usize],
5739 ) -> ::core::option::Option<&'static str> {
5740 match Self::SELECTORS.binary_search(&selector) {
5741 ::core::result::Result::Ok(idx) => {
5742 ::core::option::Option::Some(Self::SIGNATURES[idx])
5743 }
5744 ::core::result::Result::Err(_) => ::core::option::Option::None,
5745 }
5746 }
5747 #[inline]
5749 pub fn name_by_selector(
5750 selector: [u8; 32usize],
5751 ) -> ::core::option::Option<&'static str> {
5752 let sig = Self::signature_by_selector(selector)?;
5753 sig.split_once('(').map(|(name, _)| name)
5754 }
5755 }
5756 #[automatically_derived]
5757 impl alloy_sol_types::SolEventInterface for FeeContractEvents {
5758 const NAME: &'static str = "FeeContractEvents";
5759 const COUNT: usize = 6usize;
5760 fn decode_raw_log(
5761 topics: &[alloy_sol_types::Word],
5762 data: &[u8],
5763 ) -> alloy_sol_types::Result<Self> {
5764 <Self as alloy_sol_types::SolEventInterface>::decode_raw_log_with_config(
5765 topics,
5766 data,
5767 alloy_sol_types::abi::AbiDecoderConfig::default(),
5768 )
5769 }
5770 fn decode_raw_log_with_config(
5771 topics: &[alloy_sol_types::Word],
5772 data: &[u8],
5773 config: alloy_sol_types::abi::AbiDecoderConfig,
5774 ) -> alloy_sol_types::Result<Self> {
5775 match topics.first().copied() {
5776 Some(<Deposit as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5777 <Deposit as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
5778 topics,
5779 data,
5780 config,
5781 )
5782 .map(Self::Deposit)
5783 }
5784 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5785 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
5786 topics,
5787 data,
5788 config,
5789 )
5790 .map(Self::Initialized)
5791 }
5792 Some(<Log as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5793 <Log as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
5794 topics,
5795 data,
5796 config,
5797 )
5798 .map(Self::Log)
5799 }
5800 Some(
5801 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5802 ) => {
5803 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
5804 topics,
5805 data,
5806 config,
5807 )
5808 .map(Self::OwnershipTransferred)
5809 }
5810 Some(<Upgrade as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5811 <Upgrade as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
5812 topics,
5813 data,
5814 config,
5815 )
5816 .map(Self::Upgrade)
5817 }
5818 Some(<Upgraded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5819 <Upgraded as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
5820 topics,
5821 data,
5822 config,
5823 )
5824 .map(Self::Upgraded)
5825 }
5826 _ => {
5827 if topics
5828 .len()
5829 .checked_mul(alloy_sol_types::Word::len_bytes())
5830 .and_then(|len| len.checked_add(data.len()))
5831 .is_none_or(|len| len > config.get_memory_limit())
5832 {
5833 return alloy_sol_types::private::Err(
5834 alloy_sol_types::Error::MemoryLimitExceeded(
5835 config.get_memory_limit(),
5836 ),
5837 );
5838 }
5839 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
5840 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
5841 log: alloy_sol_types::private::Box::new(
5842 alloy_sol_types::private::LogData::new_unchecked(
5843 topics.to_vec(),
5844 data.to_vec().into(),
5845 ),
5846 ),
5847 })
5848 }
5849 }
5850 }
5851 }
5852 #[automatically_derived]
5853 impl alloy_sol_types::private::IntoLogData for FeeContractEvents {
5854 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5855 match self {
5856 Self::Deposit(inner) => {
5857 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5858 }
5859 Self::Initialized(inner) => {
5860 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5861 }
5862 Self::Log(inner) => {
5863 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5864 }
5865 Self::OwnershipTransferred(inner) => {
5866 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5867 }
5868 Self::Upgrade(inner) => {
5869 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5870 }
5871 Self::Upgraded(inner) => {
5872 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5873 }
5874 }
5875 }
5876 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5877 match self {
5878 Self::Deposit(inner) => {
5879 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5880 }
5881 Self::Initialized(inner) => {
5882 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5883 }
5884 Self::Log(inner) => {
5885 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5886 }
5887 Self::OwnershipTransferred(inner) => {
5888 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5889 }
5890 Self::Upgrade(inner) => {
5891 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5892 }
5893 Self::Upgraded(inner) => {
5894 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5895 }
5896 }
5897 }
5898 }
5899 #[automatically_derived]
5900 impl FeeContractEvents {
5901 #[inline]
5907 pub fn deposit(
5908 user: alloy::sol_types::private::Address,
5909 amount: alloy::sol_types::private::primitives::aliases::U256,
5910 ) -> Self {
5911 Self::Deposit(Deposit {
5912 user: user,
5913 amount: amount,
5914 })
5915 }
5916 #[inline]
5922 pub fn initialized(version: u64) -> Self {
5923 Self::Initialized(Initialized { version: version })
5924 }
5925 #[inline]
5931 pub fn log(
5932 func: alloy::sol_types::private::String,
5933 gas: alloy::sol_types::private::primitives::aliases::U256,
5934 ) -> Self {
5935 Self::Log(Log { func: func, gas: gas })
5936 }
5937 #[inline]
5943 pub fn ownership_transferred(
5944 previous_owner: alloy::sol_types::private::Address,
5945 new_owner: alloy::sol_types::private::Address,
5946 ) -> Self {
5947 Self::OwnershipTransferred(OwnershipTransferred {
5948 previousOwner: previous_owner,
5949 newOwner: new_owner,
5950 })
5951 }
5952 #[inline]
5958 pub fn upgrade(implementation: alloy::sol_types::private::Address) -> Self {
5959 Self::Upgrade(Upgrade {
5960 implementation: implementation,
5961 })
5962 }
5963 #[inline]
5969 pub fn upgraded(implementation: alloy::sol_types::private::Address) -> Self {
5970 Self::Upgraded(Upgraded {
5971 implementation: implementation,
5972 })
5973 }
5974 }
5975 use alloy::contract as alloy_contract;
5976 #[inline]
5980 pub const fn new<
5981 P: alloy_contract::private::Provider<N>,
5982 N: alloy_contract::private::Network,
5983 >(
5984 address: alloy_sol_types::private::Address,
5985 __provider: P,
5986 ) -> FeeContractInstance<P, N> {
5987 FeeContractInstance::<P, N>::new(address, __provider)
5988 }
5989 #[inline]
5995 pub fn deploy<
5996 P: alloy_contract::private::Provider<N>,
5997 N: alloy_contract::private::Network,
5998 >(
5999 __provider: P,
6000 ) -> impl ::core::future::Future<
6001 Output = alloy_contract::Result<FeeContractInstance<P, N>>,
6002 > {
6003 FeeContractInstance::<P, N>::deploy(__provider)
6004 }
6005 #[inline]
6011 pub fn deploy_builder<
6012 P: alloy_contract::private::Provider<N>,
6013 N: alloy_contract::private::Network,
6014 >(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
6015 FeeContractInstance::<P, N>::deploy_builder(__provider)
6016 }
6017 #[derive(Clone)]
6029 pub struct FeeContractInstance<P, N = alloy_contract::private::Ethereum> {
6030 address: alloy_sol_types::private::Address,
6031 provider: P,
6032 _network: ::core::marker::PhantomData<N>,
6033 }
6034 #[automatically_derived]
6035 impl<P, N> ::core::fmt::Debug for FeeContractInstance<P, N> {
6036 #[inline]
6037 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6038 f.debug_tuple("FeeContractInstance").field(&self.address).finish()
6039 }
6040 }
6041 impl<
6043 P: alloy_contract::private::Provider<N>,
6044 N: alloy_contract::private::Network,
6045 > FeeContractInstance<P, N> {
6046 #[inline]
6050 pub const fn new(
6051 address: alloy_sol_types::private::Address,
6052 __provider: P,
6053 ) -> Self {
6054 Self {
6055 address,
6056 provider: __provider,
6057 _network: ::core::marker::PhantomData,
6058 }
6059 }
6060 #[inline]
6066 pub async fn deploy(
6067 __provider: P,
6068 ) -> alloy_contract::Result<FeeContractInstance<P, N>> {
6069 let call_builder = Self::deploy_builder(__provider);
6070 let contract_address = call_builder.deploy().await?;
6071 Ok(Self::new(contract_address, call_builder.provider))
6072 }
6073 #[inline]
6079 pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
6080 alloy_contract::RawCallBuilder::new_raw_deploy(
6081 __provider,
6082 ::core::clone::Clone::clone(&BYTECODE),
6083 )
6084 }
6085 #[inline]
6087 pub const fn address(&self) -> &alloy_sol_types::private::Address {
6088 &self.address
6089 }
6090 #[inline]
6092 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
6093 self.address = address;
6094 }
6095 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
6097 self.set_address(address);
6098 self
6099 }
6100 #[inline]
6102 pub const fn provider(&self) -> &P {
6103 &self.provider
6104 }
6105 }
6106 impl<P: ::core::clone::Clone, N> FeeContractInstance<&P, N> {
6107 #[inline]
6109 pub fn with_cloned_provider(self) -> FeeContractInstance<P, N> {
6110 FeeContractInstance {
6111 address: self.address,
6112 provider: ::core::clone::Clone::clone(&self.provider),
6113 _network: ::core::marker::PhantomData,
6114 }
6115 }
6116 }
6117 impl<
6119 P: alloy_contract::private::Provider<N>,
6120 N: alloy_contract::private::Network,
6121 > FeeContractInstance<P, N> {
6122 pub fn call_builder<C: alloy_sol_types::SolCall>(
6127 &self,
6128 call: &C,
6129 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
6130 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
6131 }
6132 pub fn UPGRADE_INTERFACE_VERSION(
6134 &self,
6135 ) -> alloy_contract::SolCallBuilder<&P, UPGRADE_INTERFACE_VERSIONCall, N> {
6136 self.call_builder(&UPGRADE_INTERFACE_VERSIONCall)
6137 }
6138 pub fn balances(
6140 &self,
6141 user: alloy::sol_types::private::Address,
6142 ) -> alloy_contract::SolCallBuilder<&P, balancesCall, N> {
6143 self.call_builder(&balancesCall { user })
6144 }
6145 pub fn deposit(
6147 &self,
6148 user: alloy::sol_types::private::Address,
6149 ) -> alloy_contract::SolCallBuilder<&P, depositCall, N> {
6150 self.call_builder(&depositCall { user })
6151 }
6152 pub fn getVersion(
6154 &self,
6155 ) -> alloy_contract::SolCallBuilder<&P, getVersionCall, N> {
6156 self.call_builder(&getVersionCall)
6157 }
6158 pub fn initialize(
6160 &self,
6161 multisig: alloy::sol_types::private::Address,
6162 ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
6163 self.call_builder(&initializeCall { multisig })
6164 }
6165 pub fn maxDepositAmount(
6167 &self,
6168 ) -> alloy_contract::SolCallBuilder<&P, maxDepositAmountCall, N> {
6169 self.call_builder(&maxDepositAmountCall)
6170 }
6171 pub fn minDepositAmount(
6173 &self,
6174 ) -> alloy_contract::SolCallBuilder<&P, minDepositAmountCall, N> {
6175 self.call_builder(&minDepositAmountCall)
6176 }
6177 pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
6179 self.call_builder(&ownerCall)
6180 }
6181 pub fn proxiableUUID(
6183 &self,
6184 ) -> alloy_contract::SolCallBuilder<&P, proxiableUUIDCall, N> {
6185 self.call_builder(&proxiableUUIDCall)
6186 }
6187 pub fn renounceOwnership(
6189 &self,
6190 ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
6191 self.call_builder(&renounceOwnershipCall)
6192 }
6193 pub fn transferOwnership(
6195 &self,
6196 newOwner: alloy::sol_types::private::Address,
6197 ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
6198 self.call_builder(&transferOwnershipCall { newOwner })
6199 }
6200 pub fn upgradeToAndCall(
6202 &self,
6203 newImplementation: alloy::sol_types::private::Address,
6204 data: alloy::sol_types::private::Bytes,
6205 ) -> alloy_contract::SolCallBuilder<&P, upgradeToAndCallCall, N> {
6206 self.call_builder(
6207 &upgradeToAndCallCall {
6208 newImplementation,
6209 data,
6210 },
6211 )
6212 }
6213 }
6214 impl<
6216 P: alloy_contract::private::Provider<N>,
6217 N: alloy_contract::private::Network,
6218 > FeeContractInstance<P, N> {
6219 pub fn event_filter<E: alloy_sol_types::SolEvent>(
6224 &self,
6225 ) -> alloy_contract::Event<&P, E, N> {
6226 alloy_contract::Event::new_sol(&self.provider, &self.address)
6227 }
6228 pub fn Deposit_filter(&self) -> alloy_contract::Event<&P, Deposit, N> {
6230 self.event_filter::<Deposit>()
6231 }
6232 pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
6234 self.event_filter::<Initialized>()
6235 }
6236 pub fn Log_filter(&self) -> alloy_contract::Event<&P, Log, N> {
6238 self.event_filter::<Log>()
6239 }
6240 pub fn OwnershipTransferred_filter(
6242 &self,
6243 ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
6244 self.event_filter::<OwnershipTransferred>()
6245 }
6246 pub fn Upgrade_filter(&self) -> alloy_contract::Event<&P, Upgrade, N> {
6248 self.event_filter::<Upgrade>()
6249 }
6250 pub fn Upgraded_filter(&self) -> alloy_contract::Event<&P, Upgraded, N> {
6252 self.event_filter::<Upgraded>()
6253 }
6254 }
6255}