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