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(Default, Debug, PartialEq, Eq, Hash)]
471 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
476 #[derive(Clone)]
477 pub struct AddressEmptyCode {
478 #[allow(missing_docs)]
479 pub target: alloy::sol_types::private::Address,
480 }
481 #[allow(
482 non_camel_case_types,
483 non_snake_case,
484 clippy::pub_underscore_fields,
485 clippy::style
486 )]
487 const _: () = {
488 use alloy::sol_types as alloy_sol_types;
489 #[doc(hidden)]
490 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
491 #[doc(hidden)]
492 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
493 #[cfg(test)]
494 #[allow(dead_code, unreachable_patterns)]
495 fn _type_assertion(
496 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
497 ) {
498 match _t {
499 alloy_sol_types::private::AssertTypeEq::<
500 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
501 >(_) => {}
502 }
503 }
504 #[automatically_derived]
505 #[doc(hidden)]
506 impl ::core::convert::From<AddressEmptyCode> for UnderlyingRustTuple<'_> {
507 fn from(value: AddressEmptyCode) -> Self {
508 (value.target,)
509 }
510 }
511 #[automatically_derived]
512 #[doc(hidden)]
513 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressEmptyCode {
514 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
515 Self { target: tuple.0 }
516 }
517 }
518 #[automatically_derived]
519 impl alloy_sol_types::SolError for AddressEmptyCode {
520 type Parameters<'a> = UnderlyingSolTuple<'a>;
521 type Token<'a> = <Self::Parameters<
522 'a,
523 > as alloy_sol_types::SolType>::Token<'a>;
524 const SIGNATURE: &'static str = "AddressEmptyCode(address)";
525 const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8];
526 #[inline]
527 fn new<'a>(
528 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
529 ) -> Self {
530 tuple.into()
531 }
532 #[inline]
533 fn tokenize(&self) -> Self::Token<'_> {
534 (
535 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
536 &self.target,
537 ),
538 )
539 }
540 }
541 };
542 #[derive(Default, Debug, PartialEq, Eq, Hash)]
543 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
548 #[derive(Clone)]
549 pub struct DepositTooLarge {}
550 #[allow(
551 non_camel_case_types,
552 non_snake_case,
553 clippy::pub_underscore_fields,
554 clippy::style
555 )]
556 const _: () = {
557 use alloy::sol_types as alloy_sol_types;
558 #[doc(hidden)]
559 type UnderlyingSolTuple<'a> = ();
560 #[doc(hidden)]
561 type UnderlyingRustTuple<'a> = ();
562 #[cfg(test)]
563 #[allow(dead_code, unreachable_patterns)]
564 fn _type_assertion(
565 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
566 ) {
567 match _t {
568 alloy_sol_types::private::AssertTypeEq::<
569 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
570 >(_) => {}
571 }
572 }
573 #[automatically_derived]
574 #[doc(hidden)]
575 impl ::core::convert::From<DepositTooLarge> for UnderlyingRustTuple<'_> {
576 fn from(value: DepositTooLarge) -> Self {
577 ()
578 }
579 }
580 #[automatically_derived]
581 #[doc(hidden)]
582 impl ::core::convert::From<UnderlyingRustTuple<'_>> for DepositTooLarge {
583 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
584 Self {}
585 }
586 }
587 #[automatically_derived]
588 impl alloy_sol_types::SolError for DepositTooLarge {
589 type Parameters<'a> = UnderlyingSolTuple<'a>;
590 type Token<'a> = <Self::Parameters<
591 'a,
592 > as alloy_sol_types::SolType>::Token<'a>;
593 const SIGNATURE: &'static str = "DepositTooLarge()";
594 const SELECTOR: [u8; 4] = [197u8, 109u8, 70u8, 211u8];
595 #[inline]
596 fn new<'a>(
597 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
598 ) -> Self {
599 tuple.into()
600 }
601 #[inline]
602 fn tokenize(&self) -> Self::Token<'_> {
603 ()
604 }
605 }
606 };
607 #[derive(Default, Debug, PartialEq, Eq, Hash)]
608 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
613 #[derive(Clone)]
614 pub struct DepositTooSmall {}
615 #[allow(
616 non_camel_case_types,
617 non_snake_case,
618 clippy::pub_underscore_fields,
619 clippy::style
620 )]
621 const _: () = {
622 use alloy::sol_types as alloy_sol_types;
623 #[doc(hidden)]
624 type UnderlyingSolTuple<'a> = ();
625 #[doc(hidden)]
626 type UnderlyingRustTuple<'a> = ();
627 #[cfg(test)]
628 #[allow(dead_code, unreachable_patterns)]
629 fn _type_assertion(
630 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
631 ) {
632 match _t {
633 alloy_sol_types::private::AssertTypeEq::<
634 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
635 >(_) => {}
636 }
637 }
638 #[automatically_derived]
639 #[doc(hidden)]
640 impl ::core::convert::From<DepositTooSmall> for UnderlyingRustTuple<'_> {
641 fn from(value: DepositTooSmall) -> Self {
642 ()
643 }
644 }
645 #[automatically_derived]
646 #[doc(hidden)]
647 impl ::core::convert::From<UnderlyingRustTuple<'_>> for DepositTooSmall {
648 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
649 Self {}
650 }
651 }
652 #[automatically_derived]
653 impl alloy_sol_types::SolError for DepositTooSmall {
654 type Parameters<'a> = UnderlyingSolTuple<'a>;
655 type Token<'a> = <Self::Parameters<
656 'a,
657 > as alloy_sol_types::SolType>::Token<'a>;
658 const SIGNATURE: &'static str = "DepositTooSmall()";
659 const SELECTOR: [u8; 4] = [107u8, 164u8, 161u8, 199u8];
660 #[inline]
661 fn new<'a>(
662 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
663 ) -> Self {
664 tuple.into()
665 }
666 #[inline]
667 fn tokenize(&self) -> Self::Token<'_> {
668 ()
669 }
670 }
671 };
672 #[derive(Default, Debug, PartialEq, Eq, Hash)]
673 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
678 #[derive(Clone)]
679 pub struct ERC1967InvalidImplementation {
680 #[allow(missing_docs)]
681 pub implementation: alloy::sol_types::private::Address,
682 }
683 #[allow(
684 non_camel_case_types,
685 non_snake_case,
686 clippy::pub_underscore_fields,
687 clippy::style
688 )]
689 const _: () = {
690 use alloy::sol_types as alloy_sol_types;
691 #[doc(hidden)]
692 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
693 #[doc(hidden)]
694 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
695 #[cfg(test)]
696 #[allow(dead_code, unreachable_patterns)]
697 fn _type_assertion(
698 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
699 ) {
700 match _t {
701 alloy_sol_types::private::AssertTypeEq::<
702 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
703 >(_) => {}
704 }
705 }
706 #[automatically_derived]
707 #[doc(hidden)]
708 impl ::core::convert::From<ERC1967InvalidImplementation>
709 for UnderlyingRustTuple<'_> {
710 fn from(value: ERC1967InvalidImplementation) -> Self {
711 (value.implementation,)
712 }
713 }
714 #[automatically_derived]
715 #[doc(hidden)]
716 impl ::core::convert::From<UnderlyingRustTuple<'_>>
717 for ERC1967InvalidImplementation {
718 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
719 Self { implementation: tuple.0 }
720 }
721 }
722 #[automatically_derived]
723 impl alloy_sol_types::SolError for ERC1967InvalidImplementation {
724 type Parameters<'a> = UnderlyingSolTuple<'a>;
725 type Token<'a> = <Self::Parameters<
726 'a,
727 > as alloy_sol_types::SolType>::Token<'a>;
728 const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)";
729 const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8];
730 #[inline]
731 fn new<'a>(
732 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
733 ) -> Self {
734 tuple.into()
735 }
736 #[inline]
737 fn tokenize(&self) -> Self::Token<'_> {
738 (
739 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
740 &self.implementation,
741 ),
742 )
743 }
744 }
745 };
746 #[derive(Default, Debug, PartialEq, Eq, Hash)]
747 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
752 #[derive(Clone)]
753 pub struct ERC1967NonPayable {}
754 #[allow(
755 non_camel_case_types,
756 non_snake_case,
757 clippy::pub_underscore_fields,
758 clippy::style
759 )]
760 const _: () = {
761 use alloy::sol_types as alloy_sol_types;
762 #[doc(hidden)]
763 type UnderlyingSolTuple<'a> = ();
764 #[doc(hidden)]
765 type UnderlyingRustTuple<'a> = ();
766 #[cfg(test)]
767 #[allow(dead_code, unreachable_patterns)]
768 fn _type_assertion(
769 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
770 ) {
771 match _t {
772 alloy_sol_types::private::AssertTypeEq::<
773 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
774 >(_) => {}
775 }
776 }
777 #[automatically_derived]
778 #[doc(hidden)]
779 impl ::core::convert::From<ERC1967NonPayable> for UnderlyingRustTuple<'_> {
780 fn from(value: ERC1967NonPayable) -> Self {
781 ()
782 }
783 }
784 #[automatically_derived]
785 #[doc(hidden)]
786 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1967NonPayable {
787 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
788 Self {}
789 }
790 }
791 #[automatically_derived]
792 impl alloy_sol_types::SolError for ERC1967NonPayable {
793 type Parameters<'a> = UnderlyingSolTuple<'a>;
794 type Token<'a> = <Self::Parameters<
795 'a,
796 > as alloy_sol_types::SolType>::Token<'a>;
797 const SIGNATURE: &'static str = "ERC1967NonPayable()";
798 const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8];
799 #[inline]
800 fn new<'a>(
801 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
802 ) -> Self {
803 tuple.into()
804 }
805 #[inline]
806 fn tokenize(&self) -> Self::Token<'_> {
807 ()
808 }
809 }
810 };
811 #[derive(Default, Debug, PartialEq, Eq, Hash)]
812 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
817 #[derive(Clone)]
818 pub struct FailedInnerCall {}
819 #[allow(
820 non_camel_case_types,
821 non_snake_case,
822 clippy::pub_underscore_fields,
823 clippy::style
824 )]
825 const _: () = {
826 use alloy::sol_types as alloy_sol_types;
827 #[doc(hidden)]
828 type UnderlyingSolTuple<'a> = ();
829 #[doc(hidden)]
830 type UnderlyingRustTuple<'a> = ();
831 #[cfg(test)]
832 #[allow(dead_code, unreachable_patterns)]
833 fn _type_assertion(
834 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
835 ) {
836 match _t {
837 alloy_sol_types::private::AssertTypeEq::<
838 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
839 >(_) => {}
840 }
841 }
842 #[automatically_derived]
843 #[doc(hidden)]
844 impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
845 fn from(value: FailedInnerCall) -> Self {
846 ()
847 }
848 }
849 #[automatically_derived]
850 #[doc(hidden)]
851 impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
852 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
853 Self {}
854 }
855 }
856 #[automatically_derived]
857 impl alloy_sol_types::SolError for FailedInnerCall {
858 type Parameters<'a> = UnderlyingSolTuple<'a>;
859 type Token<'a> = <Self::Parameters<
860 'a,
861 > as alloy_sol_types::SolType>::Token<'a>;
862 const SIGNATURE: &'static str = "FailedInnerCall()";
863 const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
864 #[inline]
865 fn new<'a>(
866 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
867 ) -> Self {
868 tuple.into()
869 }
870 #[inline]
871 fn tokenize(&self) -> Self::Token<'_> {
872 ()
873 }
874 }
875 };
876 #[derive(Default, Debug, PartialEq, Eq, Hash)]
877 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
882 #[derive(Clone)]
883 pub struct FunctionDoesNotExist {}
884 #[allow(
885 non_camel_case_types,
886 non_snake_case,
887 clippy::pub_underscore_fields,
888 clippy::style
889 )]
890 const _: () = {
891 use alloy::sol_types as alloy_sol_types;
892 #[doc(hidden)]
893 type UnderlyingSolTuple<'a> = ();
894 #[doc(hidden)]
895 type UnderlyingRustTuple<'a> = ();
896 #[cfg(test)]
897 #[allow(dead_code, unreachable_patterns)]
898 fn _type_assertion(
899 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
900 ) {
901 match _t {
902 alloy_sol_types::private::AssertTypeEq::<
903 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
904 >(_) => {}
905 }
906 }
907 #[automatically_derived]
908 #[doc(hidden)]
909 impl ::core::convert::From<FunctionDoesNotExist> for UnderlyingRustTuple<'_> {
910 fn from(value: FunctionDoesNotExist) -> Self {
911 ()
912 }
913 }
914 #[automatically_derived]
915 #[doc(hidden)]
916 impl ::core::convert::From<UnderlyingRustTuple<'_>> for FunctionDoesNotExist {
917 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
918 Self {}
919 }
920 }
921 #[automatically_derived]
922 impl alloy_sol_types::SolError for FunctionDoesNotExist {
923 type Parameters<'a> = UnderlyingSolTuple<'a>;
924 type Token<'a> = <Self::Parameters<
925 'a,
926 > as alloy_sol_types::SolType>::Token<'a>;
927 const SIGNATURE: &'static str = "FunctionDoesNotExist()";
928 const SELECTOR: [u8; 4] = [169u8, 173u8, 98u8, 248u8];
929 #[inline]
930 fn new<'a>(
931 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
932 ) -> Self {
933 tuple.into()
934 }
935 #[inline]
936 fn tokenize(&self) -> Self::Token<'_> {
937 ()
938 }
939 }
940 };
941 #[derive(Default, Debug, PartialEq, Eq, Hash)]
942 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
947 #[derive(Clone)]
948 pub struct InvalidInitialization {}
949 #[allow(
950 non_camel_case_types,
951 non_snake_case,
952 clippy::pub_underscore_fields,
953 clippy::style
954 )]
955 const _: () = {
956 use alloy::sol_types as alloy_sol_types;
957 #[doc(hidden)]
958 type UnderlyingSolTuple<'a> = ();
959 #[doc(hidden)]
960 type UnderlyingRustTuple<'a> = ();
961 #[cfg(test)]
962 #[allow(dead_code, unreachable_patterns)]
963 fn _type_assertion(
964 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
965 ) {
966 match _t {
967 alloy_sol_types::private::AssertTypeEq::<
968 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
969 >(_) => {}
970 }
971 }
972 #[automatically_derived]
973 #[doc(hidden)]
974 impl ::core::convert::From<InvalidInitialization> for UnderlyingRustTuple<'_> {
975 fn from(value: InvalidInitialization) -> Self {
976 ()
977 }
978 }
979 #[automatically_derived]
980 #[doc(hidden)]
981 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInitialization {
982 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
983 Self {}
984 }
985 }
986 #[automatically_derived]
987 impl alloy_sol_types::SolError for InvalidInitialization {
988 type Parameters<'a> = UnderlyingSolTuple<'a>;
989 type Token<'a> = <Self::Parameters<
990 'a,
991 > as alloy_sol_types::SolType>::Token<'a>;
992 const SIGNATURE: &'static str = "InvalidInitialization()";
993 const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8];
994 #[inline]
995 fn new<'a>(
996 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
997 ) -> Self {
998 tuple.into()
999 }
1000 #[inline]
1001 fn tokenize(&self) -> Self::Token<'_> {
1002 ()
1003 }
1004 }
1005 };
1006 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1007 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1012 #[derive(Clone)]
1013 pub struct InvalidUserAddress {}
1014 #[allow(
1015 non_camel_case_types,
1016 non_snake_case,
1017 clippy::pub_underscore_fields,
1018 clippy::style
1019 )]
1020 const _: () = {
1021 use alloy::sol_types as alloy_sol_types;
1022 #[doc(hidden)]
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<InvalidUserAddress> for UnderlyingRustTuple<'_> {
1040 fn from(value: InvalidUserAddress) -> Self {
1041 ()
1042 }
1043 }
1044 #[automatically_derived]
1045 #[doc(hidden)]
1046 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidUserAddress {
1047 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1048 Self {}
1049 }
1050 }
1051 #[automatically_derived]
1052 impl alloy_sol_types::SolError for InvalidUserAddress {
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 = "InvalidUserAddress()";
1058 const SELECTOR: [u8; 4] = [112u8, 43u8, 61u8, 144u8];
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 }
1070 };
1071 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1072 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1077 #[derive(Clone)]
1078 pub struct NoFunctionCalled {}
1079 #[allow(
1080 non_camel_case_types,
1081 non_snake_case,
1082 clippy::pub_underscore_fields,
1083 clippy::style
1084 )]
1085 const _: () = {
1086 use alloy::sol_types as alloy_sol_types;
1087 #[doc(hidden)]
1088 type UnderlyingSolTuple<'a> = ();
1089 #[doc(hidden)]
1090 type UnderlyingRustTuple<'a> = ();
1091 #[cfg(test)]
1092 #[allow(dead_code, unreachable_patterns)]
1093 fn _type_assertion(
1094 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1095 ) {
1096 match _t {
1097 alloy_sol_types::private::AssertTypeEq::<
1098 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1099 >(_) => {}
1100 }
1101 }
1102 #[automatically_derived]
1103 #[doc(hidden)]
1104 impl ::core::convert::From<NoFunctionCalled> for UnderlyingRustTuple<'_> {
1105 fn from(value: NoFunctionCalled) -> Self {
1106 ()
1107 }
1108 }
1109 #[automatically_derived]
1110 #[doc(hidden)]
1111 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NoFunctionCalled {
1112 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1113 Self {}
1114 }
1115 }
1116 #[automatically_derived]
1117 impl alloy_sol_types::SolError for NoFunctionCalled {
1118 type Parameters<'a> = UnderlyingSolTuple<'a>;
1119 type Token<'a> = <Self::Parameters<
1120 'a,
1121 > as alloy_sol_types::SolType>::Token<'a>;
1122 const SIGNATURE: &'static str = "NoFunctionCalled()";
1123 const SELECTOR: [u8; 4] = [188u8, 142u8, 202u8, 27u8];
1124 #[inline]
1125 fn new<'a>(
1126 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1127 ) -> Self {
1128 tuple.into()
1129 }
1130 #[inline]
1131 fn tokenize(&self) -> Self::Token<'_> {
1132 ()
1133 }
1134 }
1135 };
1136 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1137 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1142 #[derive(Clone)]
1143 pub struct NotInitializing {}
1144 #[allow(
1145 non_camel_case_types,
1146 non_snake_case,
1147 clippy::pub_underscore_fields,
1148 clippy::style
1149 )]
1150 const _: () = {
1151 use alloy::sol_types as alloy_sol_types;
1152 #[doc(hidden)]
1153 type UnderlyingSolTuple<'a> = ();
1154 #[doc(hidden)]
1155 type UnderlyingRustTuple<'a> = ();
1156 #[cfg(test)]
1157 #[allow(dead_code, unreachable_patterns)]
1158 fn _type_assertion(
1159 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1160 ) {
1161 match _t {
1162 alloy_sol_types::private::AssertTypeEq::<
1163 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1164 >(_) => {}
1165 }
1166 }
1167 #[automatically_derived]
1168 #[doc(hidden)]
1169 impl ::core::convert::From<NotInitializing> for UnderlyingRustTuple<'_> {
1170 fn from(value: NotInitializing) -> Self {
1171 ()
1172 }
1173 }
1174 #[automatically_derived]
1175 #[doc(hidden)]
1176 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotInitializing {
1177 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1178 Self {}
1179 }
1180 }
1181 #[automatically_derived]
1182 impl alloy_sol_types::SolError for NotInitializing {
1183 type Parameters<'a> = UnderlyingSolTuple<'a>;
1184 type Token<'a> = <Self::Parameters<
1185 'a,
1186 > as alloy_sol_types::SolType>::Token<'a>;
1187 const SIGNATURE: &'static str = "NotInitializing()";
1188 const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8];
1189 #[inline]
1190 fn new<'a>(
1191 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1192 ) -> Self {
1193 tuple.into()
1194 }
1195 #[inline]
1196 fn tokenize(&self) -> Self::Token<'_> {
1197 ()
1198 }
1199 }
1200 };
1201 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1202 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1207 #[derive(Clone)]
1208 pub struct OwnableInvalidOwner {
1209 #[allow(missing_docs)]
1210 pub owner: alloy::sol_types::private::Address,
1211 }
1212 #[allow(
1213 non_camel_case_types,
1214 non_snake_case,
1215 clippy::pub_underscore_fields,
1216 clippy::style
1217 )]
1218 const _: () = {
1219 use alloy::sol_types as alloy_sol_types;
1220 #[doc(hidden)]
1221 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1222 #[doc(hidden)]
1223 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1224 #[cfg(test)]
1225 #[allow(dead_code, unreachable_patterns)]
1226 fn _type_assertion(
1227 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1228 ) {
1229 match _t {
1230 alloy_sol_types::private::AssertTypeEq::<
1231 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1232 >(_) => {}
1233 }
1234 }
1235 #[automatically_derived]
1236 #[doc(hidden)]
1237 impl ::core::convert::From<OwnableInvalidOwner> for UnderlyingRustTuple<'_> {
1238 fn from(value: OwnableInvalidOwner) -> Self {
1239 (value.owner,)
1240 }
1241 }
1242 #[automatically_derived]
1243 #[doc(hidden)]
1244 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableInvalidOwner {
1245 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1246 Self { owner: tuple.0 }
1247 }
1248 }
1249 #[automatically_derived]
1250 impl alloy_sol_types::SolError for OwnableInvalidOwner {
1251 type Parameters<'a> = UnderlyingSolTuple<'a>;
1252 type Token<'a> = <Self::Parameters<
1253 'a,
1254 > as alloy_sol_types::SolType>::Token<'a>;
1255 const SIGNATURE: &'static str = "OwnableInvalidOwner(address)";
1256 const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8];
1257 #[inline]
1258 fn new<'a>(
1259 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1260 ) -> Self {
1261 tuple.into()
1262 }
1263 #[inline]
1264 fn tokenize(&self) -> Self::Token<'_> {
1265 (
1266 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1267 &self.owner,
1268 ),
1269 )
1270 }
1271 }
1272 };
1273 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1274 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1279 #[derive(Clone)]
1280 pub struct OwnableUnauthorizedAccount {
1281 #[allow(missing_docs)]
1282 pub account: alloy::sol_types::private::Address,
1283 }
1284 #[allow(
1285 non_camel_case_types,
1286 non_snake_case,
1287 clippy::pub_underscore_fields,
1288 clippy::style
1289 )]
1290 const _: () = {
1291 use alloy::sol_types as alloy_sol_types;
1292 #[doc(hidden)]
1293 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1294 #[doc(hidden)]
1295 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1296 #[cfg(test)]
1297 #[allow(dead_code, unreachable_patterns)]
1298 fn _type_assertion(
1299 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1300 ) {
1301 match _t {
1302 alloy_sol_types::private::AssertTypeEq::<
1303 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1304 >(_) => {}
1305 }
1306 }
1307 #[automatically_derived]
1308 #[doc(hidden)]
1309 impl ::core::convert::From<OwnableUnauthorizedAccount>
1310 for UnderlyingRustTuple<'_> {
1311 fn from(value: OwnableUnauthorizedAccount) -> Self {
1312 (value.account,)
1313 }
1314 }
1315 #[automatically_derived]
1316 #[doc(hidden)]
1317 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1318 for OwnableUnauthorizedAccount {
1319 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1320 Self { account: tuple.0 }
1321 }
1322 }
1323 #[automatically_derived]
1324 impl alloy_sol_types::SolError for OwnableUnauthorizedAccount {
1325 type Parameters<'a> = UnderlyingSolTuple<'a>;
1326 type Token<'a> = <Self::Parameters<
1327 'a,
1328 > as alloy_sol_types::SolType>::Token<'a>;
1329 const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)";
1330 const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8];
1331 #[inline]
1332 fn new<'a>(
1333 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1334 ) -> Self {
1335 tuple.into()
1336 }
1337 #[inline]
1338 fn tokenize(&self) -> Self::Token<'_> {
1339 (
1340 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1341 &self.account,
1342 ),
1343 )
1344 }
1345 }
1346 };
1347 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1348 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1353 #[derive(Clone)]
1354 pub struct UUPSUnauthorizedCallContext {}
1355 #[allow(
1356 non_camel_case_types,
1357 non_snake_case,
1358 clippy::pub_underscore_fields,
1359 clippy::style
1360 )]
1361 const _: () = {
1362 use alloy::sol_types as alloy_sol_types;
1363 #[doc(hidden)]
1364 type UnderlyingSolTuple<'a> = ();
1365 #[doc(hidden)]
1366 type UnderlyingRustTuple<'a> = ();
1367 #[cfg(test)]
1368 #[allow(dead_code, unreachable_patterns)]
1369 fn _type_assertion(
1370 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1371 ) {
1372 match _t {
1373 alloy_sol_types::private::AssertTypeEq::<
1374 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1375 >(_) => {}
1376 }
1377 }
1378 #[automatically_derived]
1379 #[doc(hidden)]
1380 impl ::core::convert::From<UUPSUnauthorizedCallContext>
1381 for UnderlyingRustTuple<'_> {
1382 fn from(value: UUPSUnauthorizedCallContext) -> Self {
1383 ()
1384 }
1385 }
1386 #[automatically_derived]
1387 #[doc(hidden)]
1388 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1389 for UUPSUnauthorizedCallContext {
1390 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1391 Self {}
1392 }
1393 }
1394 #[automatically_derived]
1395 impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext {
1396 type Parameters<'a> = UnderlyingSolTuple<'a>;
1397 type Token<'a> = <Self::Parameters<
1398 'a,
1399 > as alloy_sol_types::SolType>::Token<'a>;
1400 const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()";
1401 const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8];
1402 #[inline]
1403 fn new<'a>(
1404 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1405 ) -> Self {
1406 tuple.into()
1407 }
1408 #[inline]
1409 fn tokenize(&self) -> Self::Token<'_> {
1410 ()
1411 }
1412 }
1413 };
1414 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1415 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1420 #[derive(Clone)]
1421 pub struct UUPSUnsupportedProxiableUUID {
1422 #[allow(missing_docs)]
1423 pub slot: alloy::sol_types::private::FixedBytes<32>,
1424 }
1425 #[allow(
1426 non_camel_case_types,
1427 non_snake_case,
1428 clippy::pub_underscore_fields,
1429 clippy::style
1430 )]
1431 const _: () = {
1432 use alloy::sol_types as alloy_sol_types;
1433 #[doc(hidden)]
1434 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1435 #[doc(hidden)]
1436 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1437 #[cfg(test)]
1438 #[allow(dead_code, unreachable_patterns)]
1439 fn _type_assertion(
1440 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1441 ) {
1442 match _t {
1443 alloy_sol_types::private::AssertTypeEq::<
1444 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1445 >(_) => {}
1446 }
1447 }
1448 #[automatically_derived]
1449 #[doc(hidden)]
1450 impl ::core::convert::From<UUPSUnsupportedProxiableUUID>
1451 for UnderlyingRustTuple<'_> {
1452 fn from(value: UUPSUnsupportedProxiableUUID) -> Self {
1453 (value.slot,)
1454 }
1455 }
1456 #[automatically_derived]
1457 #[doc(hidden)]
1458 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1459 for UUPSUnsupportedProxiableUUID {
1460 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1461 Self { slot: tuple.0 }
1462 }
1463 }
1464 #[automatically_derived]
1465 impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID {
1466 type Parameters<'a> = UnderlyingSolTuple<'a>;
1467 type Token<'a> = <Self::Parameters<
1468 'a,
1469 > as alloy_sol_types::SolType>::Token<'a>;
1470 const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)";
1471 const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8];
1472 #[inline]
1473 fn new<'a>(
1474 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1475 ) -> Self {
1476 tuple.into()
1477 }
1478 #[inline]
1479 fn tokenize(&self) -> Self::Token<'_> {
1480 (
1481 <alloy::sol_types::sol_data::FixedBytes<
1482 32,
1483 > as alloy_sol_types::SolType>::tokenize(&self.slot),
1484 )
1485 }
1486 }
1487 };
1488 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1489 #[allow(
1494 non_camel_case_types,
1495 non_snake_case,
1496 clippy::pub_underscore_fields,
1497 clippy::style
1498 )]
1499 #[derive(Clone)]
1500 pub struct Deposit {
1501 #[allow(missing_docs)]
1502 pub user: alloy::sol_types::private::Address,
1503 #[allow(missing_docs)]
1504 pub amount: alloy::sol_types::private::primitives::aliases::U256,
1505 }
1506 #[allow(
1507 non_camel_case_types,
1508 non_snake_case,
1509 clippy::pub_underscore_fields,
1510 clippy::style
1511 )]
1512 const _: () = {
1513 use alloy::sol_types as alloy_sol_types;
1514 #[automatically_derived]
1515 impl alloy_sol_types::SolEvent for Deposit {
1516 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1517 type DataToken<'a> = <Self::DataTuple<
1518 'a,
1519 > as alloy_sol_types::SolType>::Token<'a>;
1520 type TopicList = (
1521 alloy_sol_types::sol_data::FixedBytes<32>,
1522 alloy::sol_types::sol_data::Address,
1523 );
1524 const SIGNATURE: &'static str = "Deposit(address,uint256)";
1525 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1526 225u8, 255u8, 252u8, 196u8, 146u8, 61u8, 4u8, 181u8, 89u8, 244u8, 210u8,
1527 154u8, 139u8, 252u8, 108u8, 218u8, 4u8, 235u8, 91u8, 13u8, 60u8, 70u8,
1528 7u8, 81u8, 194u8, 64u8, 44u8, 92u8, 92u8, 201u8, 16u8, 156u8,
1529 ]);
1530 const ANONYMOUS: bool = false;
1531 #[allow(unused_variables)]
1532 #[inline]
1533 fn new(
1534 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1535 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1536 ) -> Self {
1537 Self {
1538 user: topics.1,
1539 amount: data.0,
1540 }
1541 }
1542 #[inline]
1543 fn check_signature(
1544 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1545 ) -> alloy_sol_types::Result<()> {
1546 if topics.0 != Self::SIGNATURE_HASH {
1547 return Err(
1548 alloy_sol_types::Error::invalid_event_signature_hash(
1549 Self::SIGNATURE,
1550 topics.0,
1551 Self::SIGNATURE_HASH,
1552 ),
1553 );
1554 }
1555 Ok(())
1556 }
1557 #[inline]
1558 fn tokenize_body(&self) -> Self::DataToken<'_> {
1559 (
1560 <alloy::sol_types::sol_data::Uint<
1561 256,
1562 > as alloy_sol_types::SolType>::tokenize(&self.amount),
1563 )
1564 }
1565 #[inline]
1566 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1567 (Self::SIGNATURE_HASH.into(), self.user.clone())
1568 }
1569 #[inline]
1570 fn encode_topics_raw(
1571 &self,
1572 out: &mut [alloy_sol_types::abi::token::WordToken],
1573 ) -> alloy_sol_types::Result<()> {
1574 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1575 return Err(alloy_sol_types::Error::Overrun);
1576 }
1577 out[0usize] = alloy_sol_types::abi::token::WordToken(
1578 Self::SIGNATURE_HASH,
1579 );
1580 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1581 &self.user,
1582 );
1583 Ok(())
1584 }
1585 }
1586 #[automatically_derived]
1587 impl alloy_sol_types::private::IntoLogData for Deposit {
1588 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1589 From::from(self)
1590 }
1591 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1592 From::from(&self)
1593 }
1594 }
1595 #[automatically_derived]
1596 impl From<&Deposit> for alloy_sol_types::private::LogData {
1597 #[inline]
1598 fn from(this: &Deposit) -> alloy_sol_types::private::LogData {
1599 alloy_sol_types::SolEvent::encode_log_data(this)
1600 }
1601 }
1602 };
1603 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1604 #[allow(
1609 non_camel_case_types,
1610 non_snake_case,
1611 clippy::pub_underscore_fields,
1612 clippy::style
1613 )]
1614 #[derive(Clone)]
1615 pub struct Initialized {
1616 #[allow(missing_docs)]
1617 pub version: u64,
1618 }
1619 #[allow(
1620 non_camel_case_types,
1621 non_snake_case,
1622 clippy::pub_underscore_fields,
1623 clippy::style
1624 )]
1625 const _: () = {
1626 use alloy::sol_types as alloy_sol_types;
1627 #[automatically_derived]
1628 impl alloy_sol_types::SolEvent for Initialized {
1629 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
1630 type DataToken<'a> = <Self::DataTuple<
1631 'a,
1632 > as alloy_sol_types::SolType>::Token<'a>;
1633 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1634 const SIGNATURE: &'static str = "Initialized(uint64)";
1635 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1636 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
1637 19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
1638 33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
1639 ]);
1640 const ANONYMOUS: bool = false;
1641 #[allow(unused_variables)]
1642 #[inline]
1643 fn new(
1644 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1645 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1646 ) -> Self {
1647 Self { version: data.0 }
1648 }
1649 #[inline]
1650 fn check_signature(
1651 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1652 ) -> alloy_sol_types::Result<()> {
1653 if topics.0 != Self::SIGNATURE_HASH {
1654 return Err(
1655 alloy_sol_types::Error::invalid_event_signature_hash(
1656 Self::SIGNATURE,
1657 topics.0,
1658 Self::SIGNATURE_HASH,
1659 ),
1660 );
1661 }
1662 Ok(())
1663 }
1664 #[inline]
1665 fn tokenize_body(&self) -> Self::DataToken<'_> {
1666 (
1667 <alloy::sol_types::sol_data::Uint<
1668 64,
1669 > as alloy_sol_types::SolType>::tokenize(&self.version),
1670 )
1671 }
1672 #[inline]
1673 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1674 (Self::SIGNATURE_HASH.into(),)
1675 }
1676 #[inline]
1677 fn encode_topics_raw(
1678 &self,
1679 out: &mut [alloy_sol_types::abi::token::WordToken],
1680 ) -> alloy_sol_types::Result<()> {
1681 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1682 return Err(alloy_sol_types::Error::Overrun);
1683 }
1684 out[0usize] = alloy_sol_types::abi::token::WordToken(
1685 Self::SIGNATURE_HASH,
1686 );
1687 Ok(())
1688 }
1689 }
1690 #[automatically_derived]
1691 impl alloy_sol_types::private::IntoLogData for Initialized {
1692 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1693 From::from(self)
1694 }
1695 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1696 From::from(&self)
1697 }
1698 }
1699 #[automatically_derived]
1700 impl From<&Initialized> for alloy_sol_types::private::LogData {
1701 #[inline]
1702 fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
1703 alloy_sol_types::SolEvent::encode_log_data(this)
1704 }
1705 }
1706 };
1707 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1708 #[allow(
1713 non_camel_case_types,
1714 non_snake_case,
1715 clippy::pub_underscore_fields,
1716 clippy::style
1717 )]
1718 #[derive(Clone)]
1719 pub struct Log {
1720 #[allow(missing_docs)]
1721 pub func: alloy::sol_types::private::String,
1722 #[allow(missing_docs)]
1723 pub gas: alloy::sol_types::private::primitives::aliases::U256,
1724 }
1725 #[allow(
1726 non_camel_case_types,
1727 non_snake_case,
1728 clippy::pub_underscore_fields,
1729 clippy::style
1730 )]
1731 const _: () = {
1732 use alloy::sol_types as alloy_sol_types;
1733 #[automatically_derived]
1734 impl alloy_sol_types::SolEvent for Log {
1735 type DataTuple<'a> = (
1736 alloy::sol_types::sol_data::String,
1737 alloy::sol_types::sol_data::Uint<256>,
1738 );
1739 type DataToken<'a> = <Self::DataTuple<
1740 'a,
1741 > as alloy_sol_types::SolType>::Token<'a>;
1742 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1743 const SIGNATURE: &'static str = "Log(string,uint256)";
1744 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1745 221u8, 151u8, 13u8, 217u8, 181u8, 191u8, 231u8, 7u8, 146u8, 33u8, 85u8,
1746 176u8, 88u8, 164u8, 7u8, 101u8, 92u8, 177u8, 130u8, 136u8, 184u8, 7u8,
1747 226u8, 33u8, 100u8, 66u8, 188u8, 168u8, 173u8, 131u8, 214u8, 181u8,
1748 ]);
1749 const ANONYMOUS: bool = false;
1750 #[allow(unused_variables)]
1751 #[inline]
1752 fn new(
1753 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1754 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1755 ) -> Self {
1756 Self { func: data.0, gas: data.1 }
1757 }
1758 #[inline]
1759 fn check_signature(
1760 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1761 ) -> alloy_sol_types::Result<()> {
1762 if topics.0 != Self::SIGNATURE_HASH {
1763 return Err(
1764 alloy_sol_types::Error::invalid_event_signature_hash(
1765 Self::SIGNATURE,
1766 topics.0,
1767 Self::SIGNATURE_HASH,
1768 ),
1769 );
1770 }
1771 Ok(())
1772 }
1773 #[inline]
1774 fn tokenize_body(&self) -> Self::DataToken<'_> {
1775 (
1776 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1777 &self.func,
1778 ),
1779 <alloy::sol_types::sol_data::Uint<
1780 256,
1781 > as alloy_sol_types::SolType>::tokenize(&self.gas),
1782 )
1783 }
1784 #[inline]
1785 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1786 (Self::SIGNATURE_HASH.into(),)
1787 }
1788 #[inline]
1789 fn encode_topics_raw(
1790 &self,
1791 out: &mut [alloy_sol_types::abi::token::WordToken],
1792 ) -> alloy_sol_types::Result<()> {
1793 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1794 return Err(alloy_sol_types::Error::Overrun);
1795 }
1796 out[0usize] = alloy_sol_types::abi::token::WordToken(
1797 Self::SIGNATURE_HASH,
1798 );
1799 Ok(())
1800 }
1801 }
1802 #[automatically_derived]
1803 impl alloy_sol_types::private::IntoLogData for Log {
1804 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1805 From::from(self)
1806 }
1807 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1808 From::from(&self)
1809 }
1810 }
1811 #[automatically_derived]
1812 impl From<&Log> for alloy_sol_types::private::LogData {
1813 #[inline]
1814 fn from(this: &Log) -> alloy_sol_types::private::LogData {
1815 alloy_sol_types::SolEvent::encode_log_data(this)
1816 }
1817 }
1818 };
1819 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1820 #[allow(
1825 non_camel_case_types,
1826 non_snake_case,
1827 clippy::pub_underscore_fields,
1828 clippy::style
1829 )]
1830 #[derive(Clone)]
1831 pub struct OwnershipTransferred {
1832 #[allow(missing_docs)]
1833 pub previousOwner: alloy::sol_types::private::Address,
1834 #[allow(missing_docs)]
1835 pub newOwner: alloy::sol_types::private::Address,
1836 }
1837 #[allow(
1838 non_camel_case_types,
1839 non_snake_case,
1840 clippy::pub_underscore_fields,
1841 clippy::style
1842 )]
1843 const _: () = {
1844 use alloy::sol_types as alloy_sol_types;
1845 #[automatically_derived]
1846 impl alloy_sol_types::SolEvent for OwnershipTransferred {
1847 type DataTuple<'a> = ();
1848 type DataToken<'a> = <Self::DataTuple<
1849 'a,
1850 > as alloy_sol_types::SolType>::Token<'a>;
1851 type TopicList = (
1852 alloy_sol_types::sol_data::FixedBytes<32>,
1853 alloy::sol_types::sol_data::Address,
1854 alloy::sol_types::sol_data::Address,
1855 );
1856 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
1857 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1858 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
1859 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
1860 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
1861 ]);
1862 const ANONYMOUS: bool = false;
1863 #[allow(unused_variables)]
1864 #[inline]
1865 fn new(
1866 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1867 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1868 ) -> Self {
1869 Self {
1870 previousOwner: topics.1,
1871 newOwner: topics.2,
1872 }
1873 }
1874 #[inline]
1875 fn check_signature(
1876 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1877 ) -> alloy_sol_types::Result<()> {
1878 if topics.0 != Self::SIGNATURE_HASH {
1879 return Err(
1880 alloy_sol_types::Error::invalid_event_signature_hash(
1881 Self::SIGNATURE,
1882 topics.0,
1883 Self::SIGNATURE_HASH,
1884 ),
1885 );
1886 }
1887 Ok(())
1888 }
1889 #[inline]
1890 fn tokenize_body(&self) -> Self::DataToken<'_> {
1891 ()
1892 }
1893 #[inline]
1894 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1895 (
1896 Self::SIGNATURE_HASH.into(),
1897 self.previousOwner.clone(),
1898 self.newOwner.clone(),
1899 )
1900 }
1901 #[inline]
1902 fn encode_topics_raw(
1903 &self,
1904 out: &mut [alloy_sol_types::abi::token::WordToken],
1905 ) -> alloy_sol_types::Result<()> {
1906 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1907 return Err(alloy_sol_types::Error::Overrun);
1908 }
1909 out[0usize] = alloy_sol_types::abi::token::WordToken(
1910 Self::SIGNATURE_HASH,
1911 );
1912 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1913 &self.previousOwner,
1914 );
1915 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1916 &self.newOwner,
1917 );
1918 Ok(())
1919 }
1920 }
1921 #[automatically_derived]
1922 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
1923 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1924 From::from(self)
1925 }
1926 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1927 From::from(&self)
1928 }
1929 }
1930 #[automatically_derived]
1931 impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
1932 #[inline]
1933 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
1934 alloy_sol_types::SolEvent::encode_log_data(this)
1935 }
1936 }
1937 };
1938 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1939 #[allow(
1944 non_camel_case_types,
1945 non_snake_case,
1946 clippy::pub_underscore_fields,
1947 clippy::style
1948 )]
1949 #[derive(Clone)]
1950 pub struct Upgrade {
1951 #[allow(missing_docs)]
1952 pub implementation: alloy::sol_types::private::Address,
1953 }
1954 #[allow(
1955 non_camel_case_types,
1956 non_snake_case,
1957 clippy::pub_underscore_fields,
1958 clippy::style
1959 )]
1960 const _: () = {
1961 use alloy::sol_types as alloy_sol_types;
1962 #[automatically_derived]
1963 impl alloy_sol_types::SolEvent for Upgrade {
1964 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1965 type DataToken<'a> = <Self::DataTuple<
1966 'a,
1967 > as alloy_sol_types::SolType>::Token<'a>;
1968 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1969 const SIGNATURE: &'static str = "Upgrade(address)";
1970 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1971 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8,
1972 154u8, 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8,
1973 185u8, 62u8, 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
1974 ]);
1975 const ANONYMOUS: bool = false;
1976 #[allow(unused_variables)]
1977 #[inline]
1978 fn new(
1979 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1980 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1981 ) -> Self {
1982 Self { implementation: data.0 }
1983 }
1984 #[inline]
1985 fn check_signature(
1986 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1987 ) -> alloy_sol_types::Result<()> {
1988 if topics.0 != Self::SIGNATURE_HASH {
1989 return Err(
1990 alloy_sol_types::Error::invalid_event_signature_hash(
1991 Self::SIGNATURE,
1992 topics.0,
1993 Self::SIGNATURE_HASH,
1994 ),
1995 );
1996 }
1997 Ok(())
1998 }
1999 #[inline]
2000 fn tokenize_body(&self) -> Self::DataToken<'_> {
2001 (
2002 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2003 &self.implementation,
2004 ),
2005 )
2006 }
2007 #[inline]
2008 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2009 (Self::SIGNATURE_HASH.into(),)
2010 }
2011 #[inline]
2012 fn encode_topics_raw(
2013 &self,
2014 out: &mut [alloy_sol_types::abi::token::WordToken],
2015 ) -> alloy_sol_types::Result<()> {
2016 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2017 return Err(alloy_sol_types::Error::Overrun);
2018 }
2019 out[0usize] = alloy_sol_types::abi::token::WordToken(
2020 Self::SIGNATURE_HASH,
2021 );
2022 Ok(())
2023 }
2024 }
2025 #[automatically_derived]
2026 impl alloy_sol_types::private::IntoLogData for Upgrade {
2027 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2028 From::from(self)
2029 }
2030 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2031 From::from(&self)
2032 }
2033 }
2034 #[automatically_derived]
2035 impl From<&Upgrade> for alloy_sol_types::private::LogData {
2036 #[inline]
2037 fn from(this: &Upgrade) -> alloy_sol_types::private::LogData {
2038 alloy_sol_types::SolEvent::encode_log_data(this)
2039 }
2040 }
2041 };
2042 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2043 #[allow(
2048 non_camel_case_types,
2049 non_snake_case,
2050 clippy::pub_underscore_fields,
2051 clippy::style
2052 )]
2053 #[derive(Clone)]
2054 pub struct Upgraded {
2055 #[allow(missing_docs)]
2056 pub implementation: alloy::sol_types::private::Address,
2057 }
2058 #[allow(
2059 non_camel_case_types,
2060 non_snake_case,
2061 clippy::pub_underscore_fields,
2062 clippy::style
2063 )]
2064 const _: () = {
2065 use alloy::sol_types as alloy_sol_types;
2066 #[automatically_derived]
2067 impl alloy_sol_types::SolEvent for Upgraded {
2068 type DataTuple<'a> = ();
2069 type DataToken<'a> = <Self::DataTuple<
2070 'a,
2071 > as alloy_sol_types::SolType>::Token<'a>;
2072 type TopicList = (
2073 alloy_sol_types::sol_data::FixedBytes<32>,
2074 alloy::sol_types::sol_data::Address,
2075 );
2076 const SIGNATURE: &'static str = "Upgraded(address)";
2077 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2078 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
2079 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8,
2080 12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
2081 ]);
2082 const ANONYMOUS: bool = false;
2083 #[allow(unused_variables)]
2084 #[inline]
2085 fn new(
2086 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2087 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2088 ) -> Self {
2089 Self { implementation: topics.1 }
2090 }
2091 #[inline]
2092 fn check_signature(
2093 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2094 ) -> alloy_sol_types::Result<()> {
2095 if topics.0 != Self::SIGNATURE_HASH {
2096 return Err(
2097 alloy_sol_types::Error::invalid_event_signature_hash(
2098 Self::SIGNATURE,
2099 topics.0,
2100 Self::SIGNATURE_HASH,
2101 ),
2102 );
2103 }
2104 Ok(())
2105 }
2106 #[inline]
2107 fn tokenize_body(&self) -> Self::DataToken<'_> {
2108 ()
2109 }
2110 #[inline]
2111 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2112 (Self::SIGNATURE_HASH.into(), self.implementation.clone())
2113 }
2114 #[inline]
2115 fn encode_topics_raw(
2116 &self,
2117 out: &mut [alloy_sol_types::abi::token::WordToken],
2118 ) -> alloy_sol_types::Result<()> {
2119 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2120 return Err(alloy_sol_types::Error::Overrun);
2121 }
2122 out[0usize] = alloy_sol_types::abi::token::WordToken(
2123 Self::SIGNATURE_HASH,
2124 );
2125 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2126 &self.implementation,
2127 );
2128 Ok(())
2129 }
2130 }
2131 #[automatically_derived]
2132 impl alloy_sol_types::private::IntoLogData for Upgraded {
2133 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2134 From::from(self)
2135 }
2136 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2137 From::from(&self)
2138 }
2139 }
2140 #[automatically_derived]
2141 impl From<&Upgraded> for alloy_sol_types::private::LogData {
2142 #[inline]
2143 fn from(this: &Upgraded) -> alloy_sol_types::private::LogData {
2144 alloy_sol_types::SolEvent::encode_log_data(this)
2145 }
2146 }
2147 };
2148 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2153 #[derive(Clone)]
2154 pub struct constructorCall {}
2155 const _: () = {
2156 use alloy::sol_types as alloy_sol_types;
2157 {
2158 #[doc(hidden)]
2159 type UnderlyingSolTuple<'a> = ();
2160 #[doc(hidden)]
2161 type UnderlyingRustTuple<'a> = ();
2162 #[cfg(test)]
2163 #[allow(dead_code, unreachable_patterns)]
2164 fn _type_assertion(
2165 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2166 ) {
2167 match _t {
2168 alloy_sol_types::private::AssertTypeEq::<
2169 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2170 >(_) => {}
2171 }
2172 }
2173 #[automatically_derived]
2174 #[doc(hidden)]
2175 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
2176 fn from(value: constructorCall) -> Self {
2177 ()
2178 }
2179 }
2180 #[automatically_derived]
2181 #[doc(hidden)]
2182 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
2183 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2184 Self {}
2185 }
2186 }
2187 }
2188 #[automatically_derived]
2189 impl alloy_sol_types::SolConstructor for constructorCall {
2190 type Parameters<'a> = ();
2191 type Token<'a> = <Self::Parameters<
2192 'a,
2193 > as alloy_sol_types::SolType>::Token<'a>;
2194 #[inline]
2195 fn new<'a>(
2196 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2197 ) -> Self {
2198 tuple.into()
2199 }
2200 #[inline]
2201 fn tokenize(&self) -> Self::Token<'_> {
2202 ()
2203 }
2204 }
2205 };
2206 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2207 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2212 #[derive(Clone)]
2213 pub struct UPGRADE_INTERFACE_VERSIONCall {}
2214 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2215 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2217 #[derive(Clone)]
2218 pub struct UPGRADE_INTERFACE_VERSIONReturn {
2219 #[allow(missing_docs)]
2220 pub _0: alloy::sol_types::private::String,
2221 }
2222 #[allow(
2223 non_camel_case_types,
2224 non_snake_case,
2225 clippy::pub_underscore_fields,
2226 clippy::style
2227 )]
2228 const _: () = {
2229 use alloy::sol_types as alloy_sol_types;
2230 {
2231 #[doc(hidden)]
2232 type UnderlyingSolTuple<'a> = ();
2233 #[doc(hidden)]
2234 type UnderlyingRustTuple<'a> = ();
2235 #[cfg(test)]
2236 #[allow(dead_code, unreachable_patterns)]
2237 fn _type_assertion(
2238 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2239 ) {
2240 match _t {
2241 alloy_sol_types::private::AssertTypeEq::<
2242 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2243 >(_) => {}
2244 }
2245 }
2246 #[automatically_derived]
2247 #[doc(hidden)]
2248 impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONCall>
2249 for UnderlyingRustTuple<'_> {
2250 fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self {
2251 ()
2252 }
2253 }
2254 #[automatically_derived]
2255 #[doc(hidden)]
2256 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2257 for UPGRADE_INTERFACE_VERSIONCall {
2258 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2259 Self {}
2260 }
2261 }
2262 }
2263 {
2264 #[doc(hidden)]
2265 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2266 #[doc(hidden)]
2267 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2268 #[cfg(test)]
2269 #[allow(dead_code, unreachable_patterns)]
2270 fn _type_assertion(
2271 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2272 ) {
2273 match _t {
2274 alloy_sol_types::private::AssertTypeEq::<
2275 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2276 >(_) => {}
2277 }
2278 }
2279 #[automatically_derived]
2280 #[doc(hidden)]
2281 impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONReturn>
2282 for UnderlyingRustTuple<'_> {
2283 fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self {
2284 (value._0,)
2285 }
2286 }
2287 #[automatically_derived]
2288 #[doc(hidden)]
2289 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2290 for UPGRADE_INTERFACE_VERSIONReturn {
2291 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2292 Self { _0: tuple.0 }
2293 }
2294 }
2295 }
2296 #[automatically_derived]
2297 impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall {
2298 type Parameters<'a> = ();
2299 type Token<'a> = <Self::Parameters<
2300 'a,
2301 > as alloy_sol_types::SolType>::Token<'a>;
2302 type Return = UPGRADE_INTERFACE_VERSIONReturn;
2303 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2304 type ReturnToken<'a> = <Self::ReturnTuple<
2305 'a,
2306 > as alloy_sol_types::SolType>::Token<'a>;
2307 const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()";
2308 const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8];
2309 #[inline]
2310 fn new<'a>(
2311 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2312 ) -> Self {
2313 tuple.into()
2314 }
2315 #[inline]
2316 fn tokenize(&self) -> Self::Token<'_> {
2317 ()
2318 }
2319 #[inline]
2320 fn abi_decode_returns(
2321 data: &[u8],
2322 validate: bool,
2323 ) -> alloy_sol_types::Result<Self::Return> {
2324 <Self::ReturnTuple<
2325 '_,
2326 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2327 .map(Into::into)
2328 }
2329 }
2330 };
2331 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2332 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2337 #[derive(Clone)]
2338 pub struct balancesCall {
2339 #[allow(missing_docs)]
2340 pub user: alloy::sol_types::private::Address,
2341 }
2342 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2343 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2345 #[derive(Clone)]
2346 pub struct balancesReturn {
2347 #[allow(missing_docs)]
2348 pub amount: alloy::sol_types::private::primitives::aliases::U256,
2349 }
2350 #[allow(
2351 non_camel_case_types,
2352 non_snake_case,
2353 clippy::pub_underscore_fields,
2354 clippy::style
2355 )]
2356 const _: () = {
2357 use alloy::sol_types as alloy_sol_types;
2358 {
2359 #[doc(hidden)]
2360 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2361 #[doc(hidden)]
2362 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2363 #[cfg(test)]
2364 #[allow(dead_code, unreachable_patterns)]
2365 fn _type_assertion(
2366 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2367 ) {
2368 match _t {
2369 alloy_sol_types::private::AssertTypeEq::<
2370 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2371 >(_) => {}
2372 }
2373 }
2374 #[automatically_derived]
2375 #[doc(hidden)]
2376 impl ::core::convert::From<balancesCall> for UnderlyingRustTuple<'_> {
2377 fn from(value: balancesCall) -> Self {
2378 (value.user,)
2379 }
2380 }
2381 #[automatically_derived]
2382 #[doc(hidden)]
2383 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balancesCall {
2384 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2385 Self { user: tuple.0 }
2386 }
2387 }
2388 }
2389 {
2390 #[doc(hidden)]
2391 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2392 #[doc(hidden)]
2393 type UnderlyingRustTuple<'a> = (
2394 alloy::sol_types::private::primitives::aliases::U256,
2395 );
2396 #[cfg(test)]
2397 #[allow(dead_code, unreachable_patterns)]
2398 fn _type_assertion(
2399 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2400 ) {
2401 match _t {
2402 alloy_sol_types::private::AssertTypeEq::<
2403 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2404 >(_) => {}
2405 }
2406 }
2407 #[automatically_derived]
2408 #[doc(hidden)]
2409 impl ::core::convert::From<balancesReturn> for UnderlyingRustTuple<'_> {
2410 fn from(value: balancesReturn) -> Self {
2411 (value.amount,)
2412 }
2413 }
2414 #[automatically_derived]
2415 #[doc(hidden)]
2416 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balancesReturn {
2417 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2418 Self { amount: tuple.0 }
2419 }
2420 }
2421 }
2422 #[automatically_derived]
2423 impl alloy_sol_types::SolCall for balancesCall {
2424 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2425 type Token<'a> = <Self::Parameters<
2426 'a,
2427 > as alloy_sol_types::SolType>::Token<'a>;
2428 type Return = balancesReturn;
2429 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2430 type ReturnToken<'a> = <Self::ReturnTuple<
2431 'a,
2432 > as alloy_sol_types::SolType>::Token<'a>;
2433 const SIGNATURE: &'static str = "balances(address)";
2434 const SELECTOR: [u8; 4] = [39u8, 226u8, 53u8, 227u8];
2435 #[inline]
2436 fn new<'a>(
2437 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2438 ) -> Self {
2439 tuple.into()
2440 }
2441 #[inline]
2442 fn tokenize(&self) -> Self::Token<'_> {
2443 (
2444 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2445 &self.user,
2446 ),
2447 )
2448 }
2449 #[inline]
2450 fn abi_decode_returns(
2451 data: &[u8],
2452 validate: bool,
2453 ) -> alloy_sol_types::Result<Self::Return> {
2454 <Self::ReturnTuple<
2455 '_,
2456 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2457 .map(Into::into)
2458 }
2459 }
2460 };
2461 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2462 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2467 #[derive(Clone)]
2468 pub struct depositCall {
2469 #[allow(missing_docs)]
2470 pub user: alloy::sol_types::private::Address,
2471 }
2472 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2474 #[derive(Clone)]
2475 pub struct depositReturn {}
2476 #[allow(
2477 non_camel_case_types,
2478 non_snake_case,
2479 clippy::pub_underscore_fields,
2480 clippy::style
2481 )]
2482 const _: () = {
2483 use alloy::sol_types as alloy_sol_types;
2484 {
2485 #[doc(hidden)]
2486 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2487 #[doc(hidden)]
2488 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2489 #[cfg(test)]
2490 #[allow(dead_code, unreachable_patterns)]
2491 fn _type_assertion(
2492 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2493 ) {
2494 match _t {
2495 alloy_sol_types::private::AssertTypeEq::<
2496 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2497 >(_) => {}
2498 }
2499 }
2500 #[automatically_derived]
2501 #[doc(hidden)]
2502 impl ::core::convert::From<depositCall> for UnderlyingRustTuple<'_> {
2503 fn from(value: depositCall) -> Self {
2504 (value.user,)
2505 }
2506 }
2507 #[automatically_derived]
2508 #[doc(hidden)]
2509 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositCall {
2510 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2511 Self { user: tuple.0 }
2512 }
2513 }
2514 }
2515 {
2516 #[doc(hidden)]
2517 type UnderlyingSolTuple<'a> = ();
2518 #[doc(hidden)]
2519 type UnderlyingRustTuple<'a> = ();
2520 #[cfg(test)]
2521 #[allow(dead_code, unreachable_patterns)]
2522 fn _type_assertion(
2523 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2524 ) {
2525 match _t {
2526 alloy_sol_types::private::AssertTypeEq::<
2527 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2528 >(_) => {}
2529 }
2530 }
2531 #[automatically_derived]
2532 #[doc(hidden)]
2533 impl ::core::convert::From<depositReturn> for UnderlyingRustTuple<'_> {
2534 fn from(value: depositReturn) -> Self {
2535 ()
2536 }
2537 }
2538 #[automatically_derived]
2539 #[doc(hidden)]
2540 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositReturn {
2541 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2542 Self {}
2543 }
2544 }
2545 }
2546 #[automatically_derived]
2547 impl alloy_sol_types::SolCall for depositCall {
2548 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2549 type Token<'a> = <Self::Parameters<
2550 'a,
2551 > as alloy_sol_types::SolType>::Token<'a>;
2552 type Return = depositReturn;
2553 type ReturnTuple<'a> = ();
2554 type ReturnToken<'a> = <Self::ReturnTuple<
2555 'a,
2556 > as alloy_sol_types::SolType>::Token<'a>;
2557 const SIGNATURE: &'static str = "deposit(address)";
2558 const SELECTOR: [u8; 4] = [243u8, 64u8, 250u8, 1u8];
2559 #[inline]
2560 fn new<'a>(
2561 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2562 ) -> Self {
2563 tuple.into()
2564 }
2565 #[inline]
2566 fn tokenize(&self) -> Self::Token<'_> {
2567 (
2568 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2569 &self.user,
2570 ),
2571 )
2572 }
2573 #[inline]
2574 fn abi_decode_returns(
2575 data: &[u8],
2576 validate: bool,
2577 ) -> alloy_sol_types::Result<Self::Return> {
2578 <Self::ReturnTuple<
2579 '_,
2580 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2581 .map(Into::into)
2582 }
2583 }
2584 };
2585 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2586 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2591 #[derive(Clone)]
2592 pub struct getVersionCall {}
2593 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2594 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2596 #[derive(Clone)]
2597 pub struct getVersionReturn {
2598 #[allow(missing_docs)]
2599 pub majorVersion: u8,
2600 #[allow(missing_docs)]
2601 pub minorVersion: u8,
2602 #[allow(missing_docs)]
2603 pub patchVersion: u8,
2604 }
2605 #[allow(
2606 non_camel_case_types,
2607 non_snake_case,
2608 clippy::pub_underscore_fields,
2609 clippy::style
2610 )]
2611 const _: () = {
2612 use alloy::sol_types as alloy_sol_types;
2613 {
2614 #[doc(hidden)]
2615 type UnderlyingSolTuple<'a> = ();
2616 #[doc(hidden)]
2617 type UnderlyingRustTuple<'a> = ();
2618 #[cfg(test)]
2619 #[allow(dead_code, unreachable_patterns)]
2620 fn _type_assertion(
2621 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2622 ) {
2623 match _t {
2624 alloy_sol_types::private::AssertTypeEq::<
2625 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2626 >(_) => {}
2627 }
2628 }
2629 #[automatically_derived]
2630 #[doc(hidden)]
2631 impl ::core::convert::From<getVersionCall> for UnderlyingRustTuple<'_> {
2632 fn from(value: getVersionCall) -> Self {
2633 ()
2634 }
2635 }
2636 #[automatically_derived]
2637 #[doc(hidden)]
2638 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionCall {
2639 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2640 Self {}
2641 }
2642 }
2643 }
2644 {
2645 #[doc(hidden)]
2646 type UnderlyingSolTuple<'a> = (
2647 alloy::sol_types::sol_data::Uint<8>,
2648 alloy::sol_types::sol_data::Uint<8>,
2649 alloy::sol_types::sol_data::Uint<8>,
2650 );
2651 #[doc(hidden)]
2652 type UnderlyingRustTuple<'a> = (u8, u8, u8);
2653 #[cfg(test)]
2654 #[allow(dead_code, unreachable_patterns)]
2655 fn _type_assertion(
2656 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2657 ) {
2658 match _t {
2659 alloy_sol_types::private::AssertTypeEq::<
2660 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2661 >(_) => {}
2662 }
2663 }
2664 #[automatically_derived]
2665 #[doc(hidden)]
2666 impl ::core::convert::From<getVersionReturn> for UnderlyingRustTuple<'_> {
2667 fn from(value: getVersionReturn) -> Self {
2668 (value.majorVersion, value.minorVersion, value.patchVersion)
2669 }
2670 }
2671 #[automatically_derived]
2672 #[doc(hidden)]
2673 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionReturn {
2674 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2675 Self {
2676 majorVersion: tuple.0,
2677 minorVersion: tuple.1,
2678 patchVersion: tuple.2,
2679 }
2680 }
2681 }
2682 }
2683 #[automatically_derived]
2684 impl alloy_sol_types::SolCall for getVersionCall {
2685 type Parameters<'a> = ();
2686 type Token<'a> = <Self::Parameters<
2687 'a,
2688 > as alloy_sol_types::SolType>::Token<'a>;
2689 type Return = getVersionReturn;
2690 type ReturnTuple<'a> = (
2691 alloy::sol_types::sol_data::Uint<8>,
2692 alloy::sol_types::sol_data::Uint<8>,
2693 alloy::sol_types::sol_data::Uint<8>,
2694 );
2695 type ReturnToken<'a> = <Self::ReturnTuple<
2696 'a,
2697 > as alloy_sol_types::SolType>::Token<'a>;
2698 const SIGNATURE: &'static str = "getVersion()";
2699 const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8];
2700 #[inline]
2701 fn new<'a>(
2702 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2703 ) -> Self {
2704 tuple.into()
2705 }
2706 #[inline]
2707 fn tokenize(&self) -> Self::Token<'_> {
2708 ()
2709 }
2710 #[inline]
2711 fn abi_decode_returns(
2712 data: &[u8],
2713 validate: bool,
2714 ) -> alloy_sol_types::Result<Self::Return> {
2715 <Self::ReturnTuple<
2716 '_,
2717 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2718 .map(Into::into)
2719 }
2720 }
2721 };
2722 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2723 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2728 #[derive(Clone)]
2729 pub struct initializeCall {
2730 #[allow(missing_docs)]
2731 pub multisig: alloy::sol_types::private::Address,
2732 }
2733 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2735 #[derive(Clone)]
2736 pub struct initializeReturn {}
2737 #[allow(
2738 non_camel_case_types,
2739 non_snake_case,
2740 clippy::pub_underscore_fields,
2741 clippy::style
2742 )]
2743 const _: () = {
2744 use alloy::sol_types as alloy_sol_types;
2745 {
2746 #[doc(hidden)]
2747 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2748 #[doc(hidden)]
2749 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2750 #[cfg(test)]
2751 #[allow(dead_code, unreachable_patterns)]
2752 fn _type_assertion(
2753 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2754 ) {
2755 match _t {
2756 alloy_sol_types::private::AssertTypeEq::<
2757 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2758 >(_) => {}
2759 }
2760 }
2761 #[automatically_derived]
2762 #[doc(hidden)]
2763 impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
2764 fn from(value: initializeCall) -> Self {
2765 (value.multisig,)
2766 }
2767 }
2768 #[automatically_derived]
2769 #[doc(hidden)]
2770 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
2771 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2772 Self { multisig: tuple.0 }
2773 }
2774 }
2775 }
2776 {
2777 #[doc(hidden)]
2778 type UnderlyingSolTuple<'a> = ();
2779 #[doc(hidden)]
2780 type UnderlyingRustTuple<'a> = ();
2781 #[cfg(test)]
2782 #[allow(dead_code, unreachable_patterns)]
2783 fn _type_assertion(
2784 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2785 ) {
2786 match _t {
2787 alloy_sol_types::private::AssertTypeEq::<
2788 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2789 >(_) => {}
2790 }
2791 }
2792 #[automatically_derived]
2793 #[doc(hidden)]
2794 impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
2795 fn from(value: initializeReturn) -> Self {
2796 ()
2797 }
2798 }
2799 #[automatically_derived]
2800 #[doc(hidden)]
2801 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
2802 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2803 Self {}
2804 }
2805 }
2806 }
2807 #[automatically_derived]
2808 impl alloy_sol_types::SolCall for initializeCall {
2809 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2810 type Token<'a> = <Self::Parameters<
2811 'a,
2812 > as alloy_sol_types::SolType>::Token<'a>;
2813 type Return = initializeReturn;
2814 type ReturnTuple<'a> = ();
2815 type ReturnToken<'a> = <Self::ReturnTuple<
2816 'a,
2817 > as alloy_sol_types::SolType>::Token<'a>;
2818 const SIGNATURE: &'static str = "initialize(address)";
2819 const SELECTOR: [u8; 4] = [196u8, 214u8, 109u8, 232u8];
2820 #[inline]
2821 fn new<'a>(
2822 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2823 ) -> Self {
2824 tuple.into()
2825 }
2826 #[inline]
2827 fn tokenize(&self) -> Self::Token<'_> {
2828 (
2829 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2830 &self.multisig,
2831 ),
2832 )
2833 }
2834 #[inline]
2835 fn abi_decode_returns(
2836 data: &[u8],
2837 validate: bool,
2838 ) -> alloy_sol_types::Result<Self::Return> {
2839 <Self::ReturnTuple<
2840 '_,
2841 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2842 .map(Into::into)
2843 }
2844 }
2845 };
2846 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2847 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2852 #[derive(Clone)]
2853 pub struct maxDepositAmountCall {}
2854 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2855 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2857 #[derive(Clone)]
2858 pub struct maxDepositAmountReturn {
2859 #[allow(missing_docs)]
2860 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2861 }
2862 #[allow(
2863 non_camel_case_types,
2864 non_snake_case,
2865 clippy::pub_underscore_fields,
2866 clippy::style
2867 )]
2868 const _: () = {
2869 use alloy::sol_types as alloy_sol_types;
2870 {
2871 #[doc(hidden)]
2872 type UnderlyingSolTuple<'a> = ();
2873 #[doc(hidden)]
2874 type UnderlyingRustTuple<'a> = ();
2875 #[cfg(test)]
2876 #[allow(dead_code, unreachable_patterns)]
2877 fn _type_assertion(
2878 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2879 ) {
2880 match _t {
2881 alloy_sol_types::private::AssertTypeEq::<
2882 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2883 >(_) => {}
2884 }
2885 }
2886 #[automatically_derived]
2887 #[doc(hidden)]
2888 impl ::core::convert::From<maxDepositAmountCall>
2889 for UnderlyingRustTuple<'_> {
2890 fn from(value: maxDepositAmountCall) -> Self {
2891 ()
2892 }
2893 }
2894 #[automatically_derived]
2895 #[doc(hidden)]
2896 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2897 for maxDepositAmountCall {
2898 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2899 Self {}
2900 }
2901 }
2902 }
2903 {
2904 #[doc(hidden)]
2905 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2906 #[doc(hidden)]
2907 type UnderlyingRustTuple<'a> = (
2908 alloy::sol_types::private::primitives::aliases::U256,
2909 );
2910 #[cfg(test)]
2911 #[allow(dead_code, unreachable_patterns)]
2912 fn _type_assertion(
2913 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2914 ) {
2915 match _t {
2916 alloy_sol_types::private::AssertTypeEq::<
2917 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2918 >(_) => {}
2919 }
2920 }
2921 #[automatically_derived]
2922 #[doc(hidden)]
2923 impl ::core::convert::From<maxDepositAmountReturn>
2924 for UnderlyingRustTuple<'_> {
2925 fn from(value: maxDepositAmountReturn) -> Self {
2926 (value._0,)
2927 }
2928 }
2929 #[automatically_derived]
2930 #[doc(hidden)]
2931 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2932 for maxDepositAmountReturn {
2933 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2934 Self { _0: tuple.0 }
2935 }
2936 }
2937 }
2938 #[automatically_derived]
2939 impl alloy_sol_types::SolCall for maxDepositAmountCall {
2940 type Parameters<'a> = ();
2941 type Token<'a> = <Self::Parameters<
2942 'a,
2943 > as alloy_sol_types::SolType>::Token<'a>;
2944 type Return = maxDepositAmountReturn;
2945 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2946 type ReturnToken<'a> = <Self::ReturnTuple<
2947 'a,
2948 > as alloy_sol_types::SolType>::Token<'a>;
2949 const SIGNATURE: &'static str = "maxDepositAmount()";
2950 const SELECTOR: [u8; 4] = [142u8, 216u8, 50u8, 113u8];
2951 #[inline]
2952 fn new<'a>(
2953 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2954 ) -> Self {
2955 tuple.into()
2956 }
2957 #[inline]
2958 fn tokenize(&self) -> Self::Token<'_> {
2959 ()
2960 }
2961 #[inline]
2962 fn abi_decode_returns(
2963 data: &[u8],
2964 validate: bool,
2965 ) -> alloy_sol_types::Result<Self::Return> {
2966 <Self::ReturnTuple<
2967 '_,
2968 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2969 .map(Into::into)
2970 }
2971 }
2972 };
2973 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2974 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2979 #[derive(Clone)]
2980 pub struct minDepositAmountCall {}
2981 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2982 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2984 #[derive(Clone)]
2985 pub struct minDepositAmountReturn {
2986 #[allow(missing_docs)]
2987 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2988 }
2989 #[allow(
2990 non_camel_case_types,
2991 non_snake_case,
2992 clippy::pub_underscore_fields,
2993 clippy::style
2994 )]
2995 const _: () = {
2996 use alloy::sol_types as alloy_sol_types;
2997 {
2998 #[doc(hidden)]
2999 type UnderlyingSolTuple<'a> = ();
3000 #[doc(hidden)]
3001 type UnderlyingRustTuple<'a> = ();
3002 #[cfg(test)]
3003 #[allow(dead_code, unreachable_patterns)]
3004 fn _type_assertion(
3005 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3006 ) {
3007 match _t {
3008 alloy_sol_types::private::AssertTypeEq::<
3009 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3010 >(_) => {}
3011 }
3012 }
3013 #[automatically_derived]
3014 #[doc(hidden)]
3015 impl ::core::convert::From<minDepositAmountCall>
3016 for UnderlyingRustTuple<'_> {
3017 fn from(value: minDepositAmountCall) -> Self {
3018 ()
3019 }
3020 }
3021 #[automatically_derived]
3022 #[doc(hidden)]
3023 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3024 for minDepositAmountCall {
3025 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3026 Self {}
3027 }
3028 }
3029 }
3030 {
3031 #[doc(hidden)]
3032 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3033 #[doc(hidden)]
3034 type UnderlyingRustTuple<'a> = (
3035 alloy::sol_types::private::primitives::aliases::U256,
3036 );
3037 #[cfg(test)]
3038 #[allow(dead_code, unreachable_patterns)]
3039 fn _type_assertion(
3040 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3041 ) {
3042 match _t {
3043 alloy_sol_types::private::AssertTypeEq::<
3044 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3045 >(_) => {}
3046 }
3047 }
3048 #[automatically_derived]
3049 #[doc(hidden)]
3050 impl ::core::convert::From<minDepositAmountReturn>
3051 for UnderlyingRustTuple<'_> {
3052 fn from(value: minDepositAmountReturn) -> Self {
3053 (value._0,)
3054 }
3055 }
3056 #[automatically_derived]
3057 #[doc(hidden)]
3058 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3059 for minDepositAmountReturn {
3060 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3061 Self { _0: tuple.0 }
3062 }
3063 }
3064 }
3065 #[automatically_derived]
3066 impl alloy_sol_types::SolCall for minDepositAmountCall {
3067 type Parameters<'a> = ();
3068 type Token<'a> = <Self::Parameters<
3069 'a,
3070 > as alloy_sol_types::SolType>::Token<'a>;
3071 type Return = minDepositAmountReturn;
3072 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3073 type ReturnToken<'a> = <Self::ReturnTuple<
3074 'a,
3075 > as alloy_sol_types::SolType>::Token<'a>;
3076 const SIGNATURE: &'static str = "minDepositAmount()";
3077 const SELECTOR: [u8; 4] = [100u8, 80u8, 6u8, 202u8];
3078 #[inline]
3079 fn new<'a>(
3080 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3081 ) -> Self {
3082 tuple.into()
3083 }
3084 #[inline]
3085 fn tokenize(&self) -> Self::Token<'_> {
3086 ()
3087 }
3088 #[inline]
3089 fn abi_decode_returns(
3090 data: &[u8],
3091 validate: bool,
3092 ) -> alloy_sol_types::Result<Self::Return> {
3093 <Self::ReturnTuple<
3094 '_,
3095 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3096 .map(Into::into)
3097 }
3098 }
3099 };
3100 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3101 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3106 #[derive(Clone)]
3107 pub struct ownerCall {}
3108 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3109 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3111 #[derive(Clone)]
3112 pub struct ownerReturn {
3113 #[allow(missing_docs)]
3114 pub _0: alloy::sol_types::private::Address,
3115 }
3116 #[allow(
3117 non_camel_case_types,
3118 non_snake_case,
3119 clippy::pub_underscore_fields,
3120 clippy::style
3121 )]
3122 const _: () = {
3123 use alloy::sol_types as alloy_sol_types;
3124 {
3125 #[doc(hidden)]
3126 type UnderlyingSolTuple<'a> = ();
3127 #[doc(hidden)]
3128 type UnderlyingRustTuple<'a> = ();
3129 #[cfg(test)]
3130 #[allow(dead_code, unreachable_patterns)]
3131 fn _type_assertion(
3132 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3133 ) {
3134 match _t {
3135 alloy_sol_types::private::AssertTypeEq::<
3136 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3137 >(_) => {}
3138 }
3139 }
3140 #[automatically_derived]
3141 #[doc(hidden)]
3142 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
3143 fn from(value: ownerCall) -> Self {
3144 ()
3145 }
3146 }
3147 #[automatically_derived]
3148 #[doc(hidden)]
3149 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
3150 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3151 Self {}
3152 }
3153 }
3154 }
3155 {
3156 #[doc(hidden)]
3157 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3158 #[doc(hidden)]
3159 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3160 #[cfg(test)]
3161 #[allow(dead_code, unreachable_patterns)]
3162 fn _type_assertion(
3163 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3164 ) {
3165 match _t {
3166 alloy_sol_types::private::AssertTypeEq::<
3167 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3168 >(_) => {}
3169 }
3170 }
3171 #[automatically_derived]
3172 #[doc(hidden)]
3173 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
3174 fn from(value: ownerReturn) -> Self {
3175 (value._0,)
3176 }
3177 }
3178 #[automatically_derived]
3179 #[doc(hidden)]
3180 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
3181 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3182 Self { _0: tuple.0 }
3183 }
3184 }
3185 }
3186 #[automatically_derived]
3187 impl alloy_sol_types::SolCall for ownerCall {
3188 type Parameters<'a> = ();
3189 type Token<'a> = <Self::Parameters<
3190 'a,
3191 > as alloy_sol_types::SolType>::Token<'a>;
3192 type Return = ownerReturn;
3193 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3194 type ReturnToken<'a> = <Self::ReturnTuple<
3195 'a,
3196 > as alloy_sol_types::SolType>::Token<'a>;
3197 const SIGNATURE: &'static str = "owner()";
3198 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
3199 #[inline]
3200 fn new<'a>(
3201 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3202 ) -> Self {
3203 tuple.into()
3204 }
3205 #[inline]
3206 fn tokenize(&self) -> Self::Token<'_> {
3207 ()
3208 }
3209 #[inline]
3210 fn abi_decode_returns(
3211 data: &[u8],
3212 validate: bool,
3213 ) -> alloy_sol_types::Result<Self::Return> {
3214 <Self::ReturnTuple<
3215 '_,
3216 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3217 .map(Into::into)
3218 }
3219 }
3220 };
3221 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3222 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3227 #[derive(Clone)]
3228 pub struct proxiableUUIDCall {}
3229 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3230 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3232 #[derive(Clone)]
3233 pub struct proxiableUUIDReturn {
3234 #[allow(missing_docs)]
3235 pub _0: alloy::sol_types::private::FixedBytes<32>,
3236 }
3237 #[allow(
3238 non_camel_case_types,
3239 non_snake_case,
3240 clippy::pub_underscore_fields,
3241 clippy::style
3242 )]
3243 const _: () = {
3244 use alloy::sol_types as alloy_sol_types;
3245 {
3246 #[doc(hidden)]
3247 type UnderlyingSolTuple<'a> = ();
3248 #[doc(hidden)]
3249 type UnderlyingRustTuple<'a> = ();
3250 #[cfg(test)]
3251 #[allow(dead_code, unreachable_patterns)]
3252 fn _type_assertion(
3253 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3254 ) {
3255 match _t {
3256 alloy_sol_types::private::AssertTypeEq::<
3257 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3258 >(_) => {}
3259 }
3260 }
3261 #[automatically_derived]
3262 #[doc(hidden)]
3263 impl ::core::convert::From<proxiableUUIDCall> for UnderlyingRustTuple<'_> {
3264 fn from(value: proxiableUUIDCall) -> Self {
3265 ()
3266 }
3267 }
3268 #[automatically_derived]
3269 #[doc(hidden)]
3270 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDCall {
3271 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3272 Self {}
3273 }
3274 }
3275 }
3276 {
3277 #[doc(hidden)]
3278 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3279 #[doc(hidden)]
3280 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3281 #[cfg(test)]
3282 #[allow(dead_code, unreachable_patterns)]
3283 fn _type_assertion(
3284 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3285 ) {
3286 match _t {
3287 alloy_sol_types::private::AssertTypeEq::<
3288 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3289 >(_) => {}
3290 }
3291 }
3292 #[automatically_derived]
3293 #[doc(hidden)]
3294 impl ::core::convert::From<proxiableUUIDReturn> for UnderlyingRustTuple<'_> {
3295 fn from(value: proxiableUUIDReturn) -> Self {
3296 (value._0,)
3297 }
3298 }
3299 #[automatically_derived]
3300 #[doc(hidden)]
3301 impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDReturn {
3302 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3303 Self { _0: tuple.0 }
3304 }
3305 }
3306 }
3307 #[automatically_derived]
3308 impl alloy_sol_types::SolCall for proxiableUUIDCall {
3309 type Parameters<'a> = ();
3310 type Token<'a> = <Self::Parameters<
3311 'a,
3312 > as alloy_sol_types::SolType>::Token<'a>;
3313 type Return = proxiableUUIDReturn;
3314 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3315 type ReturnToken<'a> = <Self::ReturnTuple<
3316 'a,
3317 > as alloy_sol_types::SolType>::Token<'a>;
3318 const SIGNATURE: &'static str = "proxiableUUID()";
3319 const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8];
3320 #[inline]
3321 fn new<'a>(
3322 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3323 ) -> Self {
3324 tuple.into()
3325 }
3326 #[inline]
3327 fn tokenize(&self) -> Self::Token<'_> {
3328 ()
3329 }
3330 #[inline]
3331 fn abi_decode_returns(
3332 data: &[u8],
3333 validate: bool,
3334 ) -> alloy_sol_types::Result<Self::Return> {
3335 <Self::ReturnTuple<
3336 '_,
3337 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3338 .map(Into::into)
3339 }
3340 }
3341 };
3342 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3343 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3348 #[derive(Clone)]
3349 pub struct renounceOwnershipCall {}
3350 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3352 #[derive(Clone)]
3353 pub struct renounceOwnershipReturn {}
3354 #[allow(
3355 non_camel_case_types,
3356 non_snake_case,
3357 clippy::pub_underscore_fields,
3358 clippy::style
3359 )]
3360 const _: () = {
3361 use alloy::sol_types as alloy_sol_types;
3362 {
3363 #[doc(hidden)]
3364 type UnderlyingSolTuple<'a> = ();
3365 #[doc(hidden)]
3366 type UnderlyingRustTuple<'a> = ();
3367 #[cfg(test)]
3368 #[allow(dead_code, unreachable_patterns)]
3369 fn _type_assertion(
3370 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3371 ) {
3372 match _t {
3373 alloy_sol_types::private::AssertTypeEq::<
3374 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3375 >(_) => {}
3376 }
3377 }
3378 #[automatically_derived]
3379 #[doc(hidden)]
3380 impl ::core::convert::From<renounceOwnershipCall>
3381 for UnderlyingRustTuple<'_> {
3382 fn from(value: renounceOwnershipCall) -> Self {
3383 ()
3384 }
3385 }
3386 #[automatically_derived]
3387 #[doc(hidden)]
3388 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3389 for renounceOwnershipCall {
3390 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3391 Self {}
3392 }
3393 }
3394 }
3395 {
3396 #[doc(hidden)]
3397 type UnderlyingSolTuple<'a> = ();
3398 #[doc(hidden)]
3399 type UnderlyingRustTuple<'a> = ();
3400 #[cfg(test)]
3401 #[allow(dead_code, unreachable_patterns)]
3402 fn _type_assertion(
3403 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3404 ) {
3405 match _t {
3406 alloy_sol_types::private::AssertTypeEq::<
3407 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3408 >(_) => {}
3409 }
3410 }
3411 #[automatically_derived]
3412 #[doc(hidden)]
3413 impl ::core::convert::From<renounceOwnershipReturn>
3414 for UnderlyingRustTuple<'_> {
3415 fn from(value: renounceOwnershipReturn) -> Self {
3416 ()
3417 }
3418 }
3419 #[automatically_derived]
3420 #[doc(hidden)]
3421 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3422 for renounceOwnershipReturn {
3423 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3424 Self {}
3425 }
3426 }
3427 }
3428 #[automatically_derived]
3429 impl alloy_sol_types::SolCall for renounceOwnershipCall {
3430 type Parameters<'a> = ();
3431 type Token<'a> = <Self::Parameters<
3432 'a,
3433 > as alloy_sol_types::SolType>::Token<'a>;
3434 type Return = renounceOwnershipReturn;
3435 type ReturnTuple<'a> = ();
3436 type ReturnToken<'a> = <Self::ReturnTuple<
3437 'a,
3438 > as alloy_sol_types::SolType>::Token<'a>;
3439 const SIGNATURE: &'static str = "renounceOwnership()";
3440 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
3441 #[inline]
3442 fn new<'a>(
3443 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3444 ) -> Self {
3445 tuple.into()
3446 }
3447 #[inline]
3448 fn tokenize(&self) -> Self::Token<'_> {
3449 ()
3450 }
3451 #[inline]
3452 fn abi_decode_returns(
3453 data: &[u8],
3454 validate: bool,
3455 ) -> alloy_sol_types::Result<Self::Return> {
3456 <Self::ReturnTuple<
3457 '_,
3458 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3459 .map(Into::into)
3460 }
3461 }
3462 };
3463 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3464 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3469 #[derive(Clone)]
3470 pub struct transferOwnershipCall {
3471 #[allow(missing_docs)]
3472 pub newOwner: alloy::sol_types::private::Address,
3473 }
3474 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3476 #[derive(Clone)]
3477 pub struct transferOwnershipReturn {}
3478 #[allow(
3479 non_camel_case_types,
3480 non_snake_case,
3481 clippy::pub_underscore_fields,
3482 clippy::style
3483 )]
3484 const _: () = {
3485 use alloy::sol_types as alloy_sol_types;
3486 {
3487 #[doc(hidden)]
3488 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3489 #[doc(hidden)]
3490 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3491 #[cfg(test)]
3492 #[allow(dead_code, unreachable_patterns)]
3493 fn _type_assertion(
3494 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3495 ) {
3496 match _t {
3497 alloy_sol_types::private::AssertTypeEq::<
3498 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3499 >(_) => {}
3500 }
3501 }
3502 #[automatically_derived]
3503 #[doc(hidden)]
3504 impl ::core::convert::From<transferOwnershipCall>
3505 for UnderlyingRustTuple<'_> {
3506 fn from(value: transferOwnershipCall) -> Self {
3507 (value.newOwner,)
3508 }
3509 }
3510 #[automatically_derived]
3511 #[doc(hidden)]
3512 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3513 for transferOwnershipCall {
3514 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3515 Self { newOwner: tuple.0 }
3516 }
3517 }
3518 }
3519 {
3520 #[doc(hidden)]
3521 type UnderlyingSolTuple<'a> = ();
3522 #[doc(hidden)]
3523 type UnderlyingRustTuple<'a> = ();
3524 #[cfg(test)]
3525 #[allow(dead_code, unreachable_patterns)]
3526 fn _type_assertion(
3527 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3528 ) {
3529 match _t {
3530 alloy_sol_types::private::AssertTypeEq::<
3531 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3532 >(_) => {}
3533 }
3534 }
3535 #[automatically_derived]
3536 #[doc(hidden)]
3537 impl ::core::convert::From<transferOwnershipReturn>
3538 for UnderlyingRustTuple<'_> {
3539 fn from(value: transferOwnershipReturn) -> Self {
3540 ()
3541 }
3542 }
3543 #[automatically_derived]
3544 #[doc(hidden)]
3545 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3546 for transferOwnershipReturn {
3547 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3548 Self {}
3549 }
3550 }
3551 }
3552 #[automatically_derived]
3553 impl alloy_sol_types::SolCall for transferOwnershipCall {
3554 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3555 type Token<'a> = <Self::Parameters<
3556 'a,
3557 > as alloy_sol_types::SolType>::Token<'a>;
3558 type Return = transferOwnershipReturn;
3559 type ReturnTuple<'a> = ();
3560 type ReturnToken<'a> = <Self::ReturnTuple<
3561 'a,
3562 > as alloy_sol_types::SolType>::Token<'a>;
3563 const SIGNATURE: &'static str = "transferOwnership(address)";
3564 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
3565 #[inline]
3566 fn new<'a>(
3567 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3568 ) -> Self {
3569 tuple.into()
3570 }
3571 #[inline]
3572 fn tokenize(&self) -> Self::Token<'_> {
3573 (
3574 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3575 &self.newOwner,
3576 ),
3577 )
3578 }
3579 #[inline]
3580 fn abi_decode_returns(
3581 data: &[u8],
3582 validate: bool,
3583 ) -> alloy_sol_types::Result<Self::Return> {
3584 <Self::ReturnTuple<
3585 '_,
3586 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3587 .map(Into::into)
3588 }
3589 }
3590 };
3591 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3592 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3597 #[derive(Clone)]
3598 pub struct upgradeToAndCallCall {
3599 #[allow(missing_docs)]
3600 pub newImplementation: alloy::sol_types::private::Address,
3601 #[allow(missing_docs)]
3602 pub data: alloy::sol_types::private::Bytes,
3603 }
3604 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3606 #[derive(Clone)]
3607 pub struct upgradeToAndCallReturn {}
3608 #[allow(
3609 non_camel_case_types,
3610 non_snake_case,
3611 clippy::pub_underscore_fields,
3612 clippy::style
3613 )]
3614 const _: () = {
3615 use alloy::sol_types as alloy_sol_types;
3616 {
3617 #[doc(hidden)]
3618 type UnderlyingSolTuple<'a> = (
3619 alloy::sol_types::sol_data::Address,
3620 alloy::sol_types::sol_data::Bytes,
3621 );
3622 #[doc(hidden)]
3623 type UnderlyingRustTuple<'a> = (
3624 alloy::sol_types::private::Address,
3625 alloy::sol_types::private::Bytes,
3626 );
3627 #[cfg(test)]
3628 #[allow(dead_code, unreachable_patterns)]
3629 fn _type_assertion(
3630 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3631 ) {
3632 match _t {
3633 alloy_sol_types::private::AssertTypeEq::<
3634 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3635 >(_) => {}
3636 }
3637 }
3638 #[automatically_derived]
3639 #[doc(hidden)]
3640 impl ::core::convert::From<upgradeToAndCallCall>
3641 for UnderlyingRustTuple<'_> {
3642 fn from(value: upgradeToAndCallCall) -> Self {
3643 (value.newImplementation, value.data)
3644 }
3645 }
3646 #[automatically_derived]
3647 #[doc(hidden)]
3648 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3649 for upgradeToAndCallCall {
3650 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3651 Self {
3652 newImplementation: tuple.0,
3653 data: tuple.1,
3654 }
3655 }
3656 }
3657 }
3658 {
3659 #[doc(hidden)]
3660 type UnderlyingSolTuple<'a> = ();
3661 #[doc(hidden)]
3662 type UnderlyingRustTuple<'a> = ();
3663 #[cfg(test)]
3664 #[allow(dead_code, unreachable_patterns)]
3665 fn _type_assertion(
3666 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3667 ) {
3668 match _t {
3669 alloy_sol_types::private::AssertTypeEq::<
3670 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3671 >(_) => {}
3672 }
3673 }
3674 #[automatically_derived]
3675 #[doc(hidden)]
3676 impl ::core::convert::From<upgradeToAndCallReturn>
3677 for UnderlyingRustTuple<'_> {
3678 fn from(value: upgradeToAndCallReturn) -> Self {
3679 ()
3680 }
3681 }
3682 #[automatically_derived]
3683 #[doc(hidden)]
3684 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3685 for upgradeToAndCallReturn {
3686 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3687 Self {}
3688 }
3689 }
3690 }
3691 #[automatically_derived]
3692 impl alloy_sol_types::SolCall for upgradeToAndCallCall {
3693 type Parameters<'a> = (
3694 alloy::sol_types::sol_data::Address,
3695 alloy::sol_types::sol_data::Bytes,
3696 );
3697 type Token<'a> = <Self::Parameters<
3698 'a,
3699 > as alloy_sol_types::SolType>::Token<'a>;
3700 type Return = upgradeToAndCallReturn;
3701 type ReturnTuple<'a> = ();
3702 type ReturnToken<'a> = <Self::ReturnTuple<
3703 'a,
3704 > as alloy_sol_types::SolType>::Token<'a>;
3705 const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)";
3706 const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8];
3707 #[inline]
3708 fn new<'a>(
3709 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3710 ) -> Self {
3711 tuple.into()
3712 }
3713 #[inline]
3714 fn tokenize(&self) -> Self::Token<'_> {
3715 (
3716 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3717 &self.newImplementation,
3718 ),
3719 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
3720 &self.data,
3721 ),
3722 )
3723 }
3724 #[inline]
3725 fn abi_decode_returns(
3726 data: &[u8],
3727 validate: bool,
3728 ) -> alloy_sol_types::Result<Self::Return> {
3729 <Self::ReturnTuple<
3730 '_,
3731 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3732 .map(Into::into)
3733 }
3734 }
3735 };
3736 #[derive()]
3738 pub enum FeeContractCalls {
3739 #[allow(missing_docs)]
3740 UPGRADE_INTERFACE_VERSION(UPGRADE_INTERFACE_VERSIONCall),
3741 #[allow(missing_docs)]
3742 balances(balancesCall),
3743 #[allow(missing_docs)]
3744 deposit(depositCall),
3745 #[allow(missing_docs)]
3746 getVersion(getVersionCall),
3747 #[allow(missing_docs)]
3748 initialize(initializeCall),
3749 #[allow(missing_docs)]
3750 maxDepositAmount(maxDepositAmountCall),
3751 #[allow(missing_docs)]
3752 minDepositAmount(minDepositAmountCall),
3753 #[allow(missing_docs)]
3754 owner(ownerCall),
3755 #[allow(missing_docs)]
3756 proxiableUUID(proxiableUUIDCall),
3757 #[allow(missing_docs)]
3758 renounceOwnership(renounceOwnershipCall),
3759 #[allow(missing_docs)]
3760 transferOwnership(transferOwnershipCall),
3761 #[allow(missing_docs)]
3762 upgradeToAndCall(upgradeToAndCallCall),
3763 }
3764 #[automatically_derived]
3765 impl FeeContractCalls {
3766 pub const SELECTORS: &'static [[u8; 4usize]] = &[
3773 [13u8, 142u8, 110u8, 44u8],
3774 [39u8, 226u8, 53u8, 227u8],
3775 [79u8, 30u8, 242u8, 134u8],
3776 [82u8, 209u8, 144u8, 45u8],
3777 [100u8, 80u8, 6u8, 202u8],
3778 [113u8, 80u8, 24u8, 166u8],
3779 [141u8, 165u8, 203u8, 91u8],
3780 [142u8, 216u8, 50u8, 113u8],
3781 [173u8, 60u8, 177u8, 204u8],
3782 [196u8, 214u8, 109u8, 232u8],
3783 [242u8, 253u8, 227u8, 139u8],
3784 [243u8, 64u8, 250u8, 1u8],
3785 ];
3786 }
3787 #[automatically_derived]
3788 impl alloy_sol_types::SolInterface for FeeContractCalls {
3789 const NAME: &'static str = "FeeContractCalls";
3790 const MIN_DATA_LENGTH: usize = 0usize;
3791 const COUNT: usize = 12usize;
3792 #[inline]
3793 fn selector(&self) -> [u8; 4] {
3794 match self {
3795 Self::UPGRADE_INTERFACE_VERSION(_) => {
3796 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SELECTOR
3797 }
3798 Self::balances(_) => <balancesCall as alloy_sol_types::SolCall>::SELECTOR,
3799 Self::deposit(_) => <depositCall as alloy_sol_types::SolCall>::SELECTOR,
3800 Self::getVersion(_) => {
3801 <getVersionCall as alloy_sol_types::SolCall>::SELECTOR
3802 }
3803 Self::initialize(_) => {
3804 <initializeCall as alloy_sol_types::SolCall>::SELECTOR
3805 }
3806 Self::maxDepositAmount(_) => {
3807 <maxDepositAmountCall as alloy_sol_types::SolCall>::SELECTOR
3808 }
3809 Self::minDepositAmount(_) => {
3810 <minDepositAmountCall as alloy_sol_types::SolCall>::SELECTOR
3811 }
3812 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
3813 Self::proxiableUUID(_) => {
3814 <proxiableUUIDCall as alloy_sol_types::SolCall>::SELECTOR
3815 }
3816 Self::renounceOwnership(_) => {
3817 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
3818 }
3819 Self::transferOwnership(_) => {
3820 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
3821 }
3822 Self::upgradeToAndCall(_) => {
3823 <upgradeToAndCallCall as alloy_sol_types::SolCall>::SELECTOR
3824 }
3825 }
3826 }
3827 #[inline]
3828 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
3829 Self::SELECTORS.get(i).copied()
3830 }
3831 #[inline]
3832 fn valid_selector(selector: [u8; 4]) -> bool {
3833 Self::SELECTORS.binary_search(&selector).is_ok()
3834 }
3835 #[inline]
3836 #[allow(non_snake_case)]
3837 fn abi_decode_raw(
3838 selector: [u8; 4],
3839 data: &[u8],
3840 validate: bool,
3841 ) -> alloy_sol_types::Result<Self> {
3842 static DECODE_SHIMS: &[fn(
3843 &[u8],
3844 bool,
3845 ) -> alloy_sol_types::Result<FeeContractCalls>] = &[
3846 {
3847 fn getVersion(
3848 data: &[u8],
3849 validate: bool,
3850 ) -> alloy_sol_types::Result<FeeContractCalls> {
3851 <getVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(
3852 data,
3853 validate,
3854 )
3855 .map(FeeContractCalls::getVersion)
3856 }
3857 getVersion
3858 },
3859 {
3860 fn balances(
3861 data: &[u8],
3862 validate: bool,
3863 ) -> alloy_sol_types::Result<FeeContractCalls> {
3864 <balancesCall as alloy_sol_types::SolCall>::abi_decode_raw(
3865 data,
3866 validate,
3867 )
3868 .map(FeeContractCalls::balances)
3869 }
3870 balances
3871 },
3872 {
3873 fn upgradeToAndCall(
3874 data: &[u8],
3875 validate: bool,
3876 ) -> alloy_sol_types::Result<FeeContractCalls> {
3877 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(
3878 data,
3879 validate,
3880 )
3881 .map(FeeContractCalls::upgradeToAndCall)
3882 }
3883 upgradeToAndCall
3884 },
3885 {
3886 fn proxiableUUID(
3887 data: &[u8],
3888 validate: bool,
3889 ) -> alloy_sol_types::Result<FeeContractCalls> {
3890 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
3891 data,
3892 validate,
3893 )
3894 .map(FeeContractCalls::proxiableUUID)
3895 }
3896 proxiableUUID
3897 },
3898 {
3899 fn minDepositAmount(
3900 data: &[u8],
3901 validate: bool,
3902 ) -> alloy_sol_types::Result<FeeContractCalls> {
3903 <minDepositAmountCall as alloy_sol_types::SolCall>::abi_decode_raw(
3904 data,
3905 validate,
3906 )
3907 .map(FeeContractCalls::minDepositAmount)
3908 }
3909 minDepositAmount
3910 },
3911 {
3912 fn renounceOwnership(
3913 data: &[u8],
3914 validate: bool,
3915 ) -> alloy_sol_types::Result<FeeContractCalls> {
3916 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
3917 data,
3918 validate,
3919 )
3920 .map(FeeContractCalls::renounceOwnership)
3921 }
3922 renounceOwnership
3923 },
3924 {
3925 fn owner(
3926 data: &[u8],
3927 validate: bool,
3928 ) -> alloy_sol_types::Result<FeeContractCalls> {
3929 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(
3930 data,
3931 validate,
3932 )
3933 .map(FeeContractCalls::owner)
3934 }
3935 owner
3936 },
3937 {
3938 fn maxDepositAmount(
3939 data: &[u8],
3940 validate: bool,
3941 ) -> alloy_sol_types::Result<FeeContractCalls> {
3942 <maxDepositAmountCall as alloy_sol_types::SolCall>::abi_decode_raw(
3943 data,
3944 validate,
3945 )
3946 .map(FeeContractCalls::maxDepositAmount)
3947 }
3948 maxDepositAmount
3949 },
3950 {
3951 fn UPGRADE_INTERFACE_VERSION(
3952 data: &[u8],
3953 validate: bool,
3954 ) -> alloy_sol_types::Result<FeeContractCalls> {
3955 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(
3956 data,
3957 validate,
3958 )
3959 .map(FeeContractCalls::UPGRADE_INTERFACE_VERSION)
3960 }
3961 UPGRADE_INTERFACE_VERSION
3962 },
3963 {
3964 fn initialize(
3965 data: &[u8],
3966 validate: bool,
3967 ) -> alloy_sol_types::Result<FeeContractCalls> {
3968 <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
3969 data,
3970 validate,
3971 )
3972 .map(FeeContractCalls::initialize)
3973 }
3974 initialize
3975 },
3976 {
3977 fn transferOwnership(
3978 data: &[u8],
3979 validate: bool,
3980 ) -> alloy_sol_types::Result<FeeContractCalls> {
3981 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
3982 data,
3983 validate,
3984 )
3985 .map(FeeContractCalls::transferOwnership)
3986 }
3987 transferOwnership
3988 },
3989 {
3990 fn deposit(
3991 data: &[u8],
3992 validate: bool,
3993 ) -> alloy_sol_types::Result<FeeContractCalls> {
3994 <depositCall as alloy_sol_types::SolCall>::abi_decode_raw(
3995 data,
3996 validate,
3997 )
3998 .map(FeeContractCalls::deposit)
3999 }
4000 deposit
4001 },
4002 ];
4003 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4004 return Err(
4005 alloy_sol_types::Error::unknown_selector(
4006 <Self as alloy_sol_types::SolInterface>::NAME,
4007 selector,
4008 ),
4009 );
4010 };
4011 DECODE_SHIMS[idx](data, validate)
4012 }
4013 #[inline]
4014 fn abi_encoded_size(&self) -> usize {
4015 match self {
4016 Self::UPGRADE_INTERFACE_VERSION(inner) => {
4017 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
4018 inner,
4019 )
4020 }
4021 Self::balances(inner) => {
4022 <balancesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4023 }
4024 Self::deposit(inner) => {
4025 <depositCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4026 }
4027 Self::getVersion(inner) => {
4028 <getVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4029 }
4030 Self::initialize(inner) => {
4031 <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4032 }
4033 Self::maxDepositAmount(inner) => {
4034 <maxDepositAmountCall as alloy_sol_types::SolCall>::abi_encoded_size(
4035 inner,
4036 )
4037 }
4038 Self::minDepositAmount(inner) => {
4039 <minDepositAmountCall as alloy_sol_types::SolCall>::abi_encoded_size(
4040 inner,
4041 )
4042 }
4043 Self::owner(inner) => {
4044 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4045 }
4046 Self::proxiableUUID(inner) => {
4047 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encoded_size(
4048 inner,
4049 )
4050 }
4051 Self::renounceOwnership(inner) => {
4052 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
4053 inner,
4054 )
4055 }
4056 Self::transferOwnership(inner) => {
4057 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
4058 inner,
4059 )
4060 }
4061 Self::upgradeToAndCall(inner) => {
4062 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(
4063 inner,
4064 )
4065 }
4066 }
4067 }
4068 #[inline]
4069 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4070 match self {
4071 Self::UPGRADE_INTERFACE_VERSION(inner) => {
4072 <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
4073 inner,
4074 out,
4075 )
4076 }
4077 Self::balances(inner) => {
4078 <balancesCall as alloy_sol_types::SolCall>::abi_encode_raw(
4079 inner,
4080 out,
4081 )
4082 }
4083 Self::deposit(inner) => {
4084 <depositCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4085 }
4086 Self::getVersion(inner) => {
4087 <getVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
4088 inner,
4089 out,
4090 )
4091 }
4092 Self::initialize(inner) => {
4093 <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
4094 inner,
4095 out,
4096 )
4097 }
4098 Self::maxDepositAmount(inner) => {
4099 <maxDepositAmountCall as alloy_sol_types::SolCall>::abi_encode_raw(
4100 inner,
4101 out,
4102 )
4103 }
4104 Self::minDepositAmount(inner) => {
4105 <minDepositAmountCall as alloy_sol_types::SolCall>::abi_encode_raw(
4106 inner,
4107 out,
4108 )
4109 }
4110 Self::owner(inner) => {
4111 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4112 }
4113 Self::proxiableUUID(inner) => {
4114 <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encode_raw(
4115 inner,
4116 out,
4117 )
4118 }
4119 Self::renounceOwnership(inner) => {
4120 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
4121 inner,
4122 out,
4123 )
4124 }
4125 Self::transferOwnership(inner) => {
4126 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
4127 inner,
4128 out,
4129 )
4130 }
4131 Self::upgradeToAndCall(inner) => {
4132 <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(
4133 inner,
4134 out,
4135 )
4136 }
4137 }
4138 }
4139 }
4140 #[derive(Debug, PartialEq, Eq, Hash)]
4142 pub enum FeeContractErrors {
4143 #[allow(missing_docs)]
4144 AddressEmptyCode(AddressEmptyCode),
4145 #[allow(missing_docs)]
4146 DepositTooLarge(DepositTooLarge),
4147 #[allow(missing_docs)]
4148 DepositTooSmall(DepositTooSmall),
4149 #[allow(missing_docs)]
4150 ERC1967InvalidImplementation(ERC1967InvalidImplementation),
4151 #[allow(missing_docs)]
4152 ERC1967NonPayable(ERC1967NonPayable),
4153 #[allow(missing_docs)]
4154 FailedInnerCall(FailedInnerCall),
4155 #[allow(missing_docs)]
4156 FunctionDoesNotExist(FunctionDoesNotExist),
4157 #[allow(missing_docs)]
4158 InvalidInitialization(InvalidInitialization),
4159 #[allow(missing_docs)]
4160 InvalidUserAddress(InvalidUserAddress),
4161 #[allow(missing_docs)]
4162 NoFunctionCalled(NoFunctionCalled),
4163 #[allow(missing_docs)]
4164 NotInitializing(NotInitializing),
4165 #[allow(missing_docs)]
4166 OwnableInvalidOwner(OwnableInvalidOwner),
4167 #[allow(missing_docs)]
4168 OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
4169 #[allow(missing_docs)]
4170 UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext),
4171 #[allow(missing_docs)]
4172 UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID),
4173 }
4174 #[automatically_derived]
4175 impl FeeContractErrors {
4176 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4183 [17u8, 140u8, 218u8, 167u8],
4184 [20u8, 37u8, 234u8, 66u8],
4185 [30u8, 79u8, 189u8, 247u8],
4186 [76u8, 156u8, 140u8, 227u8],
4187 [107u8, 164u8, 161u8, 199u8],
4188 [112u8, 43u8, 61u8, 144u8],
4189 [153u8, 150u8, 179u8, 21u8],
4190 [169u8, 173u8, 98u8, 248u8],
4191 [170u8, 29u8, 73u8, 164u8],
4192 [179u8, 152u8, 151u8, 159u8],
4193 [188u8, 142u8, 202u8, 27u8],
4194 [197u8, 109u8, 70u8, 211u8],
4195 [215u8, 230u8, 188u8, 248u8],
4196 [224u8, 124u8, 141u8, 186u8],
4197 [249u8, 46u8, 232u8, 169u8],
4198 ];
4199 }
4200 #[automatically_derived]
4201 impl alloy_sol_types::SolInterface for FeeContractErrors {
4202 const NAME: &'static str = "FeeContractErrors";
4203 const MIN_DATA_LENGTH: usize = 0usize;
4204 const COUNT: usize = 15usize;
4205 #[inline]
4206 fn selector(&self) -> [u8; 4] {
4207 match self {
4208 Self::AddressEmptyCode(_) => {
4209 <AddressEmptyCode as alloy_sol_types::SolError>::SELECTOR
4210 }
4211 Self::DepositTooLarge(_) => {
4212 <DepositTooLarge as alloy_sol_types::SolError>::SELECTOR
4213 }
4214 Self::DepositTooSmall(_) => {
4215 <DepositTooSmall as alloy_sol_types::SolError>::SELECTOR
4216 }
4217 Self::ERC1967InvalidImplementation(_) => {
4218 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SELECTOR
4219 }
4220 Self::ERC1967NonPayable(_) => {
4221 <ERC1967NonPayable as alloy_sol_types::SolError>::SELECTOR
4222 }
4223 Self::FailedInnerCall(_) => {
4224 <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
4225 }
4226 Self::FunctionDoesNotExist(_) => {
4227 <FunctionDoesNotExist as alloy_sol_types::SolError>::SELECTOR
4228 }
4229 Self::InvalidInitialization(_) => {
4230 <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
4231 }
4232 Self::InvalidUserAddress(_) => {
4233 <InvalidUserAddress as alloy_sol_types::SolError>::SELECTOR
4234 }
4235 Self::NoFunctionCalled(_) => {
4236 <NoFunctionCalled as alloy_sol_types::SolError>::SELECTOR
4237 }
4238 Self::NotInitializing(_) => {
4239 <NotInitializing as alloy_sol_types::SolError>::SELECTOR
4240 }
4241 Self::OwnableInvalidOwner(_) => {
4242 <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
4243 }
4244 Self::OwnableUnauthorizedAccount(_) => {
4245 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
4246 }
4247 Self::UUPSUnauthorizedCallContext(_) => {
4248 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SELECTOR
4249 }
4250 Self::UUPSUnsupportedProxiableUUID(_) => {
4251 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SELECTOR
4252 }
4253 }
4254 }
4255 #[inline]
4256 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4257 Self::SELECTORS.get(i).copied()
4258 }
4259 #[inline]
4260 fn valid_selector(selector: [u8; 4]) -> bool {
4261 Self::SELECTORS.binary_search(&selector).is_ok()
4262 }
4263 #[inline]
4264 #[allow(non_snake_case)]
4265 fn abi_decode_raw(
4266 selector: [u8; 4],
4267 data: &[u8],
4268 validate: bool,
4269 ) -> alloy_sol_types::Result<Self> {
4270 static DECODE_SHIMS: &[fn(
4271 &[u8],
4272 bool,
4273 ) -> alloy_sol_types::Result<FeeContractErrors>] = &[
4274 {
4275 fn OwnableUnauthorizedAccount(
4276 data: &[u8],
4277 validate: bool,
4278 ) -> alloy_sol_types::Result<FeeContractErrors> {
4279 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
4280 data,
4281 validate,
4282 )
4283 .map(FeeContractErrors::OwnableUnauthorizedAccount)
4284 }
4285 OwnableUnauthorizedAccount
4286 },
4287 {
4288 fn FailedInnerCall(
4289 data: &[u8],
4290 validate: bool,
4291 ) -> alloy_sol_types::Result<FeeContractErrors> {
4292 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(
4293 data,
4294 validate,
4295 )
4296 .map(FeeContractErrors::FailedInnerCall)
4297 }
4298 FailedInnerCall
4299 },
4300 {
4301 fn OwnableInvalidOwner(
4302 data: &[u8],
4303 validate: bool,
4304 ) -> alloy_sol_types::Result<FeeContractErrors> {
4305 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
4306 data,
4307 validate,
4308 )
4309 .map(FeeContractErrors::OwnableInvalidOwner)
4310 }
4311 OwnableInvalidOwner
4312 },
4313 {
4314 fn ERC1967InvalidImplementation(
4315 data: &[u8],
4316 validate: bool,
4317 ) -> alloy_sol_types::Result<FeeContractErrors> {
4318 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_decode_raw(
4319 data,
4320 validate,
4321 )
4322 .map(FeeContractErrors::ERC1967InvalidImplementation)
4323 }
4324 ERC1967InvalidImplementation
4325 },
4326 {
4327 fn DepositTooSmall(
4328 data: &[u8],
4329 validate: bool,
4330 ) -> alloy_sol_types::Result<FeeContractErrors> {
4331 <DepositTooSmall as alloy_sol_types::SolError>::abi_decode_raw(
4332 data,
4333 validate,
4334 )
4335 .map(FeeContractErrors::DepositTooSmall)
4336 }
4337 DepositTooSmall
4338 },
4339 {
4340 fn InvalidUserAddress(
4341 data: &[u8],
4342 validate: bool,
4343 ) -> alloy_sol_types::Result<FeeContractErrors> {
4344 <InvalidUserAddress as alloy_sol_types::SolError>::abi_decode_raw(
4345 data,
4346 validate,
4347 )
4348 .map(FeeContractErrors::InvalidUserAddress)
4349 }
4350 InvalidUserAddress
4351 },
4352 {
4353 fn AddressEmptyCode(
4354 data: &[u8],
4355 validate: bool,
4356 ) -> alloy_sol_types::Result<FeeContractErrors> {
4357 <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw(
4358 data,
4359 validate,
4360 )
4361 .map(FeeContractErrors::AddressEmptyCode)
4362 }
4363 AddressEmptyCode
4364 },
4365 {
4366 fn FunctionDoesNotExist(
4367 data: &[u8],
4368 validate: bool,
4369 ) -> alloy_sol_types::Result<FeeContractErrors> {
4370 <FunctionDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw(
4371 data,
4372 validate,
4373 )
4374 .map(FeeContractErrors::FunctionDoesNotExist)
4375 }
4376 FunctionDoesNotExist
4377 },
4378 {
4379 fn UUPSUnsupportedProxiableUUID(
4380 data: &[u8],
4381 validate: bool,
4382 ) -> alloy_sol_types::Result<FeeContractErrors> {
4383 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_decode_raw(
4384 data,
4385 validate,
4386 )
4387 .map(FeeContractErrors::UUPSUnsupportedProxiableUUID)
4388 }
4389 UUPSUnsupportedProxiableUUID
4390 },
4391 {
4392 fn ERC1967NonPayable(
4393 data: &[u8],
4394 validate: bool,
4395 ) -> alloy_sol_types::Result<FeeContractErrors> {
4396 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_decode_raw(
4397 data,
4398 validate,
4399 )
4400 .map(FeeContractErrors::ERC1967NonPayable)
4401 }
4402 ERC1967NonPayable
4403 },
4404 {
4405 fn NoFunctionCalled(
4406 data: &[u8],
4407 validate: bool,
4408 ) -> alloy_sol_types::Result<FeeContractErrors> {
4409 <NoFunctionCalled as alloy_sol_types::SolError>::abi_decode_raw(
4410 data,
4411 validate,
4412 )
4413 .map(FeeContractErrors::NoFunctionCalled)
4414 }
4415 NoFunctionCalled
4416 },
4417 {
4418 fn DepositTooLarge(
4419 data: &[u8],
4420 validate: bool,
4421 ) -> alloy_sol_types::Result<FeeContractErrors> {
4422 <DepositTooLarge as alloy_sol_types::SolError>::abi_decode_raw(
4423 data,
4424 validate,
4425 )
4426 .map(FeeContractErrors::DepositTooLarge)
4427 }
4428 DepositTooLarge
4429 },
4430 {
4431 fn NotInitializing(
4432 data: &[u8],
4433 validate: bool,
4434 ) -> alloy_sol_types::Result<FeeContractErrors> {
4435 <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw(
4436 data,
4437 validate,
4438 )
4439 .map(FeeContractErrors::NotInitializing)
4440 }
4441 NotInitializing
4442 },
4443 {
4444 fn UUPSUnauthorizedCallContext(
4445 data: &[u8],
4446 validate: bool,
4447 ) -> alloy_sol_types::Result<FeeContractErrors> {
4448 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_decode_raw(
4449 data,
4450 validate,
4451 )
4452 .map(FeeContractErrors::UUPSUnauthorizedCallContext)
4453 }
4454 UUPSUnauthorizedCallContext
4455 },
4456 {
4457 fn InvalidInitialization(
4458 data: &[u8],
4459 validate: bool,
4460 ) -> alloy_sol_types::Result<FeeContractErrors> {
4461 <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw(
4462 data,
4463 validate,
4464 )
4465 .map(FeeContractErrors::InvalidInitialization)
4466 }
4467 InvalidInitialization
4468 },
4469 ];
4470 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4471 return Err(
4472 alloy_sol_types::Error::unknown_selector(
4473 <Self as alloy_sol_types::SolInterface>::NAME,
4474 selector,
4475 ),
4476 );
4477 };
4478 DECODE_SHIMS[idx](data, validate)
4479 }
4480 #[inline]
4481 fn abi_encoded_size(&self) -> usize {
4482 match self {
4483 Self::AddressEmptyCode(inner) => {
4484 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encoded_size(
4485 inner,
4486 )
4487 }
4488 Self::DepositTooLarge(inner) => {
4489 <DepositTooLarge as alloy_sol_types::SolError>::abi_encoded_size(
4490 inner,
4491 )
4492 }
4493 Self::DepositTooSmall(inner) => {
4494 <DepositTooSmall as alloy_sol_types::SolError>::abi_encoded_size(
4495 inner,
4496 )
4497 }
4498 Self::ERC1967InvalidImplementation(inner) => {
4499 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encoded_size(
4500 inner,
4501 )
4502 }
4503 Self::ERC1967NonPayable(inner) => {
4504 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encoded_size(
4505 inner,
4506 )
4507 }
4508 Self::FailedInnerCall(inner) => {
4509 <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(
4510 inner,
4511 )
4512 }
4513 Self::FunctionDoesNotExist(inner) => {
4514 <FunctionDoesNotExist as alloy_sol_types::SolError>::abi_encoded_size(
4515 inner,
4516 )
4517 }
4518 Self::InvalidInitialization(inner) => {
4519 <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(
4520 inner,
4521 )
4522 }
4523 Self::InvalidUserAddress(inner) => {
4524 <InvalidUserAddress as alloy_sol_types::SolError>::abi_encoded_size(
4525 inner,
4526 )
4527 }
4528 Self::NoFunctionCalled(inner) => {
4529 <NoFunctionCalled as alloy_sol_types::SolError>::abi_encoded_size(
4530 inner,
4531 )
4532 }
4533 Self::NotInitializing(inner) => {
4534 <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(
4535 inner,
4536 )
4537 }
4538 Self::OwnableInvalidOwner(inner) => {
4539 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
4540 inner,
4541 )
4542 }
4543 Self::OwnableUnauthorizedAccount(inner) => {
4544 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
4545 inner,
4546 )
4547 }
4548 Self::UUPSUnauthorizedCallContext(inner) => {
4549 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encoded_size(
4550 inner,
4551 )
4552 }
4553 Self::UUPSUnsupportedProxiableUUID(inner) => {
4554 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encoded_size(
4555 inner,
4556 )
4557 }
4558 }
4559 }
4560 #[inline]
4561 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4562 match self {
4563 Self::AddressEmptyCode(inner) => {
4564 <AddressEmptyCode as alloy_sol_types::SolError>::abi_encode_raw(
4565 inner,
4566 out,
4567 )
4568 }
4569 Self::DepositTooLarge(inner) => {
4570 <DepositTooLarge as alloy_sol_types::SolError>::abi_encode_raw(
4571 inner,
4572 out,
4573 )
4574 }
4575 Self::DepositTooSmall(inner) => {
4576 <DepositTooSmall as alloy_sol_types::SolError>::abi_encode_raw(
4577 inner,
4578 out,
4579 )
4580 }
4581 Self::ERC1967InvalidImplementation(inner) => {
4582 <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encode_raw(
4583 inner,
4584 out,
4585 )
4586 }
4587 Self::ERC1967NonPayable(inner) => {
4588 <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encode_raw(
4589 inner,
4590 out,
4591 )
4592 }
4593 Self::FailedInnerCall(inner) => {
4594 <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(
4595 inner,
4596 out,
4597 )
4598 }
4599 Self::FunctionDoesNotExist(inner) => {
4600 <FunctionDoesNotExist as alloy_sol_types::SolError>::abi_encode_raw(
4601 inner,
4602 out,
4603 )
4604 }
4605 Self::InvalidInitialization(inner) => {
4606 <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(
4607 inner,
4608 out,
4609 )
4610 }
4611 Self::InvalidUserAddress(inner) => {
4612 <InvalidUserAddress as alloy_sol_types::SolError>::abi_encode_raw(
4613 inner,
4614 out,
4615 )
4616 }
4617 Self::NoFunctionCalled(inner) => {
4618 <NoFunctionCalled as alloy_sol_types::SolError>::abi_encode_raw(
4619 inner,
4620 out,
4621 )
4622 }
4623 Self::NotInitializing(inner) => {
4624 <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(
4625 inner,
4626 out,
4627 )
4628 }
4629 Self::OwnableInvalidOwner(inner) => {
4630 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
4631 inner,
4632 out,
4633 )
4634 }
4635 Self::OwnableUnauthorizedAccount(inner) => {
4636 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
4637 inner,
4638 out,
4639 )
4640 }
4641 Self::UUPSUnauthorizedCallContext(inner) => {
4642 <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encode_raw(
4643 inner,
4644 out,
4645 )
4646 }
4647 Self::UUPSUnsupportedProxiableUUID(inner) => {
4648 <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encode_raw(
4649 inner,
4650 out,
4651 )
4652 }
4653 }
4654 }
4655 }
4656 #[derive(Debug, PartialEq, Eq, Hash)]
4658 pub enum FeeContractEvents {
4659 #[allow(missing_docs)]
4660 Deposit(Deposit),
4661 #[allow(missing_docs)]
4662 Initialized(Initialized),
4663 #[allow(missing_docs)]
4664 Log(Log),
4665 #[allow(missing_docs)]
4666 OwnershipTransferred(OwnershipTransferred),
4667 #[allow(missing_docs)]
4668 Upgrade(Upgrade),
4669 #[allow(missing_docs)]
4670 Upgraded(Upgraded),
4671 }
4672 #[automatically_derived]
4673 impl FeeContractEvents {
4674 pub const SELECTORS: &'static [[u8; 32usize]] = &[
4681 [
4682 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
4683 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
4684 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
4685 ],
4686 [
4687 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
4688 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8,
4689 12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
4690 ],
4691 [
4692 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
4693 19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
4694 33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
4695 ],
4696 [
4697 221u8, 151u8, 13u8, 217u8, 181u8, 191u8, 231u8, 7u8, 146u8, 33u8, 85u8,
4698 176u8, 88u8, 164u8, 7u8, 101u8, 92u8, 177u8, 130u8, 136u8, 184u8, 7u8,
4699 226u8, 33u8, 100u8, 66u8, 188u8, 168u8, 173u8, 131u8, 214u8, 181u8,
4700 ],
4701 [
4702 225u8, 255u8, 252u8, 196u8, 146u8, 61u8, 4u8, 181u8, 89u8, 244u8, 210u8,
4703 154u8, 139u8, 252u8, 108u8, 218u8, 4u8, 235u8, 91u8, 13u8, 60u8, 70u8,
4704 7u8, 81u8, 194u8, 64u8, 44u8, 92u8, 92u8, 201u8, 16u8, 156u8,
4705 ],
4706 [
4707 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8,
4708 154u8, 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8,
4709 185u8, 62u8, 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
4710 ],
4711 ];
4712 }
4713 #[automatically_derived]
4714 impl alloy_sol_types::SolEventInterface for FeeContractEvents {
4715 const NAME: &'static str = "FeeContractEvents";
4716 const COUNT: usize = 6usize;
4717 fn decode_raw_log(
4718 topics: &[alloy_sol_types::Word],
4719 data: &[u8],
4720 validate: bool,
4721 ) -> alloy_sol_types::Result<Self> {
4722 match topics.first().copied() {
4723 Some(<Deposit as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4724 <Deposit as alloy_sol_types::SolEvent>::decode_raw_log(
4725 topics,
4726 data,
4727 validate,
4728 )
4729 .map(Self::Deposit)
4730 }
4731 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4732 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
4733 topics,
4734 data,
4735 validate,
4736 )
4737 .map(Self::Initialized)
4738 }
4739 Some(<Log as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4740 <Log as alloy_sol_types::SolEvent>::decode_raw_log(
4741 topics,
4742 data,
4743 validate,
4744 )
4745 .map(Self::Log)
4746 }
4747 Some(
4748 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
4749 ) => {
4750 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
4751 topics,
4752 data,
4753 validate,
4754 )
4755 .map(Self::OwnershipTransferred)
4756 }
4757 Some(<Upgrade as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4758 <Upgrade as alloy_sol_types::SolEvent>::decode_raw_log(
4759 topics,
4760 data,
4761 validate,
4762 )
4763 .map(Self::Upgrade)
4764 }
4765 Some(<Upgraded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4766 <Upgraded as alloy_sol_types::SolEvent>::decode_raw_log(
4767 topics,
4768 data,
4769 validate,
4770 )
4771 .map(Self::Upgraded)
4772 }
4773 _ => {
4774 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
4775 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
4776 log: alloy_sol_types::private::Box::new(
4777 alloy_sol_types::private::LogData::new_unchecked(
4778 topics.to_vec(),
4779 data.to_vec().into(),
4780 ),
4781 ),
4782 })
4783 }
4784 }
4785 }
4786 }
4787 #[automatically_derived]
4788 impl alloy_sol_types::private::IntoLogData for FeeContractEvents {
4789 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4790 match self {
4791 Self::Deposit(inner) => {
4792 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4793 }
4794 Self::Initialized(inner) => {
4795 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4796 }
4797 Self::Log(inner) => {
4798 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4799 }
4800 Self::OwnershipTransferred(inner) => {
4801 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4802 }
4803 Self::Upgrade(inner) => {
4804 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4805 }
4806 Self::Upgraded(inner) => {
4807 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4808 }
4809 }
4810 }
4811 fn into_log_data(self) -> alloy_sol_types::private::LogData {
4812 match self {
4813 Self::Deposit(inner) => {
4814 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4815 }
4816 Self::Initialized(inner) => {
4817 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4818 }
4819 Self::Log(inner) => {
4820 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4821 }
4822 Self::OwnershipTransferred(inner) => {
4823 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4824 }
4825 Self::Upgrade(inner) => {
4826 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4827 }
4828 Self::Upgraded(inner) => {
4829 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4830 }
4831 }
4832 }
4833 }
4834 use alloy::contract as alloy_contract;
4835 #[inline]
4839 pub const fn new<
4840 T: alloy_contract::private::Transport + ::core::clone::Clone,
4841 P: alloy_contract::private::Provider<T, N>,
4842 N: alloy_contract::private::Network,
4843 >(
4844 address: alloy_sol_types::private::Address,
4845 provider: P,
4846 ) -> FeeContractInstance<T, P, N> {
4847 FeeContractInstance::<T, P, N>::new(address, provider)
4848 }
4849 #[inline]
4855 pub fn deploy<
4856 T: alloy_contract::private::Transport + ::core::clone::Clone,
4857 P: alloy_contract::private::Provider<T, N>,
4858 N: alloy_contract::private::Network,
4859 >(
4860 provider: P,
4861 ) -> impl ::core::future::Future<
4862 Output = alloy_contract::Result<FeeContractInstance<T, P, N>>,
4863 > {
4864 FeeContractInstance::<T, P, N>::deploy(provider)
4865 }
4866 #[inline]
4872 pub fn deploy_builder<
4873 T: alloy_contract::private::Transport + ::core::clone::Clone,
4874 P: alloy_contract::private::Provider<T, N>,
4875 N: alloy_contract::private::Network,
4876 >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
4877 FeeContractInstance::<T, P, N>::deploy_builder(provider)
4878 }
4879 #[derive(Clone)]
4891 pub struct FeeContractInstance<T, P, N = alloy_contract::private::Ethereum> {
4892 address: alloy_sol_types::private::Address,
4893 provider: P,
4894 _network_transport: ::core::marker::PhantomData<(N, T)>,
4895 }
4896 #[automatically_derived]
4897 impl<T, P, N> ::core::fmt::Debug for FeeContractInstance<T, P, N> {
4898 #[inline]
4899 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4900 f.debug_tuple("FeeContractInstance").field(&self.address).finish()
4901 }
4902 }
4903 #[automatically_derived]
4905 impl<
4906 T: alloy_contract::private::Transport + ::core::clone::Clone,
4907 P: alloy_contract::private::Provider<T, N>,
4908 N: alloy_contract::private::Network,
4909 > FeeContractInstance<T, P, N> {
4910 #[inline]
4914 pub const fn new(
4915 address: alloy_sol_types::private::Address,
4916 provider: P,
4917 ) -> Self {
4918 Self {
4919 address,
4920 provider,
4921 _network_transport: ::core::marker::PhantomData,
4922 }
4923 }
4924 #[inline]
4930 pub async fn deploy(
4931 provider: P,
4932 ) -> alloy_contract::Result<FeeContractInstance<T, P, N>> {
4933 let call_builder = Self::deploy_builder(provider);
4934 let contract_address = call_builder.deploy().await?;
4935 Ok(Self::new(contract_address, call_builder.provider))
4936 }
4937 #[inline]
4943 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
4944 alloy_contract::RawCallBuilder::new_raw_deploy(
4945 provider,
4946 ::core::clone::Clone::clone(&BYTECODE),
4947 )
4948 }
4949 #[inline]
4951 pub const fn address(&self) -> &alloy_sol_types::private::Address {
4952 &self.address
4953 }
4954 #[inline]
4956 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
4957 self.address = address;
4958 }
4959 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
4961 self.set_address(address);
4962 self
4963 }
4964 #[inline]
4966 pub const fn provider(&self) -> &P {
4967 &self.provider
4968 }
4969 }
4970 impl<T, P: ::core::clone::Clone, N> FeeContractInstance<T, &P, N> {
4971 #[inline]
4973 pub fn with_cloned_provider(self) -> FeeContractInstance<T, P, N> {
4974 FeeContractInstance {
4975 address: self.address,
4976 provider: ::core::clone::Clone::clone(&self.provider),
4977 _network_transport: ::core::marker::PhantomData,
4978 }
4979 }
4980 }
4981 #[automatically_derived]
4983 impl<
4984 T: alloy_contract::private::Transport + ::core::clone::Clone,
4985 P: alloy_contract::private::Provider<T, N>,
4986 N: alloy_contract::private::Network,
4987 > FeeContractInstance<T, P, N> {
4988 pub fn call_builder<C: alloy_sol_types::SolCall>(
4993 &self,
4994 call: &C,
4995 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
4996 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
4997 }
4998 pub fn UPGRADE_INTERFACE_VERSION(
5000 &self,
5001 ) -> alloy_contract::SolCallBuilder<T, &P, UPGRADE_INTERFACE_VERSIONCall, N> {
5002 self.call_builder(&UPGRADE_INTERFACE_VERSIONCall {})
5003 }
5004 pub fn balances(
5006 &self,
5007 user: alloy::sol_types::private::Address,
5008 ) -> alloy_contract::SolCallBuilder<T, &P, balancesCall, N> {
5009 self.call_builder(&balancesCall { user })
5010 }
5011 pub fn deposit(
5013 &self,
5014 user: alloy::sol_types::private::Address,
5015 ) -> alloy_contract::SolCallBuilder<T, &P, depositCall, N> {
5016 self.call_builder(&depositCall { user })
5017 }
5018 pub fn getVersion(
5020 &self,
5021 ) -> alloy_contract::SolCallBuilder<T, &P, getVersionCall, N> {
5022 self.call_builder(&getVersionCall {})
5023 }
5024 pub fn initialize(
5026 &self,
5027 multisig: alloy::sol_types::private::Address,
5028 ) -> alloy_contract::SolCallBuilder<T, &P, initializeCall, N> {
5029 self.call_builder(&initializeCall { multisig })
5030 }
5031 pub fn maxDepositAmount(
5033 &self,
5034 ) -> alloy_contract::SolCallBuilder<T, &P, maxDepositAmountCall, N> {
5035 self.call_builder(&maxDepositAmountCall {})
5036 }
5037 pub fn minDepositAmount(
5039 &self,
5040 ) -> alloy_contract::SolCallBuilder<T, &P, minDepositAmountCall, N> {
5041 self.call_builder(&minDepositAmountCall {})
5042 }
5043 pub fn owner(&self) -> alloy_contract::SolCallBuilder<T, &P, ownerCall, N> {
5045 self.call_builder(&ownerCall {})
5046 }
5047 pub fn proxiableUUID(
5049 &self,
5050 ) -> alloy_contract::SolCallBuilder<T, &P, proxiableUUIDCall, N> {
5051 self.call_builder(&proxiableUUIDCall {})
5052 }
5053 pub fn renounceOwnership(
5055 &self,
5056 ) -> alloy_contract::SolCallBuilder<T, &P, renounceOwnershipCall, N> {
5057 self.call_builder(&renounceOwnershipCall {})
5058 }
5059 pub fn transferOwnership(
5061 &self,
5062 newOwner: alloy::sol_types::private::Address,
5063 ) -> alloy_contract::SolCallBuilder<T, &P, transferOwnershipCall, N> {
5064 self.call_builder(&transferOwnershipCall { newOwner })
5065 }
5066 pub fn upgradeToAndCall(
5068 &self,
5069 newImplementation: alloy::sol_types::private::Address,
5070 data: alloy::sol_types::private::Bytes,
5071 ) -> alloy_contract::SolCallBuilder<T, &P, upgradeToAndCallCall, N> {
5072 self.call_builder(
5073 &upgradeToAndCallCall {
5074 newImplementation,
5075 data,
5076 },
5077 )
5078 }
5079 }
5080 #[automatically_derived]
5082 impl<
5083 T: alloy_contract::private::Transport + ::core::clone::Clone,
5084 P: alloy_contract::private::Provider<T, N>,
5085 N: alloy_contract::private::Network,
5086 > FeeContractInstance<T, P, N> {
5087 pub fn event_filter<E: alloy_sol_types::SolEvent>(
5092 &self,
5093 ) -> alloy_contract::Event<T, &P, E, N> {
5094 alloy_contract::Event::new_sol(&self.provider, &self.address)
5095 }
5096 pub fn Deposit_filter(&self) -> alloy_contract::Event<T, &P, Deposit, N> {
5098 self.event_filter::<Deposit>()
5099 }
5100 pub fn Initialized_filter(
5102 &self,
5103 ) -> alloy_contract::Event<T, &P, Initialized, N> {
5104 self.event_filter::<Initialized>()
5105 }
5106 pub fn Log_filter(&self) -> alloy_contract::Event<T, &P, Log, N> {
5108 self.event_filter::<Log>()
5109 }
5110 pub fn OwnershipTransferred_filter(
5112 &self,
5113 ) -> alloy_contract::Event<T, &P, OwnershipTransferred, N> {
5114 self.event_filter::<OwnershipTransferred>()
5115 }
5116 pub fn Upgrade_filter(&self) -> alloy_contract::Event<T, &P, Upgrade, N> {
5118 self.event_filter::<Upgrade>()
5119 }
5120 pub fn Upgraded_filter(&self) -> alloy_contract::Event<T, &P, Upgraded, N> {
5122 self.event_filter::<Upgraded>()
5123 }
5124 }
5125}