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