1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use StrategyBase::*;
3
4#[allow(
578 non_camel_case_types,
579 non_snake_case,
580 clippy::pub_underscore_fields,
581 clippy::style,
582 clippy::empty_structs_with_brackets
583)]
584pub mod StrategyBase {
585 use super::*;
586 use alloy::sol_types as alloy_sol_types;
587 #[rustfmt::skip]
593 #[allow(clippy::all)]
594 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
595 b"`\xE0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x16\x028\x03\x80a\x16\x02\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01\xD8V[\x80\x82`\x01`\x01`\xA0\x1B\x03\x81\x16a\0WW`@Qc9\xB1\x90\xBB`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0l\x81a\0\x8DV[`\xA0RP`\x01`\x01`\xA0\x1B\x03\x83\x16`\xC0Ra\0\x85a\0\xD3V[PPPa\x03\x05V[__\x82\x90P`\x1F\x81Q\x11\x15a\0\xC0W\x82`@Qc0Z'\xA9`\xE0\x1B\x81R`\x04\x01a\0\xB7\x91\x90a\x02\xADV[`@Q\x80\x91\x03\x90\xFD[\x80Qa\0\xCB\x82a\x02\xDFV[\x17\x93\x92PPPV[_Ta\x01\0\x90\x04`\xFF\x16\x15a\x01:W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FInitializable: contract is initi`D\x82\x01Rfalizing`\xC8\x1B`d\x82\x01R`\x84\x01a\0\xB7V[_T`\xFF\x90\x81\x16\x14a\x01\x89W_\x80T`\xFF\x19\x16`\xFF\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x90` \x01`@Q\x80\x91\x03\x90\xA1[V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x01\x9FW__\xFD[PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_[\x83\x81\x10\x15a\x01\xD0W\x81\x81\x01Q\x83\x82\x01R` \x01a\x01\xB8V[PP_\x91\x01RV[___``\x84\x86\x03\x12\x15a\x01\xEAW__\xFD[\x83Qa\x01\xF5\x81a\x01\x8BV[` \x85\x01Q\x90\x93Pa\x02\x06\x81a\x01\x8BV[`@\x85\x01Q\x90\x92P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02!W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x021W__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02JWa\x02Ja\x01\xA2V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x02xWa\x02xa\x01\xA2V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x02\x8FW__\xFD[a\x02\xA0\x82` \x83\x01` \x86\x01a\x01\xB6V[\x80\x93PPPP\x92P\x92P\x92V[` \x81R_\x82Q\x80` \x84\x01Ra\x02\xCB\x81`@\x85\x01` \x87\x01a\x01\xB6V[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[\x80Q` \x80\x83\x01Q\x91\x90\x81\x10\x15a\x02\xFFW_\x19\x81` \x03`\x03\x1B\x1B\x82\x16\x91P[P\x91\x90PV[`\x80Q`\xA0Q`\xC0Qa\x12\xA9a\x03Y_9_\x81\x81a\x01\x80\x01R\x81\x81a\x04\x15\x01R\x81\x81a\x07\xD9\x01Ra\x08v\x01R_a\x055\x01R_\x81\x81a\x02K\x01R\x81\x81a\x03\"\x01R\x81\x81a\x05\x86\x01Ra\t\xA4\x01Ra\x12\xA9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x012W_5`\xE0\x1C\x80cz\x8B&7\x11a\0\xB4W\x80c\xC4\xD6m\xE8\x11a\0yW\x80c\xC4\xD6m\xE8\x14a\x02\x9BW\x80c\xCE|*\xC2\x14a\x02\xAEW\x80c\xD9\xCA\xED\x12\x14a\x02\xC1W\x80c\xE3\xDA\xE5\x1C\x14a\x02\xD4W\x80c\xF3\xE78u\x14a\x02\xE7W\x80c\xFA\xBC\x1C\xBC\x14a\x02\xFAW__\xFD[\x80cz\x8B&7\x14a\x023W\x80c\x88o\x11\x95\x14a\x02FW\x80c\x8C\x87\x10\x19\x14a\x02mW\x80c\x8Fjb@\x14a\x02\x80W\x80c\xABY!\xE1\x14a\x02\x93W__\xFD[\x80cT\xFDMP\x11a\0\xFAW\x80cT\xFDMP\x14a\x01\xCCW\x80cU<\xA5\xF8\x14a\x01\xE1W\x80cY\\jg\x14a\x01\xF4W\x80cZ\xC8j\xB7\x14a\x01\xFCW\x80c\\\x97Z\xBB\x14a\x02+W__\xFD[\x80c\x13d9\xDD\x14a\x016W\x80c$\x95\xA5\x99\x14a\x01KW\x80c9\xB7\x0E8\x14a\x01{W\x80c:\x98\xEF9\x14a\x01\xA2W\x80cG\xE7\xEF$\x14a\x01\xB9W[__\xFD[a\x01Ia\x01D6`\x04a\x0F\xFAV[a\x03\rV[\0[`2Ta\x01^\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01^\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\x81V[a\x01\xAB`3T\x81V[`@Q\x90\x81R` \x01a\x01rV[a\x01\xABa\x01\xC76`\x04a\x10(V[a\x03\xE2V[a\x01\xD4a\x05.V[`@Qa\x01r\x91\x90a\x10tV[a\x01\xABa\x01\xEF6`\x04a\x10\xA6V[a\x05^V[a\x01Ia\x05qV[a\x02\x1Ba\x02\n6`\x04a\x10\xD6V[`\x01\x80T`\xFF\x90\x92\x16\x1B\x90\x81\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\x01rV[`\x01Ta\x01\xABV[a\x01\xABa\x02A6`\x04a\x0F\xFAV[a\x06 V[a\x01^\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\x81V[a\x01\xABa\x02{6`\x04a\x0F\xFAV[a\x06iV[a\x01\xABa\x02\x8E6`\x04a\x10\xA6V[a\x06sV[a\x01\xD4a\x06\x80V[a\x01Ia\x02\xA96`\x04a\x10\xA6V[a\x06\xA0V[a\x01\xABa\x02\xBC6`\x04a\x10\xA6V[a\x07\xB2V[a\x01Ia\x02\xCF6`\x04a\x10\xF1V[a\x08DV[a\x01\xABa\x02\xE26`\x04a\x0F\xFAV[a\taV[a\x01\xABa\x02\xF56`\x04a\x0F\xFAV[a\t\x98V[a\x01Ia\x03\x086`\x04a\x0F\xFAV[a\t\xA2V[`@Qc#}\xFBG`\xE1\x1B\x81R3`\x04\x82\x01R\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\x16\x90cF\xFB\xF6\x8E\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03oW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x93\x91\x90a\x11/V[a\x03\xB0W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x81\x81\x16\x81\x14a\x03\xD5W`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xDE\x82a\n\xB8V[PPV[`\x01\x80T_\x91\x82\x91\x81\x16\x03a\x04\nW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3`\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\x04SW`@QcH\xDAqO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04]\x84\x84a\n\xF5V[`3T_a\x04ma\x03\xE8\x83a\x11bV[\x90P_a\x03\xE8a\x04{a\x0B#V[a\x04\x85\x91\x90a\x11bV[\x90P_a\x04\x92\x87\x83a\x11uV[\x90P\x80a\x04\x9F\x84\x89a\x11\x88V[a\x04\xA9\x91\x90a\x11\x9FV[\x95P\x85_\x03a\x04\xCBW`@Qc\x0C9.\xD3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\xD5\x86\x85a\x11bV[`3\x81\x90UoK;L\xA8Z\x86\xC4z\t\x8A\"?\xFF\xFF\xFF\xFF\x10\x15a\x05\nW`@Qc/\x14\xE8\xA3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05#\x82a\x03\xE8`3Ta\x05\x1E\x91\x90a\x11bV[a\x0B\x8DV[PPPPP\x92\x91PPV[``a\x05Y\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\0a\x0B\xD9V[\x90P\x90V[_a\x05ka\x02A\x83a\x07\xB2V[\x92\x91PPV[`@Qc#}\xFBG`\xE1\x1B\x81R3`\x04\x82\x01R\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\x16\x90cF\xFB\xF6\x8E\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xD3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xF7\x91\x90a\x11/V[a\x06\x14W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x06\x1E_\x19a\n\xB8V[V[__a\x03\xE8`3Ta\x062\x91\x90a\x11bV[\x90P_a\x03\xE8a\x06@a\x0B#V[a\x06J\x91\x90a\x11bV[\x90P\x81a\x06W\x85\x83a\x11\x88V[a\x06a\x91\x90a\x11\x9FV[\x94\x93PPPPV[_a\x05k\x82a\taV[_a\x05ka\x02\xF5\x83a\x07\xB2V[```@Q\x80`\x80\x01`@R\x80`M\x81R` \x01a\x12'`M\x919\x90P\x90V[_Ta\x01\0\x90\x04`\xFF\x16\x15\x80\x80\x15a\x06\xBEWP_T`\x01`\xFF\x90\x91\x16\x10[\x80a\x06\xD7WP0;\x15\x80\x15a\x06\xD7WP_T`\xFF\x16`\x01\x14[a\x07?W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FInitializable: contract is alrea`D\x82\x01Rm\x19\x1EH\x1A[\x9A]\x1AX[\x1A^\x99Y`\x92\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[_\x80T`\xFF\x19\x16`\x01\x17\x90U\x80\x15a\x07`W_\x80Ta\xFF\0\x19\x16a\x01\0\x17\x90U[a\x07i\x82a\x0C\x16V[\x80\x15a\x03\xDEW_\x80Ta\xFF\0\x19\x16\x90U`@Q`\x01\x81R\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`@Qc\xFE$:\x17`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\x04\x83\x01R0`$\x83\x01R_\x91\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\x90\x91\x16\x90c\xFE$:\x17\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08 W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05k\x91\x90a\x11\xBEV[`\x01\x80T`\x02\x90\x81\x16\x03a\x08kW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3`\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\x08\xB4W`@QcH\xDAqO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08\xBF\x84\x84\x84a\raV[`3T\x80\x83\x11\x15a\x08\xE3W`@Qc\x0BF\x9D\xF3`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x08\xF0a\x03\xE8\x83a\x11bV[\x90P_a\x03\xE8a\x08\xFEa\x0B#V[a\t\x08\x91\x90a\x11bV[\x90P_\x82a\t\x16\x87\x84a\x11\x88V[a\t \x91\x90a\x11\x9FV[\x90Pa\t,\x86\x85a\x11uV[`3Ua\tLa\t<\x82\x84a\x11uV[a\x03\xE8`3Ta\x05\x1E\x91\x90a\x11bV[a\tW\x88\x88\x83a\r\x94V[PPPPPPPPV[__a\x03\xE8`3Ta\ts\x91\x90a\x11bV[\x90P_a\x03\xE8a\t\x81a\x0B#V[a\t\x8B\x91\x90a\x11bV[\x90P\x80a\x06W\x83\x86a\x11\x88V[_a\x05k\x82a\x06 V[\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\x16c\xEA\xB6mz`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xFEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\"\x91\x90a\x11\xD5V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\nSW`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x80\x19\x82\x19\x81\x16\x14a\nzW`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01\x82\x90U`@Q\x82\x81R3\x90\x7F5\x82\xD1\x82\x8E&\xBFV\xBD\x80\x15\x02\xBC\x02\x1A\xC0\xBC\x8A\xFBW\xC8&\xE4\x98kEY<\x8F\xAD8\x9C\x90` \x01`@Q\x80\x91\x03\x90\xA2PPV[`\x01\x81\x90U`@Q\x81\x81R3\x90\x7F\xAB@\xA3t\xBCQ\xDE7\"\0\xA8\xBC\x98\x1A\xF8\xC9\xEC\xDC\x08\xDF\xDA\xEF\x0B\xB6\xE0\x9F\x88\xF3\xC6\x16\xEF=\x90` \x01`@Q\x80\x91\x03\x90\xA2PV[`2T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16\x91\x16\x14a\x03\xDEW`@Qc\x03\x12\xAB\xDD`\xE6\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`2T`@Qcp\xA0\x821`\xE0\x1B\x81R0`\x04\x82\x01R_\x91`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0BiW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Y\x91\x90a\x11\xBEV[\x7F\xD2IO4y\xE5\xDAI\xD3\x86e|),a\x0B[\x01\xDF1=\x07\xC6.\xB0\xCF\xA4\x99$\xA3\x1B\xE8\x81a\x0B\xC1\x84g\r\xE0\xB6\xB3\xA7d\0\0a\x11\x88V[a\x0B\xCB\x91\x90a\x11\x9FV[`@Q\x90\x81R` \x01a\x07\xA6V[``_a\x0B\xE5\x83a\r\xA8V[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x82\x01\x81\x806\x837PPP\x91\x82RP` \x81\x01\x92\x90\x92RP\x90V[_Ta\x01\0\x90\x04`\xFF\x16a\x0C\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`+`$\x82\x01R\x7FInitializable: contract is not i`D\x82\x01Rjnitializing`\xA8\x1B`d\x82\x01R`\x84\x01a\x076V[`2\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90Ua\x0C\xA4_a\n\xB8V[\x7F\x1CT\x07\x07\xB0\x0E\xB5B{kwO\xC7\x99\xD7VQjT\xAE\xE1\x08\xB6K2z\xCCU\xAFUu\x07`2_\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16c1<\xE5g`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\x16W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r:\x91\x90a\x11\xF0V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x90\x93\x16\x83R`\xFF\x90\x91\x16` \x83\x01R\x01`@Q\x80\x91\x03\x90\xA1PV[`2T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16\x91\x16\x14a\r\x8FW`@Qc\x03\x12\xAB\xDD`\xE6\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPV[a\r\x8F`\x01`\x01`\xA0\x1B\x03\x83\x16\x84\x83a\r\xCFV[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x05kW`@Qc,\xD4J\xC3`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x83R` \x80\x83\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x16c\xA9\x05\x9C\xBB`\xE0\x1B\x17\x90R\x83Q\x80\x85\x01\x90\x94R\x80\x84R\x7FSafeERC20: low-level call failed\x90\x84\x01Ra\r\x8F\x92\x86\x92\x91_\x91a\x0E^\x91\x85\x16\x90\x84\x90a\x0E\xDDV[\x90P\x80Q_\x14\x80a\x0E~WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0E~\x91\x90a\x11/V[a\r\x8FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01Ri\x1B\xDD\x08\x1C\xDDX\xD8\xD9YY`\xB2\x1B`d\x82\x01R`\x84\x01a\x076V[``a\x06a\x84\x84_\x85\x85__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x0F\x02\x91\x90a\x12\x0BV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0F<W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0FAV[``\x91P[P\x91P\x91Pa\x0FR\x87\x83\x83\x87a\x0F]V[\x97\x96PPPPPPPV[``\x83\x15a\x0F\xCBW\x82Q_\x03a\x0F\xC4W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x0F\xC4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x076V[P\x81a\x06aV[a\x06a\x83\x83\x81Q\x15a\x0F\xE0W\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x076\x91\x90a\x10tV[_` \x82\x84\x03\x12\x15a\x10\nW__\xFD[P5\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x10%W__\xFD[PV[__`@\x83\x85\x03\x12\x15a\x109W__\xFD[\x825a\x10D\x81a\x10\x11V[\x94` \x93\x90\x93\x015\x93PPPV[_[\x83\x81\x10\x15a\x10lW\x81\x81\x01Q\x83\x82\x01R` \x01a\x10TV[PP_\x91\x01RV[` \x81R_\x82Q\x80` \x84\x01Ra\x10\x92\x81`@\x85\x01` \x87\x01a\x10RV[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x10\xB6W__\xFD[\x815a\x10\xC1\x81a\x10\x11V[\x93\x92PPPV[`\xFF\x81\x16\x81\x14a\x10%W__\xFD[_` \x82\x84\x03\x12\x15a\x10\xE6W__\xFD[\x815a\x10\xC1\x81a\x10\xC8V[___``\x84\x86\x03\x12\x15a\x11\x03W__\xFD[\x835a\x11\x0E\x81a\x10\x11V[\x92P` \x84\x015a\x11\x1E\x81a\x10\x11V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x11?W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x10\xC1W__\xFD[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x05kWa\x05ka\x11NV[\x81\x81\x03\x81\x81\x11\x15a\x05kWa\x05ka\x11NV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x05kWa\x05ka\x11NV[_\x82a\x11\xB9WcNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[P\x04\x90V[_` \x82\x84\x03\x12\x15a\x11\xCEW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x11\xE5W__\xFD[\x81Qa\x10\xC1\x81a\x10\x11V[_` \x82\x84\x03\x12\x15a\x12\0W__\xFD[\x81Qa\x10\xC1\x81a\x10\xC8V[_\x82Qa\x12\x1C\x81\x84` \x87\x01a\x10RV[\x91\x90\x91\x01\x92\x91PPV\xFEBase Strategy implementation to inherit from for more complex implementations\xA2dipfsX\"\x12 w\xB5v\x12\x02\xCF\x1B;L!\xC9}\xA9M>\xE9H\x13\xDD\xACb\xD0\xAF-\x9D\xE7v8\x1E\xC4\x81\xE6dsolcC\0\x08\x1B\x003",
596 );
597 #[rustfmt::skip]
603 #[allow(clippy::all)]
604 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
605 b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x012W_5`\xE0\x1C\x80cz\x8B&7\x11a\0\xB4W\x80c\xC4\xD6m\xE8\x11a\0yW\x80c\xC4\xD6m\xE8\x14a\x02\x9BW\x80c\xCE|*\xC2\x14a\x02\xAEW\x80c\xD9\xCA\xED\x12\x14a\x02\xC1W\x80c\xE3\xDA\xE5\x1C\x14a\x02\xD4W\x80c\xF3\xE78u\x14a\x02\xE7W\x80c\xFA\xBC\x1C\xBC\x14a\x02\xFAW__\xFD[\x80cz\x8B&7\x14a\x023W\x80c\x88o\x11\x95\x14a\x02FW\x80c\x8C\x87\x10\x19\x14a\x02mW\x80c\x8Fjb@\x14a\x02\x80W\x80c\xABY!\xE1\x14a\x02\x93W__\xFD[\x80cT\xFDMP\x11a\0\xFAW\x80cT\xFDMP\x14a\x01\xCCW\x80cU<\xA5\xF8\x14a\x01\xE1W\x80cY\\jg\x14a\x01\xF4W\x80cZ\xC8j\xB7\x14a\x01\xFCW\x80c\\\x97Z\xBB\x14a\x02+W__\xFD[\x80c\x13d9\xDD\x14a\x016W\x80c$\x95\xA5\x99\x14a\x01KW\x80c9\xB7\x0E8\x14a\x01{W\x80c:\x98\xEF9\x14a\x01\xA2W\x80cG\xE7\xEF$\x14a\x01\xB9W[__\xFD[a\x01Ia\x01D6`\x04a\x0F\xFAV[a\x03\rV[\0[`2Ta\x01^\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01^\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\x81V[a\x01\xAB`3T\x81V[`@Q\x90\x81R` \x01a\x01rV[a\x01\xABa\x01\xC76`\x04a\x10(V[a\x03\xE2V[a\x01\xD4a\x05.V[`@Qa\x01r\x91\x90a\x10tV[a\x01\xABa\x01\xEF6`\x04a\x10\xA6V[a\x05^V[a\x01Ia\x05qV[a\x02\x1Ba\x02\n6`\x04a\x10\xD6V[`\x01\x80T`\xFF\x90\x92\x16\x1B\x90\x81\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\x01rV[`\x01Ta\x01\xABV[a\x01\xABa\x02A6`\x04a\x0F\xFAV[a\x06 V[a\x01^\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\x81V[a\x01\xABa\x02{6`\x04a\x0F\xFAV[a\x06iV[a\x01\xABa\x02\x8E6`\x04a\x10\xA6V[a\x06sV[a\x01\xD4a\x06\x80V[a\x01Ia\x02\xA96`\x04a\x10\xA6V[a\x06\xA0V[a\x01\xABa\x02\xBC6`\x04a\x10\xA6V[a\x07\xB2V[a\x01Ia\x02\xCF6`\x04a\x10\xF1V[a\x08DV[a\x01\xABa\x02\xE26`\x04a\x0F\xFAV[a\taV[a\x01\xABa\x02\xF56`\x04a\x0F\xFAV[a\t\x98V[a\x01Ia\x03\x086`\x04a\x0F\xFAV[a\t\xA2V[`@Qc#}\xFBG`\xE1\x1B\x81R3`\x04\x82\x01R\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\x16\x90cF\xFB\xF6\x8E\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03oW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x93\x91\x90a\x11/V[a\x03\xB0W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x81\x81\x16\x81\x14a\x03\xD5W`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xDE\x82a\n\xB8V[PPV[`\x01\x80T_\x91\x82\x91\x81\x16\x03a\x04\nW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3`\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\x04SW`@QcH\xDAqO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04]\x84\x84a\n\xF5V[`3T_a\x04ma\x03\xE8\x83a\x11bV[\x90P_a\x03\xE8a\x04{a\x0B#V[a\x04\x85\x91\x90a\x11bV[\x90P_a\x04\x92\x87\x83a\x11uV[\x90P\x80a\x04\x9F\x84\x89a\x11\x88V[a\x04\xA9\x91\x90a\x11\x9FV[\x95P\x85_\x03a\x04\xCBW`@Qc\x0C9.\xD3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\xD5\x86\x85a\x11bV[`3\x81\x90UoK;L\xA8Z\x86\xC4z\t\x8A\"?\xFF\xFF\xFF\xFF\x10\x15a\x05\nW`@Qc/\x14\xE8\xA3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05#\x82a\x03\xE8`3Ta\x05\x1E\x91\x90a\x11bV[a\x0B\x8DV[PPPPP\x92\x91PPV[``a\x05Y\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\0a\x0B\xD9V[\x90P\x90V[_a\x05ka\x02A\x83a\x07\xB2V[\x92\x91PPV[`@Qc#}\xFBG`\xE1\x1B\x81R3`\x04\x82\x01R\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\x16\x90cF\xFB\xF6\x8E\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xD3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xF7\x91\x90a\x11/V[a\x06\x14W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x06\x1E_\x19a\n\xB8V[V[__a\x03\xE8`3Ta\x062\x91\x90a\x11bV[\x90P_a\x03\xE8a\x06@a\x0B#V[a\x06J\x91\x90a\x11bV[\x90P\x81a\x06W\x85\x83a\x11\x88V[a\x06a\x91\x90a\x11\x9FV[\x94\x93PPPPV[_a\x05k\x82a\taV[_a\x05ka\x02\xF5\x83a\x07\xB2V[```@Q\x80`\x80\x01`@R\x80`M\x81R` \x01a\x12'`M\x919\x90P\x90V[_Ta\x01\0\x90\x04`\xFF\x16\x15\x80\x80\x15a\x06\xBEWP_T`\x01`\xFF\x90\x91\x16\x10[\x80a\x06\xD7WP0;\x15\x80\x15a\x06\xD7WP_T`\xFF\x16`\x01\x14[a\x07?W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FInitializable: contract is alrea`D\x82\x01Rm\x19\x1EH\x1A[\x9A]\x1AX[\x1A^\x99Y`\x92\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[_\x80T`\xFF\x19\x16`\x01\x17\x90U\x80\x15a\x07`W_\x80Ta\xFF\0\x19\x16a\x01\0\x17\x90U[a\x07i\x82a\x0C\x16V[\x80\x15a\x03\xDEW_\x80Ta\xFF\0\x19\x16\x90U`@Q`\x01\x81R\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`@Qc\xFE$:\x17`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\x04\x83\x01R0`$\x83\x01R_\x91\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\x90\x91\x16\x90c\xFE$:\x17\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08 W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05k\x91\x90a\x11\xBEV[`\x01\x80T`\x02\x90\x81\x16\x03a\x08kW`@Qc\x84\nH\xD5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3`\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\x08\xB4W`@QcH\xDAqO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08\xBF\x84\x84\x84a\raV[`3T\x80\x83\x11\x15a\x08\xE3W`@Qc\x0BF\x9D\xF3`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x08\xF0a\x03\xE8\x83a\x11bV[\x90P_a\x03\xE8a\x08\xFEa\x0B#V[a\t\x08\x91\x90a\x11bV[\x90P_\x82a\t\x16\x87\x84a\x11\x88V[a\t \x91\x90a\x11\x9FV[\x90Pa\t,\x86\x85a\x11uV[`3Ua\tLa\t<\x82\x84a\x11uV[a\x03\xE8`3Ta\x05\x1E\x91\x90a\x11bV[a\tW\x88\x88\x83a\r\x94V[PPPPPPPPV[__a\x03\xE8`3Ta\ts\x91\x90a\x11bV[\x90P_a\x03\xE8a\t\x81a\x0B#V[a\t\x8B\x91\x90a\x11bV[\x90P\x80a\x06W\x83\x86a\x11\x88V[_a\x05k\x82a\x06 V[\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\x16c\xEA\xB6mz`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xFEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\"\x91\x90a\x11\xD5V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\nSW`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x80\x19\x82\x19\x81\x16\x14a\nzW`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01\x82\x90U`@Q\x82\x81R3\x90\x7F5\x82\xD1\x82\x8E&\xBFV\xBD\x80\x15\x02\xBC\x02\x1A\xC0\xBC\x8A\xFBW\xC8&\xE4\x98kEY<\x8F\xAD8\x9C\x90` \x01`@Q\x80\x91\x03\x90\xA2PPV[`\x01\x81\x90U`@Q\x81\x81R3\x90\x7F\xAB@\xA3t\xBCQ\xDE7\"\0\xA8\xBC\x98\x1A\xF8\xC9\xEC\xDC\x08\xDF\xDA\xEF\x0B\xB6\xE0\x9F\x88\xF3\xC6\x16\xEF=\x90` \x01`@Q\x80\x91\x03\x90\xA2PV[`2T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16\x91\x16\x14a\x03\xDEW`@Qc\x03\x12\xAB\xDD`\xE6\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`2T`@Qcp\xA0\x821`\xE0\x1B\x81R0`\x04\x82\x01R_\x91`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0BiW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Y\x91\x90a\x11\xBEV[\x7F\xD2IO4y\xE5\xDAI\xD3\x86e|),a\x0B[\x01\xDF1=\x07\xC6.\xB0\xCF\xA4\x99$\xA3\x1B\xE8\x81a\x0B\xC1\x84g\r\xE0\xB6\xB3\xA7d\0\0a\x11\x88V[a\x0B\xCB\x91\x90a\x11\x9FV[`@Q\x90\x81R` \x01a\x07\xA6V[``_a\x0B\xE5\x83a\r\xA8V[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x82\x01\x81\x806\x837PPP\x91\x82RP` \x81\x01\x92\x90\x92RP\x90V[_Ta\x01\0\x90\x04`\xFF\x16a\x0C\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`+`$\x82\x01R\x7FInitializable: contract is not i`D\x82\x01Rjnitializing`\xA8\x1B`d\x82\x01R`\x84\x01a\x076V[`2\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90Ua\x0C\xA4_a\n\xB8V[\x7F\x1CT\x07\x07\xB0\x0E\xB5B{kwO\xC7\x99\xD7VQjT\xAE\xE1\x08\xB6K2z\xCCU\xAFUu\x07`2_\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16c1<\xE5g`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\x16W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r:\x91\x90a\x11\xF0V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x90\x93\x16\x83R`\xFF\x90\x91\x16` \x83\x01R\x01`@Q\x80\x91\x03\x90\xA1PV[`2T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16\x91\x16\x14a\r\x8FW`@Qc\x03\x12\xAB\xDD`\xE6\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPV[a\r\x8F`\x01`\x01`\xA0\x1B\x03\x83\x16\x84\x83a\r\xCFV[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x05kW`@Qc,\xD4J\xC3`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x83R` \x80\x83\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x16c\xA9\x05\x9C\xBB`\xE0\x1B\x17\x90R\x83Q\x80\x85\x01\x90\x94R\x80\x84R\x7FSafeERC20: low-level call failed\x90\x84\x01Ra\r\x8F\x92\x86\x92\x91_\x91a\x0E^\x91\x85\x16\x90\x84\x90a\x0E\xDDV[\x90P\x80Q_\x14\x80a\x0E~WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0E~\x91\x90a\x11/V[a\r\x8FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01Ri\x1B\xDD\x08\x1C\xDDX\xD8\xD9YY`\xB2\x1B`d\x82\x01R`\x84\x01a\x076V[``a\x06a\x84\x84_\x85\x85__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x0F\x02\x91\x90a\x12\x0BV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0F<W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0FAV[``\x91P[P\x91P\x91Pa\x0FR\x87\x83\x83\x87a\x0F]V[\x97\x96PPPPPPPV[``\x83\x15a\x0F\xCBW\x82Q_\x03a\x0F\xC4W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x0F\xC4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x076V[P\x81a\x06aV[a\x06a\x83\x83\x81Q\x15a\x0F\xE0W\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x076\x91\x90a\x10tV[_` \x82\x84\x03\x12\x15a\x10\nW__\xFD[P5\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x10%W__\xFD[PV[__`@\x83\x85\x03\x12\x15a\x109W__\xFD[\x825a\x10D\x81a\x10\x11V[\x94` \x93\x90\x93\x015\x93PPPV[_[\x83\x81\x10\x15a\x10lW\x81\x81\x01Q\x83\x82\x01R` \x01a\x10TV[PP_\x91\x01RV[` \x81R_\x82Q\x80` \x84\x01Ra\x10\x92\x81`@\x85\x01` \x87\x01a\x10RV[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x10\xB6W__\xFD[\x815a\x10\xC1\x81a\x10\x11V[\x93\x92PPPV[`\xFF\x81\x16\x81\x14a\x10%W__\xFD[_` \x82\x84\x03\x12\x15a\x10\xE6W__\xFD[\x815a\x10\xC1\x81a\x10\xC8V[___``\x84\x86\x03\x12\x15a\x11\x03W__\xFD[\x835a\x11\x0E\x81a\x10\x11V[\x92P` \x84\x015a\x11\x1E\x81a\x10\x11V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x11?W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x10\xC1W__\xFD[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x05kWa\x05ka\x11NV[\x81\x81\x03\x81\x81\x11\x15a\x05kWa\x05ka\x11NV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x05kWa\x05ka\x11NV[_\x82a\x11\xB9WcNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[P\x04\x90V[_` \x82\x84\x03\x12\x15a\x11\xCEW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x11\xE5W__\xFD[\x81Qa\x10\xC1\x81a\x10\x11V[_` \x82\x84\x03\x12\x15a\x12\0W__\xFD[\x81Qa\x10\xC1\x81a\x10\xC8V[_\x82Qa\x12\x1C\x81\x84` \x87\x01a\x10RV[\x91\x90\x91\x01\x92\x91PPV\xFEBase Strategy implementation to inherit from for more complex implementations\xA2dipfsX\"\x12 w\xB5v\x12\x02\xCF\x1B;L!\xC9}\xA9M>\xE9H\x13\xDD\xACb\xD0\xAF-\x9D\xE7v8\x1E\xC4\x81\xE6dsolcC\0\x08\x1B\x003",
606 );
607 #[derive(serde::Serialize, serde::Deserialize)]
608 #[derive(Default, Debug, PartialEq, Eq, Hash)]
609 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
614 #[derive(Clone)]
615 pub struct BalanceExceedsMaxTotalDeposits;
616 #[allow(
617 non_camel_case_types,
618 non_snake_case,
619 clippy::pub_underscore_fields,
620 clippy::style
621 )]
622 const _: () = {
623 use alloy::sol_types as alloy_sol_types;
624 #[doc(hidden)]
625 type UnderlyingSolTuple<'a> = ();
626 #[doc(hidden)]
627 type UnderlyingRustTuple<'a> = ();
628 #[cfg(test)]
629 #[allow(dead_code, unreachable_patterns)]
630 fn _type_assertion(
631 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
632 ) {
633 match _t {
634 alloy_sol_types::private::AssertTypeEq::<
635 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
636 >(_) => {}
637 }
638 }
639 #[automatically_derived]
640 #[doc(hidden)]
641 impl ::core::convert::From<BalanceExceedsMaxTotalDeposits>
642 for UnderlyingRustTuple<'_> {
643 fn from(value: BalanceExceedsMaxTotalDeposits) -> Self {
644 ()
645 }
646 }
647 #[automatically_derived]
648 #[doc(hidden)]
649 impl ::core::convert::From<UnderlyingRustTuple<'_>>
650 for BalanceExceedsMaxTotalDeposits {
651 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
652 Self
653 }
654 }
655 #[automatically_derived]
656 impl alloy_sol_types::SolError for BalanceExceedsMaxTotalDeposits {
657 type Parameters<'a> = UnderlyingSolTuple<'a>;
658 type Token<'a> = <Self::Parameters<
659 'a,
660 > as alloy_sol_types::SolType>::Token<'a>;
661 const SIGNATURE: &'static str = "BalanceExceedsMaxTotalDeposits()";
662 const SELECTOR: [u8; 4] = [216u8, 107u8, 174u8, 103u8];
663 #[inline]
664 fn new<'a>(
665 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
666 ) -> Self {
667 tuple.into()
668 }
669 #[inline]
670 fn tokenize(&self) -> Self::Token<'_> {
671 ()
672 }
673 #[inline]
674 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
675 <Self::Parameters<
676 '_,
677 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
678 .map(Self::new)
679 }
680 }
681 };
682 #[derive(serde::Serialize, serde::Deserialize)]
683 #[derive(Default, Debug, PartialEq, Eq, Hash)]
684 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
689 #[derive(Clone)]
690 pub struct CurrentlyPaused;
691 #[allow(
692 non_camel_case_types,
693 non_snake_case,
694 clippy::pub_underscore_fields,
695 clippy::style
696 )]
697 const _: () = {
698 use alloy::sol_types as alloy_sol_types;
699 #[doc(hidden)]
700 type UnderlyingSolTuple<'a> = ();
701 #[doc(hidden)]
702 type UnderlyingRustTuple<'a> = ();
703 #[cfg(test)]
704 #[allow(dead_code, unreachable_patterns)]
705 fn _type_assertion(
706 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
707 ) {
708 match _t {
709 alloy_sol_types::private::AssertTypeEq::<
710 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
711 >(_) => {}
712 }
713 }
714 #[automatically_derived]
715 #[doc(hidden)]
716 impl ::core::convert::From<CurrentlyPaused> for UnderlyingRustTuple<'_> {
717 fn from(value: CurrentlyPaused) -> Self {
718 ()
719 }
720 }
721 #[automatically_derived]
722 #[doc(hidden)]
723 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CurrentlyPaused {
724 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
725 Self
726 }
727 }
728 #[automatically_derived]
729 impl alloy_sol_types::SolError for CurrentlyPaused {
730 type Parameters<'a> = UnderlyingSolTuple<'a>;
731 type Token<'a> = <Self::Parameters<
732 'a,
733 > as alloy_sol_types::SolType>::Token<'a>;
734 const SIGNATURE: &'static str = "CurrentlyPaused()";
735 const SELECTOR: [u8; 4] = [132u8, 10u8, 72u8, 213u8];
736 #[inline]
737 fn new<'a>(
738 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
739 ) -> Self {
740 tuple.into()
741 }
742 #[inline]
743 fn tokenize(&self) -> Self::Token<'_> {
744 ()
745 }
746 #[inline]
747 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
748 <Self::Parameters<
749 '_,
750 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
751 .map(Self::new)
752 }
753 }
754 };
755 #[derive(serde::Serialize, serde::Deserialize)]
756 #[derive(Default, Debug, PartialEq, Eq, Hash)]
757 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
762 #[derive(Clone)]
763 pub struct InputAddressZero;
764 #[allow(
765 non_camel_case_types,
766 non_snake_case,
767 clippy::pub_underscore_fields,
768 clippy::style
769 )]
770 const _: () = {
771 use alloy::sol_types as alloy_sol_types;
772 #[doc(hidden)]
773 type UnderlyingSolTuple<'a> = ();
774 #[doc(hidden)]
775 type UnderlyingRustTuple<'a> = ();
776 #[cfg(test)]
777 #[allow(dead_code, unreachable_patterns)]
778 fn _type_assertion(
779 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
780 ) {
781 match _t {
782 alloy_sol_types::private::AssertTypeEq::<
783 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
784 >(_) => {}
785 }
786 }
787 #[automatically_derived]
788 #[doc(hidden)]
789 impl ::core::convert::From<InputAddressZero> for UnderlyingRustTuple<'_> {
790 fn from(value: InputAddressZero) -> Self {
791 ()
792 }
793 }
794 #[automatically_derived]
795 #[doc(hidden)]
796 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputAddressZero {
797 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
798 Self
799 }
800 }
801 #[automatically_derived]
802 impl alloy_sol_types::SolError for InputAddressZero {
803 type Parameters<'a> = UnderlyingSolTuple<'a>;
804 type Token<'a> = <Self::Parameters<
805 'a,
806 > as alloy_sol_types::SolType>::Token<'a>;
807 const SIGNATURE: &'static str = "InputAddressZero()";
808 const SELECTOR: [u8; 4] = [115u8, 99u8, 33u8, 118u8];
809 #[inline]
810 fn new<'a>(
811 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
812 ) -> Self {
813 tuple.into()
814 }
815 #[inline]
816 fn tokenize(&self) -> Self::Token<'_> {
817 ()
818 }
819 #[inline]
820 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
821 <Self::Parameters<
822 '_,
823 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
824 .map(Self::new)
825 }
826 }
827 };
828 #[derive(serde::Serialize, serde::Deserialize)]
829 #[derive(Default, Debug, PartialEq, Eq, Hash)]
830 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
835 #[derive(Clone)]
836 pub struct InvalidNewPausedStatus;
837 #[allow(
838 non_camel_case_types,
839 non_snake_case,
840 clippy::pub_underscore_fields,
841 clippy::style
842 )]
843 const _: () = {
844 use alloy::sol_types as alloy_sol_types;
845 #[doc(hidden)]
846 type UnderlyingSolTuple<'a> = ();
847 #[doc(hidden)]
848 type UnderlyingRustTuple<'a> = ();
849 #[cfg(test)]
850 #[allow(dead_code, unreachable_patterns)]
851 fn _type_assertion(
852 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
853 ) {
854 match _t {
855 alloy_sol_types::private::AssertTypeEq::<
856 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
857 >(_) => {}
858 }
859 }
860 #[automatically_derived]
861 #[doc(hidden)]
862 impl ::core::convert::From<InvalidNewPausedStatus> for UnderlyingRustTuple<'_> {
863 fn from(value: InvalidNewPausedStatus) -> Self {
864 ()
865 }
866 }
867 #[automatically_derived]
868 #[doc(hidden)]
869 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidNewPausedStatus {
870 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
871 Self
872 }
873 }
874 #[automatically_derived]
875 impl alloy_sol_types::SolError for InvalidNewPausedStatus {
876 type Parameters<'a> = UnderlyingSolTuple<'a>;
877 type Token<'a> = <Self::Parameters<
878 'a,
879 > as alloy_sol_types::SolType>::Token<'a>;
880 const SIGNATURE: &'static str = "InvalidNewPausedStatus()";
881 const SELECTOR: [u8; 4] = [198u8, 29u8, 202u8, 93u8];
882 #[inline]
883 fn new<'a>(
884 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
885 ) -> Self {
886 tuple.into()
887 }
888 #[inline]
889 fn tokenize(&self) -> Self::Token<'_> {
890 ()
891 }
892 #[inline]
893 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
894 <Self::Parameters<
895 '_,
896 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
897 .map(Self::new)
898 }
899 }
900 };
901 #[derive(serde::Serialize, serde::Deserialize)]
902 #[derive(Default, Debug, PartialEq, Eq, Hash)]
903 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
908 #[derive(Clone)]
909 pub struct InvalidShortString;
910 #[allow(
911 non_camel_case_types,
912 non_snake_case,
913 clippy::pub_underscore_fields,
914 clippy::style
915 )]
916 const _: () = {
917 use alloy::sol_types as alloy_sol_types;
918 #[doc(hidden)]
919 type UnderlyingSolTuple<'a> = ();
920 #[doc(hidden)]
921 type UnderlyingRustTuple<'a> = ();
922 #[cfg(test)]
923 #[allow(dead_code, unreachable_patterns)]
924 fn _type_assertion(
925 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
926 ) {
927 match _t {
928 alloy_sol_types::private::AssertTypeEq::<
929 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
930 >(_) => {}
931 }
932 }
933 #[automatically_derived]
934 #[doc(hidden)]
935 impl ::core::convert::From<InvalidShortString> for UnderlyingRustTuple<'_> {
936 fn from(value: InvalidShortString) -> Self {
937 ()
938 }
939 }
940 #[automatically_derived]
941 #[doc(hidden)]
942 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidShortString {
943 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
944 Self
945 }
946 }
947 #[automatically_derived]
948 impl alloy_sol_types::SolError for InvalidShortString {
949 type Parameters<'a> = UnderlyingSolTuple<'a>;
950 type Token<'a> = <Self::Parameters<
951 'a,
952 > as alloy_sol_types::SolType>::Token<'a>;
953 const SIGNATURE: &'static str = "InvalidShortString()";
954 const SELECTOR: [u8; 4] = [179u8, 81u8, 43u8, 12u8];
955 #[inline]
956 fn new<'a>(
957 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
958 ) -> Self {
959 tuple.into()
960 }
961 #[inline]
962 fn tokenize(&self) -> Self::Token<'_> {
963 ()
964 }
965 #[inline]
966 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
967 <Self::Parameters<
968 '_,
969 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
970 .map(Self::new)
971 }
972 }
973 };
974 #[derive(serde::Serialize, serde::Deserialize)]
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 MaxPerDepositExceedsMax;
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(
998 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
999 ) {
1000 match _t {
1001 alloy_sol_types::private::AssertTypeEq::<
1002 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1003 >(_) => {}
1004 }
1005 }
1006 #[automatically_derived]
1007 #[doc(hidden)]
1008 impl ::core::convert::From<MaxPerDepositExceedsMax> for UnderlyingRustTuple<'_> {
1009 fn from(value: MaxPerDepositExceedsMax) -> Self {
1010 ()
1011 }
1012 }
1013 #[automatically_derived]
1014 #[doc(hidden)]
1015 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MaxPerDepositExceedsMax {
1016 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1017 Self
1018 }
1019 }
1020 #[automatically_derived]
1021 impl alloy_sol_types::SolError for MaxPerDepositExceedsMax {
1022 type Parameters<'a> = UnderlyingSolTuple<'a>;
1023 type Token<'a> = <Self::Parameters<
1024 'a,
1025 > as alloy_sol_types::SolType>::Token<'a>;
1026 const SIGNATURE: &'static str = "MaxPerDepositExceedsMax()";
1027 const SELECTOR: [u8; 4] = [20u8, 172u8, 30u8, 220u8];
1028 #[inline]
1029 fn new<'a>(
1030 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1031 ) -> Self {
1032 tuple.into()
1033 }
1034 #[inline]
1035 fn tokenize(&self) -> Self::Token<'_> {
1036 ()
1037 }
1038 #[inline]
1039 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1040 <Self::Parameters<
1041 '_,
1042 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1043 .map(Self::new)
1044 }
1045 }
1046 };
1047 #[derive(serde::Serialize, serde::Deserialize)]
1048 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1049 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1054 #[derive(Clone)]
1055 pub struct NewSharesZero;
1056 #[allow(
1057 non_camel_case_types,
1058 non_snake_case,
1059 clippy::pub_underscore_fields,
1060 clippy::style
1061 )]
1062 const _: () = {
1063 use alloy::sol_types as alloy_sol_types;
1064 #[doc(hidden)]
1065 type UnderlyingSolTuple<'a> = ();
1066 #[doc(hidden)]
1067 type UnderlyingRustTuple<'a> = ();
1068 #[cfg(test)]
1069 #[allow(dead_code, unreachable_patterns)]
1070 fn _type_assertion(
1071 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1072 ) {
1073 match _t {
1074 alloy_sol_types::private::AssertTypeEq::<
1075 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1076 >(_) => {}
1077 }
1078 }
1079 #[automatically_derived]
1080 #[doc(hidden)]
1081 impl ::core::convert::From<NewSharesZero> for UnderlyingRustTuple<'_> {
1082 fn from(value: NewSharesZero) -> Self {
1083 ()
1084 }
1085 }
1086 #[automatically_derived]
1087 #[doc(hidden)]
1088 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NewSharesZero {
1089 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1090 Self
1091 }
1092 }
1093 #[automatically_derived]
1094 impl alloy_sol_types::SolError for NewSharesZero {
1095 type Parameters<'a> = UnderlyingSolTuple<'a>;
1096 type Token<'a> = <Self::Parameters<
1097 'a,
1098 > as alloy_sol_types::SolType>::Token<'a>;
1099 const SIGNATURE: &'static str = "NewSharesZero()";
1100 const SELECTOR: [u8; 4] = [24u8, 114u8, 93u8, 166u8];
1101 #[inline]
1102 fn new<'a>(
1103 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1104 ) -> Self {
1105 tuple.into()
1106 }
1107 #[inline]
1108 fn tokenize(&self) -> Self::Token<'_> {
1109 ()
1110 }
1111 #[inline]
1112 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1113 <Self::Parameters<
1114 '_,
1115 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1116 .map(Self::new)
1117 }
1118 }
1119 };
1120 #[derive(serde::Serialize, serde::Deserialize)]
1121 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1122 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1127 #[derive(Clone)]
1128 pub struct OnlyPauser;
1129 #[allow(
1130 non_camel_case_types,
1131 non_snake_case,
1132 clippy::pub_underscore_fields,
1133 clippy::style
1134 )]
1135 const _: () = {
1136 use alloy::sol_types as alloy_sol_types;
1137 #[doc(hidden)]
1138 type UnderlyingSolTuple<'a> = ();
1139 #[doc(hidden)]
1140 type UnderlyingRustTuple<'a> = ();
1141 #[cfg(test)]
1142 #[allow(dead_code, unreachable_patterns)]
1143 fn _type_assertion(
1144 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1145 ) {
1146 match _t {
1147 alloy_sol_types::private::AssertTypeEq::<
1148 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1149 >(_) => {}
1150 }
1151 }
1152 #[automatically_derived]
1153 #[doc(hidden)]
1154 impl ::core::convert::From<OnlyPauser> for UnderlyingRustTuple<'_> {
1155 fn from(value: OnlyPauser) -> Self {
1156 ()
1157 }
1158 }
1159 #[automatically_derived]
1160 #[doc(hidden)]
1161 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyPauser {
1162 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1163 Self
1164 }
1165 }
1166 #[automatically_derived]
1167 impl alloy_sol_types::SolError for OnlyPauser {
1168 type Parameters<'a> = UnderlyingSolTuple<'a>;
1169 type Token<'a> = <Self::Parameters<
1170 'a,
1171 > as alloy_sol_types::SolType>::Token<'a>;
1172 const SIGNATURE: &'static str = "OnlyPauser()";
1173 const SELECTOR: [u8; 4] = [117u8, 223u8, 81u8, 220u8];
1174 #[inline]
1175 fn new<'a>(
1176 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1177 ) -> Self {
1178 tuple.into()
1179 }
1180 #[inline]
1181 fn tokenize(&self) -> Self::Token<'_> {
1182 ()
1183 }
1184 #[inline]
1185 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1186 <Self::Parameters<
1187 '_,
1188 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1189 .map(Self::new)
1190 }
1191 }
1192 };
1193 #[derive(serde::Serialize, serde::Deserialize)]
1194 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1195 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1200 #[derive(Clone)]
1201 pub struct OnlyStrategyManager;
1202 #[allow(
1203 non_camel_case_types,
1204 non_snake_case,
1205 clippy::pub_underscore_fields,
1206 clippy::style
1207 )]
1208 const _: () = {
1209 use alloy::sol_types as alloy_sol_types;
1210 #[doc(hidden)]
1211 type UnderlyingSolTuple<'a> = ();
1212 #[doc(hidden)]
1213 type UnderlyingRustTuple<'a> = ();
1214 #[cfg(test)]
1215 #[allow(dead_code, unreachable_patterns)]
1216 fn _type_assertion(
1217 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1218 ) {
1219 match _t {
1220 alloy_sol_types::private::AssertTypeEq::<
1221 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1222 >(_) => {}
1223 }
1224 }
1225 #[automatically_derived]
1226 #[doc(hidden)]
1227 impl ::core::convert::From<OnlyStrategyManager> for UnderlyingRustTuple<'_> {
1228 fn from(value: OnlyStrategyManager) -> Self {
1229 ()
1230 }
1231 }
1232 #[automatically_derived]
1233 #[doc(hidden)]
1234 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyStrategyManager {
1235 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1236 Self
1237 }
1238 }
1239 #[automatically_derived]
1240 impl alloy_sol_types::SolError for OnlyStrategyManager {
1241 type Parameters<'a> = UnderlyingSolTuple<'a>;
1242 type Token<'a> = <Self::Parameters<
1243 'a,
1244 > as alloy_sol_types::SolType>::Token<'a>;
1245 const SIGNATURE: &'static str = "OnlyStrategyManager()";
1246 const SELECTOR: [u8; 4] = [72u8, 218u8, 113u8, 79u8];
1247 #[inline]
1248 fn new<'a>(
1249 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1250 ) -> Self {
1251 tuple.into()
1252 }
1253 #[inline]
1254 fn tokenize(&self) -> Self::Token<'_> {
1255 ()
1256 }
1257 #[inline]
1258 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1259 <Self::Parameters<
1260 '_,
1261 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1262 .map(Self::new)
1263 }
1264 }
1265 };
1266 #[derive(serde::Serialize, serde::Deserialize)]
1267 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1268 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1273 #[derive(Clone)]
1274 pub struct OnlyUnderlyingToken;
1275 #[allow(
1276 non_camel_case_types,
1277 non_snake_case,
1278 clippy::pub_underscore_fields,
1279 clippy::style
1280 )]
1281 const _: () = {
1282 use alloy::sol_types as alloy_sol_types;
1283 #[doc(hidden)]
1284 type UnderlyingSolTuple<'a> = ();
1285 #[doc(hidden)]
1286 type UnderlyingRustTuple<'a> = ();
1287 #[cfg(test)]
1288 #[allow(dead_code, unreachable_patterns)]
1289 fn _type_assertion(
1290 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1291 ) {
1292 match _t {
1293 alloy_sol_types::private::AssertTypeEq::<
1294 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1295 >(_) => {}
1296 }
1297 }
1298 #[automatically_derived]
1299 #[doc(hidden)]
1300 impl ::core::convert::From<OnlyUnderlyingToken> for UnderlyingRustTuple<'_> {
1301 fn from(value: OnlyUnderlyingToken) -> Self {
1302 ()
1303 }
1304 }
1305 #[automatically_derived]
1306 #[doc(hidden)]
1307 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnderlyingToken {
1308 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1309 Self
1310 }
1311 }
1312 #[automatically_derived]
1313 impl alloy_sol_types::SolError for OnlyUnderlyingToken {
1314 type Parameters<'a> = UnderlyingSolTuple<'a>;
1315 type Token<'a> = <Self::Parameters<
1316 'a,
1317 > as alloy_sol_types::SolType>::Token<'a>;
1318 const SIGNATURE: &'static str = "OnlyUnderlyingToken()";
1319 const SELECTOR: [u8; 4] = [196u8, 170u8, 247u8, 64u8];
1320 #[inline]
1321 fn new<'a>(
1322 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1323 ) -> Self {
1324 tuple.into()
1325 }
1326 #[inline]
1327 fn tokenize(&self) -> Self::Token<'_> {
1328 ()
1329 }
1330 #[inline]
1331 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1332 <Self::Parameters<
1333 '_,
1334 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1335 .map(Self::new)
1336 }
1337 }
1338 };
1339 #[derive(serde::Serialize, serde::Deserialize)]
1340 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1341 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1346 #[derive(Clone)]
1347 pub struct OnlyUnpauser;
1348 #[allow(
1349 non_camel_case_types,
1350 non_snake_case,
1351 clippy::pub_underscore_fields,
1352 clippy::style
1353 )]
1354 const _: () = {
1355 use alloy::sol_types as alloy_sol_types;
1356 #[doc(hidden)]
1357 type UnderlyingSolTuple<'a> = ();
1358 #[doc(hidden)]
1359 type UnderlyingRustTuple<'a> = ();
1360 #[cfg(test)]
1361 #[allow(dead_code, unreachable_patterns)]
1362 fn _type_assertion(
1363 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1364 ) {
1365 match _t {
1366 alloy_sol_types::private::AssertTypeEq::<
1367 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1368 >(_) => {}
1369 }
1370 }
1371 #[automatically_derived]
1372 #[doc(hidden)]
1373 impl ::core::convert::From<OnlyUnpauser> for UnderlyingRustTuple<'_> {
1374 fn from(value: OnlyUnpauser) -> Self {
1375 ()
1376 }
1377 }
1378 #[automatically_derived]
1379 #[doc(hidden)]
1380 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnpauser {
1381 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1382 Self
1383 }
1384 }
1385 #[automatically_derived]
1386 impl alloy_sol_types::SolError for OnlyUnpauser {
1387 type Parameters<'a> = UnderlyingSolTuple<'a>;
1388 type Token<'a> = <Self::Parameters<
1389 'a,
1390 > as alloy_sol_types::SolType>::Token<'a>;
1391 const SIGNATURE: &'static str = "OnlyUnpauser()";
1392 const SELECTOR: [u8; 4] = [121u8, 72u8, 33u8, 255u8];
1393 #[inline]
1394 fn new<'a>(
1395 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1396 ) -> Self {
1397 tuple.into()
1398 }
1399 #[inline]
1400 fn tokenize(&self) -> Self::Token<'_> {
1401 ()
1402 }
1403 #[inline]
1404 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1405 <Self::Parameters<
1406 '_,
1407 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1408 .map(Self::new)
1409 }
1410 }
1411 };
1412 #[derive(serde::Serialize, serde::Deserialize)]
1413 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1414 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1419 #[derive(Clone)]
1420 pub struct StringTooLong {
1421 #[allow(missing_docs)]
1422 pub str: alloy::sol_types::private::String,
1423 }
1424 #[allow(
1425 non_camel_case_types,
1426 non_snake_case,
1427 clippy::pub_underscore_fields,
1428 clippy::style
1429 )]
1430 const _: () = {
1431 use alloy::sol_types as alloy_sol_types;
1432 #[doc(hidden)]
1433 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1434 #[doc(hidden)]
1435 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1436 #[cfg(test)]
1437 #[allow(dead_code, unreachable_patterns)]
1438 fn _type_assertion(
1439 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1440 ) {
1441 match _t {
1442 alloy_sol_types::private::AssertTypeEq::<
1443 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1444 >(_) => {}
1445 }
1446 }
1447 #[automatically_derived]
1448 #[doc(hidden)]
1449 impl ::core::convert::From<StringTooLong> for UnderlyingRustTuple<'_> {
1450 fn from(value: StringTooLong) -> Self {
1451 (value.str,)
1452 }
1453 }
1454 #[automatically_derived]
1455 #[doc(hidden)]
1456 impl ::core::convert::From<UnderlyingRustTuple<'_>> for StringTooLong {
1457 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1458 Self { str: tuple.0 }
1459 }
1460 }
1461 #[automatically_derived]
1462 impl alloy_sol_types::SolError for StringTooLong {
1463 type Parameters<'a> = UnderlyingSolTuple<'a>;
1464 type Token<'a> = <Self::Parameters<
1465 'a,
1466 > as alloy_sol_types::SolType>::Token<'a>;
1467 const SIGNATURE: &'static str = "StringTooLong(string)";
1468 const SELECTOR: [u8; 4] = [48u8, 90u8, 39u8, 169u8];
1469 #[inline]
1470 fn new<'a>(
1471 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1472 ) -> Self {
1473 tuple.into()
1474 }
1475 #[inline]
1476 fn tokenize(&self) -> Self::Token<'_> {
1477 (
1478 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1479 &self.str,
1480 ),
1481 )
1482 }
1483 #[inline]
1484 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1485 <Self::Parameters<
1486 '_,
1487 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1488 .map(Self::new)
1489 }
1490 }
1491 };
1492 #[derive(serde::Serialize, serde::Deserialize)]
1493 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1494 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1499 #[derive(Clone)]
1500 pub struct TotalSharesExceedsMax;
1501 #[allow(
1502 non_camel_case_types,
1503 non_snake_case,
1504 clippy::pub_underscore_fields,
1505 clippy::style
1506 )]
1507 const _: () = {
1508 use alloy::sol_types as alloy_sol_types;
1509 #[doc(hidden)]
1510 type UnderlyingSolTuple<'a> = ();
1511 #[doc(hidden)]
1512 type UnderlyingRustTuple<'a> = ();
1513 #[cfg(test)]
1514 #[allow(dead_code, unreachable_patterns)]
1515 fn _type_assertion(
1516 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1517 ) {
1518 match _t {
1519 alloy_sol_types::private::AssertTypeEq::<
1520 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1521 >(_) => {}
1522 }
1523 }
1524 #[automatically_derived]
1525 #[doc(hidden)]
1526 impl ::core::convert::From<TotalSharesExceedsMax> for UnderlyingRustTuple<'_> {
1527 fn from(value: TotalSharesExceedsMax) -> Self {
1528 ()
1529 }
1530 }
1531 #[automatically_derived]
1532 #[doc(hidden)]
1533 impl ::core::convert::From<UnderlyingRustTuple<'_>> for TotalSharesExceedsMax {
1534 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1535 Self
1536 }
1537 }
1538 #[automatically_derived]
1539 impl alloy_sol_types::SolError for TotalSharesExceedsMax {
1540 type Parameters<'a> = UnderlyingSolTuple<'a>;
1541 type Token<'a> = <Self::Parameters<
1542 'a,
1543 > as alloy_sol_types::SolType>::Token<'a>;
1544 const SIGNATURE: &'static str = "TotalSharesExceedsMax()";
1545 const SELECTOR: [u8; 4] = [94u8, 41u8, 209u8, 70u8];
1546 #[inline]
1547 fn new<'a>(
1548 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1549 ) -> Self {
1550 tuple.into()
1551 }
1552 #[inline]
1553 fn tokenize(&self) -> Self::Token<'_> {
1554 ()
1555 }
1556 #[inline]
1557 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1558 <Self::Parameters<
1559 '_,
1560 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1561 .map(Self::new)
1562 }
1563 }
1564 };
1565 #[derive(serde::Serialize, serde::Deserialize)]
1566 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1567 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1572 #[derive(Clone)]
1573 pub struct WithdrawalAmountExceedsTotalDeposits;
1574 #[allow(
1575 non_camel_case_types,
1576 non_snake_case,
1577 clippy::pub_underscore_fields,
1578 clippy::style
1579 )]
1580 const _: () = {
1581 use alloy::sol_types as alloy_sol_types;
1582 #[doc(hidden)]
1583 type UnderlyingSolTuple<'a> = ();
1584 #[doc(hidden)]
1585 type UnderlyingRustTuple<'a> = ();
1586 #[cfg(test)]
1587 #[allow(dead_code, unreachable_patterns)]
1588 fn _type_assertion(
1589 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1590 ) {
1591 match _t {
1592 alloy_sol_types::private::AssertTypeEq::<
1593 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1594 >(_) => {}
1595 }
1596 }
1597 #[automatically_derived]
1598 #[doc(hidden)]
1599 impl ::core::convert::From<WithdrawalAmountExceedsTotalDeposits>
1600 for UnderlyingRustTuple<'_> {
1601 fn from(value: WithdrawalAmountExceedsTotalDeposits) -> Self {
1602 ()
1603 }
1604 }
1605 #[automatically_derived]
1606 #[doc(hidden)]
1607 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1608 for WithdrawalAmountExceedsTotalDeposits {
1609 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1610 Self
1611 }
1612 }
1613 #[automatically_derived]
1614 impl alloy_sol_types::SolError for WithdrawalAmountExceedsTotalDeposits {
1615 type Parameters<'a> = UnderlyingSolTuple<'a>;
1616 type Token<'a> = <Self::Parameters<
1617 'a,
1618 > as alloy_sol_types::SolType>::Token<'a>;
1619 const SIGNATURE: &'static str = "WithdrawalAmountExceedsTotalDeposits()";
1620 const SELECTOR: [u8; 4] = [180u8, 105u8, 223u8, 48u8];
1621 #[inline]
1622 fn new<'a>(
1623 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1624 ) -> Self {
1625 tuple.into()
1626 }
1627 #[inline]
1628 fn tokenize(&self) -> Self::Token<'_> {
1629 ()
1630 }
1631 #[inline]
1632 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1633 <Self::Parameters<
1634 '_,
1635 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1636 .map(Self::new)
1637 }
1638 }
1639 };
1640 #[derive(serde::Serialize, serde::Deserialize)]
1641 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1642 #[allow(
1647 non_camel_case_types,
1648 non_snake_case,
1649 clippy::pub_underscore_fields,
1650 clippy::style
1651 )]
1652 #[derive(Clone)]
1653 pub struct ExchangeRateEmitted {
1654 #[allow(missing_docs)]
1655 pub rate: alloy::sol_types::private::primitives::aliases::U256,
1656 }
1657 #[allow(
1658 non_camel_case_types,
1659 non_snake_case,
1660 clippy::pub_underscore_fields,
1661 clippy::style
1662 )]
1663 const _: () = {
1664 use alloy::sol_types as alloy_sol_types;
1665 #[automatically_derived]
1666 impl alloy_sol_types::SolEvent for ExchangeRateEmitted {
1667 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1668 type DataToken<'a> = <Self::DataTuple<
1669 'a,
1670 > as alloy_sol_types::SolType>::Token<'a>;
1671 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1672 const SIGNATURE: &'static str = "ExchangeRateEmitted(uint256)";
1673 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1674 210u8, 73u8, 79u8, 52u8, 121u8, 229u8, 218u8, 73u8, 211u8, 134u8, 101u8,
1675 124u8, 41u8, 44u8, 97u8, 11u8, 91u8, 1u8, 223u8, 49u8, 61u8, 7u8, 198u8,
1676 46u8, 176u8, 207u8, 164u8, 153u8, 36u8, 163u8, 27u8, 232u8,
1677 ]);
1678 const ANONYMOUS: bool = false;
1679 #[allow(unused_variables)]
1680 #[inline]
1681 fn new(
1682 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1683 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1684 ) -> Self {
1685 Self { rate: data.0 }
1686 }
1687 #[inline]
1688 fn check_signature(
1689 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1690 ) -> alloy_sol_types::Result<()> {
1691 if topics.0 != Self::SIGNATURE_HASH {
1692 return Err(
1693 alloy_sol_types::Error::invalid_event_signature_hash(
1694 Self::SIGNATURE,
1695 topics.0,
1696 Self::SIGNATURE_HASH,
1697 ),
1698 );
1699 }
1700 Ok(())
1701 }
1702 #[inline]
1703 fn tokenize_body(&self) -> Self::DataToken<'_> {
1704 (
1705 <alloy::sol_types::sol_data::Uint<
1706 256,
1707 > as alloy_sol_types::SolType>::tokenize(&self.rate),
1708 )
1709 }
1710 #[inline]
1711 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1712 (Self::SIGNATURE_HASH.into(),)
1713 }
1714 #[inline]
1715 fn encode_topics_raw(
1716 &self,
1717 out: &mut [alloy_sol_types::abi::token::WordToken],
1718 ) -> alloy_sol_types::Result<()> {
1719 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1720 return Err(alloy_sol_types::Error::Overrun);
1721 }
1722 out[0usize] = alloy_sol_types::abi::token::WordToken(
1723 Self::SIGNATURE_HASH,
1724 );
1725 Ok(())
1726 }
1727 }
1728 #[automatically_derived]
1729 impl alloy_sol_types::private::IntoLogData for ExchangeRateEmitted {
1730 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1731 From::from(self)
1732 }
1733 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1734 From::from(&self)
1735 }
1736 }
1737 #[automatically_derived]
1738 impl From<&ExchangeRateEmitted> for alloy_sol_types::private::LogData {
1739 #[inline]
1740 fn from(this: &ExchangeRateEmitted) -> alloy_sol_types::private::LogData {
1741 alloy_sol_types::SolEvent::encode_log_data(this)
1742 }
1743 }
1744 };
1745 #[derive(serde::Serialize, serde::Deserialize)]
1746 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1747 #[allow(
1752 non_camel_case_types,
1753 non_snake_case,
1754 clippy::pub_underscore_fields,
1755 clippy::style
1756 )]
1757 #[derive(Clone)]
1758 pub struct Initialized {
1759 #[allow(missing_docs)]
1760 pub version: u8,
1761 }
1762 #[allow(
1763 non_camel_case_types,
1764 non_snake_case,
1765 clippy::pub_underscore_fields,
1766 clippy::style
1767 )]
1768 const _: () = {
1769 use alloy::sol_types as alloy_sol_types;
1770 #[automatically_derived]
1771 impl alloy_sol_types::SolEvent for Initialized {
1772 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
1773 type DataToken<'a> = <Self::DataTuple<
1774 'a,
1775 > as alloy_sol_types::SolType>::Token<'a>;
1776 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1777 const SIGNATURE: &'static str = "Initialized(uint8)";
1778 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1779 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
1780 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
1781 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
1782 ]);
1783 const ANONYMOUS: bool = false;
1784 #[allow(unused_variables)]
1785 #[inline]
1786 fn new(
1787 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1788 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1789 ) -> Self {
1790 Self { version: data.0 }
1791 }
1792 #[inline]
1793 fn check_signature(
1794 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1795 ) -> alloy_sol_types::Result<()> {
1796 if topics.0 != Self::SIGNATURE_HASH {
1797 return Err(
1798 alloy_sol_types::Error::invalid_event_signature_hash(
1799 Self::SIGNATURE,
1800 topics.0,
1801 Self::SIGNATURE_HASH,
1802 ),
1803 );
1804 }
1805 Ok(())
1806 }
1807 #[inline]
1808 fn tokenize_body(&self) -> Self::DataToken<'_> {
1809 (
1810 <alloy::sol_types::sol_data::Uint<
1811 8,
1812 > as alloy_sol_types::SolType>::tokenize(&self.version),
1813 )
1814 }
1815 #[inline]
1816 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1817 (Self::SIGNATURE_HASH.into(),)
1818 }
1819 #[inline]
1820 fn encode_topics_raw(
1821 &self,
1822 out: &mut [alloy_sol_types::abi::token::WordToken],
1823 ) -> alloy_sol_types::Result<()> {
1824 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1825 return Err(alloy_sol_types::Error::Overrun);
1826 }
1827 out[0usize] = alloy_sol_types::abi::token::WordToken(
1828 Self::SIGNATURE_HASH,
1829 );
1830 Ok(())
1831 }
1832 }
1833 #[automatically_derived]
1834 impl alloy_sol_types::private::IntoLogData for Initialized {
1835 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1836 From::from(self)
1837 }
1838 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1839 From::from(&self)
1840 }
1841 }
1842 #[automatically_derived]
1843 impl From<&Initialized> for alloy_sol_types::private::LogData {
1844 #[inline]
1845 fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
1846 alloy_sol_types::SolEvent::encode_log_data(this)
1847 }
1848 }
1849 };
1850 #[derive(serde::Serialize, serde::Deserialize)]
1851 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1852 #[allow(
1857 non_camel_case_types,
1858 non_snake_case,
1859 clippy::pub_underscore_fields,
1860 clippy::style
1861 )]
1862 #[derive(Clone)]
1863 pub struct Paused {
1864 #[allow(missing_docs)]
1865 pub account: alloy::sol_types::private::Address,
1866 #[allow(missing_docs)]
1867 pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
1868 }
1869 #[allow(
1870 non_camel_case_types,
1871 non_snake_case,
1872 clippy::pub_underscore_fields,
1873 clippy::style
1874 )]
1875 const _: () = {
1876 use alloy::sol_types as alloy_sol_types;
1877 #[automatically_derived]
1878 impl alloy_sol_types::SolEvent for Paused {
1879 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1880 type DataToken<'a> = <Self::DataTuple<
1881 'a,
1882 > as alloy_sol_types::SolType>::Token<'a>;
1883 type TopicList = (
1884 alloy_sol_types::sol_data::FixedBytes<32>,
1885 alloy::sol_types::sol_data::Address,
1886 );
1887 const SIGNATURE: &'static str = "Paused(address,uint256)";
1888 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1889 171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8,
1890 188u8, 152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8,
1891 11u8, 182u8, 224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
1892 ]);
1893 const ANONYMOUS: bool = false;
1894 #[allow(unused_variables)]
1895 #[inline]
1896 fn new(
1897 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1898 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1899 ) -> Self {
1900 Self {
1901 account: topics.1,
1902 newPausedStatus: data.0,
1903 }
1904 }
1905 #[inline]
1906 fn check_signature(
1907 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1908 ) -> alloy_sol_types::Result<()> {
1909 if topics.0 != Self::SIGNATURE_HASH {
1910 return Err(
1911 alloy_sol_types::Error::invalid_event_signature_hash(
1912 Self::SIGNATURE,
1913 topics.0,
1914 Self::SIGNATURE_HASH,
1915 ),
1916 );
1917 }
1918 Ok(())
1919 }
1920 #[inline]
1921 fn tokenize_body(&self) -> Self::DataToken<'_> {
1922 (
1923 <alloy::sol_types::sol_data::Uint<
1924 256,
1925 > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
1926 )
1927 }
1928 #[inline]
1929 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1930 (Self::SIGNATURE_HASH.into(), self.account.clone())
1931 }
1932 #[inline]
1933 fn encode_topics_raw(
1934 &self,
1935 out: &mut [alloy_sol_types::abi::token::WordToken],
1936 ) -> alloy_sol_types::Result<()> {
1937 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1938 return Err(alloy_sol_types::Error::Overrun);
1939 }
1940 out[0usize] = alloy_sol_types::abi::token::WordToken(
1941 Self::SIGNATURE_HASH,
1942 );
1943 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1944 &self.account,
1945 );
1946 Ok(())
1947 }
1948 }
1949 #[automatically_derived]
1950 impl alloy_sol_types::private::IntoLogData for Paused {
1951 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1952 From::from(self)
1953 }
1954 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1955 From::from(&self)
1956 }
1957 }
1958 #[automatically_derived]
1959 impl From<&Paused> for alloy_sol_types::private::LogData {
1960 #[inline]
1961 fn from(this: &Paused) -> alloy_sol_types::private::LogData {
1962 alloy_sol_types::SolEvent::encode_log_data(this)
1963 }
1964 }
1965 };
1966 #[derive(serde::Serialize, serde::Deserialize)]
1967 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1968 #[allow(
1973 non_camel_case_types,
1974 non_snake_case,
1975 clippy::pub_underscore_fields,
1976 clippy::style
1977 )]
1978 #[derive(Clone)]
1979 pub struct StrategyTokenSet {
1980 #[allow(missing_docs)]
1981 pub token: alloy::sol_types::private::Address,
1982 #[allow(missing_docs)]
1983 pub decimals: u8,
1984 }
1985 #[allow(
1986 non_camel_case_types,
1987 non_snake_case,
1988 clippy::pub_underscore_fields,
1989 clippy::style
1990 )]
1991 const _: () = {
1992 use alloy::sol_types as alloy_sol_types;
1993 #[automatically_derived]
1994 impl alloy_sol_types::SolEvent for StrategyTokenSet {
1995 type DataTuple<'a> = (
1996 alloy::sol_types::sol_data::Address,
1997 alloy::sol_types::sol_data::Uint<8>,
1998 );
1999 type DataToken<'a> = <Self::DataTuple<
2000 'a,
2001 > as alloy_sol_types::SolType>::Token<'a>;
2002 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
2003 const SIGNATURE: &'static str = "StrategyTokenSet(address,uint8)";
2004 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2005 28u8, 84u8, 7u8, 7u8, 176u8, 14u8, 181u8, 66u8, 123u8, 107u8, 119u8,
2006 79u8, 199u8, 153u8, 215u8, 86u8, 81u8, 106u8, 84u8, 174u8, 225u8, 8u8,
2007 182u8, 75u8, 50u8, 122u8, 204u8, 85u8, 175u8, 85u8, 117u8, 7u8,
2008 ]);
2009 const ANONYMOUS: bool = false;
2010 #[allow(unused_variables)]
2011 #[inline]
2012 fn new(
2013 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2014 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2015 ) -> Self {
2016 Self {
2017 token: data.0,
2018 decimals: data.1,
2019 }
2020 }
2021 #[inline]
2022 fn check_signature(
2023 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2024 ) -> alloy_sol_types::Result<()> {
2025 if topics.0 != Self::SIGNATURE_HASH {
2026 return Err(
2027 alloy_sol_types::Error::invalid_event_signature_hash(
2028 Self::SIGNATURE,
2029 topics.0,
2030 Self::SIGNATURE_HASH,
2031 ),
2032 );
2033 }
2034 Ok(())
2035 }
2036 #[inline]
2037 fn tokenize_body(&self) -> Self::DataToken<'_> {
2038 (
2039 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2040 &self.token,
2041 ),
2042 <alloy::sol_types::sol_data::Uint<
2043 8,
2044 > as alloy_sol_types::SolType>::tokenize(&self.decimals),
2045 )
2046 }
2047 #[inline]
2048 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2049 (Self::SIGNATURE_HASH.into(),)
2050 }
2051 #[inline]
2052 fn encode_topics_raw(
2053 &self,
2054 out: &mut [alloy_sol_types::abi::token::WordToken],
2055 ) -> alloy_sol_types::Result<()> {
2056 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2057 return Err(alloy_sol_types::Error::Overrun);
2058 }
2059 out[0usize] = alloy_sol_types::abi::token::WordToken(
2060 Self::SIGNATURE_HASH,
2061 );
2062 Ok(())
2063 }
2064 }
2065 #[automatically_derived]
2066 impl alloy_sol_types::private::IntoLogData for StrategyTokenSet {
2067 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2068 From::from(self)
2069 }
2070 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2071 From::from(&self)
2072 }
2073 }
2074 #[automatically_derived]
2075 impl From<&StrategyTokenSet> for alloy_sol_types::private::LogData {
2076 #[inline]
2077 fn from(this: &StrategyTokenSet) -> alloy_sol_types::private::LogData {
2078 alloy_sol_types::SolEvent::encode_log_data(this)
2079 }
2080 }
2081 };
2082 #[derive(serde::Serialize, serde::Deserialize)]
2083 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2084 #[allow(
2089 non_camel_case_types,
2090 non_snake_case,
2091 clippy::pub_underscore_fields,
2092 clippy::style
2093 )]
2094 #[derive(Clone)]
2095 pub struct Unpaused {
2096 #[allow(missing_docs)]
2097 pub account: alloy::sol_types::private::Address,
2098 #[allow(missing_docs)]
2099 pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
2100 }
2101 #[allow(
2102 non_camel_case_types,
2103 non_snake_case,
2104 clippy::pub_underscore_fields,
2105 clippy::style
2106 )]
2107 const _: () = {
2108 use alloy::sol_types as alloy_sol_types;
2109 #[automatically_derived]
2110 impl alloy_sol_types::SolEvent for Unpaused {
2111 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2112 type DataToken<'a> = <Self::DataTuple<
2113 'a,
2114 > as alloy_sol_types::SolType>::Token<'a>;
2115 type TopicList = (
2116 alloy_sol_types::sol_data::FixedBytes<32>,
2117 alloy::sol_types::sol_data::Address,
2118 );
2119 const SIGNATURE: &'static str = "Unpaused(address,uint256)";
2120 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2121 53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8,
2122 2u8, 188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8,
2123 228u8, 152u8, 107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
2124 ]);
2125 const ANONYMOUS: bool = false;
2126 #[allow(unused_variables)]
2127 #[inline]
2128 fn new(
2129 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2130 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2131 ) -> Self {
2132 Self {
2133 account: topics.1,
2134 newPausedStatus: data.0,
2135 }
2136 }
2137 #[inline]
2138 fn check_signature(
2139 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2140 ) -> alloy_sol_types::Result<()> {
2141 if topics.0 != Self::SIGNATURE_HASH {
2142 return Err(
2143 alloy_sol_types::Error::invalid_event_signature_hash(
2144 Self::SIGNATURE,
2145 topics.0,
2146 Self::SIGNATURE_HASH,
2147 ),
2148 );
2149 }
2150 Ok(())
2151 }
2152 #[inline]
2153 fn tokenize_body(&self) -> Self::DataToken<'_> {
2154 (
2155 <alloy::sol_types::sol_data::Uint<
2156 256,
2157 > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
2158 )
2159 }
2160 #[inline]
2161 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2162 (Self::SIGNATURE_HASH.into(), self.account.clone())
2163 }
2164 #[inline]
2165 fn encode_topics_raw(
2166 &self,
2167 out: &mut [alloy_sol_types::abi::token::WordToken],
2168 ) -> alloy_sol_types::Result<()> {
2169 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2170 return Err(alloy_sol_types::Error::Overrun);
2171 }
2172 out[0usize] = alloy_sol_types::abi::token::WordToken(
2173 Self::SIGNATURE_HASH,
2174 );
2175 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2176 &self.account,
2177 );
2178 Ok(())
2179 }
2180 }
2181 #[automatically_derived]
2182 impl alloy_sol_types::private::IntoLogData for Unpaused {
2183 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2184 From::from(self)
2185 }
2186 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2187 From::from(&self)
2188 }
2189 }
2190 #[automatically_derived]
2191 impl From<&Unpaused> for alloy_sol_types::private::LogData {
2192 #[inline]
2193 fn from(this: &Unpaused) -> alloy_sol_types::private::LogData {
2194 alloy_sol_types::SolEvent::encode_log_data(this)
2195 }
2196 }
2197 };
2198 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2203 #[derive(Clone)]
2204 pub struct constructorCall {
2205 #[allow(missing_docs)]
2206 pub _strategyManager: alloy::sol_types::private::Address,
2207 #[allow(missing_docs)]
2208 pub _pauserRegistry: alloy::sol_types::private::Address,
2209 #[allow(missing_docs)]
2210 pub _version: alloy::sol_types::private::String,
2211 }
2212 const _: () = {
2213 use alloy::sol_types as alloy_sol_types;
2214 {
2215 #[doc(hidden)]
2216 type UnderlyingSolTuple<'a> = (
2217 alloy::sol_types::sol_data::Address,
2218 alloy::sol_types::sol_data::Address,
2219 alloy::sol_types::sol_data::String,
2220 );
2221 #[doc(hidden)]
2222 type UnderlyingRustTuple<'a> = (
2223 alloy::sol_types::private::Address,
2224 alloy::sol_types::private::Address,
2225 alloy::sol_types::private::String,
2226 );
2227 #[cfg(test)]
2228 #[allow(dead_code, unreachable_patterns)]
2229 fn _type_assertion(
2230 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2231 ) {
2232 match _t {
2233 alloy_sol_types::private::AssertTypeEq::<
2234 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2235 >(_) => {}
2236 }
2237 }
2238 #[automatically_derived]
2239 #[doc(hidden)]
2240 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
2241 fn from(value: constructorCall) -> Self {
2242 (value._strategyManager, value._pauserRegistry, value._version)
2243 }
2244 }
2245 #[automatically_derived]
2246 #[doc(hidden)]
2247 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
2248 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2249 Self {
2250 _strategyManager: tuple.0,
2251 _pauserRegistry: tuple.1,
2252 _version: tuple.2,
2253 }
2254 }
2255 }
2256 }
2257 #[automatically_derived]
2258 impl alloy_sol_types::SolConstructor for constructorCall {
2259 type Parameters<'a> = (
2260 alloy::sol_types::sol_data::Address,
2261 alloy::sol_types::sol_data::Address,
2262 alloy::sol_types::sol_data::String,
2263 );
2264 type Token<'a> = <Self::Parameters<
2265 'a,
2266 > as alloy_sol_types::SolType>::Token<'a>;
2267 #[inline]
2268 fn new<'a>(
2269 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2270 ) -> Self {
2271 tuple.into()
2272 }
2273 #[inline]
2274 fn tokenize(&self) -> Self::Token<'_> {
2275 (
2276 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2277 &self._strategyManager,
2278 ),
2279 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2280 &self._pauserRegistry,
2281 ),
2282 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
2283 &self._version,
2284 ),
2285 )
2286 }
2287 }
2288 };
2289 #[derive(serde::Serialize, serde::Deserialize)]
2290 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2291 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2296 #[derive(Clone)]
2297 pub struct depositCall {
2298 #[allow(missing_docs)]
2299 pub token: alloy::sol_types::private::Address,
2300 #[allow(missing_docs)]
2301 pub amount: alloy::sol_types::private::primitives::aliases::U256,
2302 }
2303 #[derive(serde::Serialize, serde::Deserialize)]
2304 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2305 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2307 #[derive(Clone)]
2308 pub struct depositReturn {
2309 #[allow(missing_docs)]
2310 pub newShares: alloy::sol_types::private::primitives::aliases::U256,
2311 }
2312 #[allow(
2313 non_camel_case_types,
2314 non_snake_case,
2315 clippy::pub_underscore_fields,
2316 clippy::style
2317 )]
2318 const _: () = {
2319 use alloy::sol_types as alloy_sol_types;
2320 {
2321 #[doc(hidden)]
2322 type UnderlyingSolTuple<'a> = (
2323 alloy::sol_types::sol_data::Address,
2324 alloy::sol_types::sol_data::Uint<256>,
2325 );
2326 #[doc(hidden)]
2327 type UnderlyingRustTuple<'a> = (
2328 alloy::sol_types::private::Address,
2329 alloy::sol_types::private::primitives::aliases::U256,
2330 );
2331 #[cfg(test)]
2332 #[allow(dead_code, unreachable_patterns)]
2333 fn _type_assertion(
2334 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2335 ) {
2336 match _t {
2337 alloy_sol_types::private::AssertTypeEq::<
2338 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2339 >(_) => {}
2340 }
2341 }
2342 #[automatically_derived]
2343 #[doc(hidden)]
2344 impl ::core::convert::From<depositCall> for UnderlyingRustTuple<'_> {
2345 fn from(value: depositCall) -> Self {
2346 (value.token, value.amount)
2347 }
2348 }
2349 #[automatically_derived]
2350 #[doc(hidden)]
2351 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositCall {
2352 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2353 Self {
2354 token: tuple.0,
2355 amount: tuple.1,
2356 }
2357 }
2358 }
2359 }
2360 {
2361 #[doc(hidden)]
2362 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2363 #[doc(hidden)]
2364 type UnderlyingRustTuple<'a> = (
2365 alloy::sol_types::private::primitives::aliases::U256,
2366 );
2367 #[cfg(test)]
2368 #[allow(dead_code, unreachable_patterns)]
2369 fn _type_assertion(
2370 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2371 ) {
2372 match _t {
2373 alloy_sol_types::private::AssertTypeEq::<
2374 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2375 >(_) => {}
2376 }
2377 }
2378 #[automatically_derived]
2379 #[doc(hidden)]
2380 impl ::core::convert::From<depositReturn> for UnderlyingRustTuple<'_> {
2381 fn from(value: depositReturn) -> Self {
2382 (value.newShares,)
2383 }
2384 }
2385 #[automatically_derived]
2386 #[doc(hidden)]
2387 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositReturn {
2388 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2389 Self { newShares: tuple.0 }
2390 }
2391 }
2392 }
2393 #[automatically_derived]
2394 impl alloy_sol_types::SolCall for depositCall {
2395 type Parameters<'a> = (
2396 alloy::sol_types::sol_data::Address,
2397 alloy::sol_types::sol_data::Uint<256>,
2398 );
2399 type Token<'a> = <Self::Parameters<
2400 'a,
2401 > as alloy_sol_types::SolType>::Token<'a>;
2402 type Return = alloy::sol_types::private::primitives::aliases::U256;
2403 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2404 type ReturnToken<'a> = <Self::ReturnTuple<
2405 'a,
2406 > as alloy_sol_types::SolType>::Token<'a>;
2407 const SIGNATURE: &'static str = "deposit(address,uint256)";
2408 const SELECTOR: [u8; 4] = [71u8, 231u8, 239u8, 36u8];
2409 #[inline]
2410 fn new<'a>(
2411 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2412 ) -> Self {
2413 tuple.into()
2414 }
2415 #[inline]
2416 fn tokenize(&self) -> Self::Token<'_> {
2417 (
2418 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2419 &self.token,
2420 ),
2421 <alloy::sol_types::sol_data::Uint<
2422 256,
2423 > as alloy_sol_types::SolType>::tokenize(&self.amount),
2424 )
2425 }
2426 #[inline]
2427 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2428 (
2429 <alloy::sol_types::sol_data::Uint<
2430 256,
2431 > as alloy_sol_types::SolType>::tokenize(ret),
2432 )
2433 }
2434 #[inline]
2435 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2436 <Self::ReturnTuple<
2437 '_,
2438 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2439 .map(|r| {
2440 let r: depositReturn = r.into();
2441 r.newShares
2442 })
2443 }
2444 #[inline]
2445 fn abi_decode_returns_validate(
2446 data: &[u8],
2447 ) -> alloy_sol_types::Result<Self::Return> {
2448 <Self::ReturnTuple<
2449 '_,
2450 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2451 .map(|r| {
2452 let r: depositReturn = r.into();
2453 r.newShares
2454 })
2455 }
2456 }
2457 };
2458 #[derive(serde::Serialize, serde::Deserialize)]
2459 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2460 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2465 #[derive(Clone)]
2466 pub struct explanationCall;
2467 #[derive(serde::Serialize, serde::Deserialize)]
2468 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2469 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2471 #[derive(Clone)]
2472 pub struct explanationReturn {
2473 #[allow(missing_docs)]
2474 pub _0: alloy::sol_types::private::String,
2475 }
2476 #[allow(
2477 non_camel_case_types,
2478 non_snake_case,
2479 clippy::pub_underscore_fields,
2480 clippy::style
2481 )]
2482 const _: () = {
2483 use alloy::sol_types as alloy_sol_types;
2484 {
2485 #[doc(hidden)]
2486 type UnderlyingSolTuple<'a> = ();
2487 #[doc(hidden)]
2488 type UnderlyingRustTuple<'a> = ();
2489 #[cfg(test)]
2490 #[allow(dead_code, unreachable_patterns)]
2491 fn _type_assertion(
2492 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2493 ) {
2494 match _t {
2495 alloy_sol_types::private::AssertTypeEq::<
2496 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2497 >(_) => {}
2498 }
2499 }
2500 #[automatically_derived]
2501 #[doc(hidden)]
2502 impl ::core::convert::From<explanationCall> for UnderlyingRustTuple<'_> {
2503 fn from(value: explanationCall) -> Self {
2504 ()
2505 }
2506 }
2507 #[automatically_derived]
2508 #[doc(hidden)]
2509 impl ::core::convert::From<UnderlyingRustTuple<'_>> for explanationCall {
2510 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2511 Self
2512 }
2513 }
2514 }
2515 {
2516 #[doc(hidden)]
2517 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2518 #[doc(hidden)]
2519 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2520 #[cfg(test)]
2521 #[allow(dead_code, unreachable_patterns)]
2522 fn _type_assertion(
2523 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2524 ) {
2525 match _t {
2526 alloy_sol_types::private::AssertTypeEq::<
2527 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2528 >(_) => {}
2529 }
2530 }
2531 #[automatically_derived]
2532 #[doc(hidden)]
2533 impl ::core::convert::From<explanationReturn> for UnderlyingRustTuple<'_> {
2534 fn from(value: explanationReturn) -> Self {
2535 (value._0,)
2536 }
2537 }
2538 #[automatically_derived]
2539 #[doc(hidden)]
2540 impl ::core::convert::From<UnderlyingRustTuple<'_>> for explanationReturn {
2541 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2542 Self { _0: tuple.0 }
2543 }
2544 }
2545 }
2546 #[automatically_derived]
2547 impl alloy_sol_types::SolCall for explanationCall {
2548 type Parameters<'a> = ();
2549 type Token<'a> = <Self::Parameters<
2550 'a,
2551 > as alloy_sol_types::SolType>::Token<'a>;
2552 type Return = alloy::sol_types::private::String;
2553 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2554 type ReturnToken<'a> = <Self::ReturnTuple<
2555 'a,
2556 > as alloy_sol_types::SolType>::Token<'a>;
2557 const SIGNATURE: &'static str = "explanation()";
2558 const SELECTOR: [u8; 4] = [171u8, 89u8, 33u8, 225u8];
2559 #[inline]
2560 fn new<'a>(
2561 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2562 ) -> Self {
2563 tuple.into()
2564 }
2565 #[inline]
2566 fn tokenize(&self) -> Self::Token<'_> {
2567 ()
2568 }
2569 #[inline]
2570 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2571 (
2572 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
2573 ret,
2574 ),
2575 )
2576 }
2577 #[inline]
2578 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2579 <Self::ReturnTuple<
2580 '_,
2581 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2582 .map(|r| {
2583 let r: explanationReturn = r.into();
2584 r._0
2585 })
2586 }
2587 #[inline]
2588 fn abi_decode_returns_validate(
2589 data: &[u8],
2590 ) -> alloy_sol_types::Result<Self::Return> {
2591 <Self::ReturnTuple<
2592 '_,
2593 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2594 .map(|r| {
2595 let r: explanationReturn = r.into();
2596 r._0
2597 })
2598 }
2599 }
2600 };
2601 #[derive(serde::Serialize, serde::Deserialize)]
2602 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2603 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2608 #[derive(Clone)]
2609 pub struct initializeCall {
2610 #[allow(missing_docs)]
2611 pub _underlyingToken: alloy::sol_types::private::Address,
2612 }
2613 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2615 #[derive(Clone)]
2616 pub struct initializeReturn {}
2617 #[allow(
2618 non_camel_case_types,
2619 non_snake_case,
2620 clippy::pub_underscore_fields,
2621 clippy::style
2622 )]
2623 const _: () = {
2624 use alloy::sol_types as alloy_sol_types;
2625 {
2626 #[doc(hidden)]
2627 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2628 #[doc(hidden)]
2629 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2630 #[cfg(test)]
2631 #[allow(dead_code, unreachable_patterns)]
2632 fn _type_assertion(
2633 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2634 ) {
2635 match _t {
2636 alloy_sol_types::private::AssertTypeEq::<
2637 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2638 >(_) => {}
2639 }
2640 }
2641 #[automatically_derived]
2642 #[doc(hidden)]
2643 impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
2644 fn from(value: initializeCall) -> Self {
2645 (value._underlyingToken,)
2646 }
2647 }
2648 #[automatically_derived]
2649 #[doc(hidden)]
2650 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
2651 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2652 Self { _underlyingToken: tuple.0 }
2653 }
2654 }
2655 }
2656 {
2657 #[doc(hidden)]
2658 type UnderlyingSolTuple<'a> = ();
2659 #[doc(hidden)]
2660 type UnderlyingRustTuple<'a> = ();
2661 #[cfg(test)]
2662 #[allow(dead_code, unreachable_patterns)]
2663 fn _type_assertion(
2664 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2665 ) {
2666 match _t {
2667 alloy_sol_types::private::AssertTypeEq::<
2668 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2669 >(_) => {}
2670 }
2671 }
2672 #[automatically_derived]
2673 #[doc(hidden)]
2674 impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
2675 fn from(value: initializeReturn) -> Self {
2676 ()
2677 }
2678 }
2679 #[automatically_derived]
2680 #[doc(hidden)]
2681 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
2682 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2683 Self {}
2684 }
2685 }
2686 }
2687 impl initializeReturn {
2688 fn _tokenize(
2689 &self,
2690 ) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2691 ()
2692 }
2693 }
2694 #[automatically_derived]
2695 impl alloy_sol_types::SolCall for initializeCall {
2696 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2697 type Token<'a> = <Self::Parameters<
2698 'a,
2699 > as alloy_sol_types::SolType>::Token<'a>;
2700 type Return = initializeReturn;
2701 type ReturnTuple<'a> = ();
2702 type ReturnToken<'a> = <Self::ReturnTuple<
2703 'a,
2704 > as alloy_sol_types::SolType>::Token<'a>;
2705 const SIGNATURE: &'static str = "initialize(address)";
2706 const SELECTOR: [u8; 4] = [196u8, 214u8, 109u8, 232u8];
2707 #[inline]
2708 fn new<'a>(
2709 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2710 ) -> Self {
2711 tuple.into()
2712 }
2713 #[inline]
2714 fn tokenize(&self) -> Self::Token<'_> {
2715 (
2716 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2717 &self._underlyingToken,
2718 ),
2719 )
2720 }
2721 #[inline]
2722 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2723 initializeReturn::_tokenize(ret)
2724 }
2725 #[inline]
2726 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2727 <Self::ReturnTuple<
2728 '_,
2729 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2730 .map(Into::into)
2731 }
2732 #[inline]
2733 fn abi_decode_returns_validate(
2734 data: &[u8],
2735 ) -> alloy_sol_types::Result<Self::Return> {
2736 <Self::ReturnTuple<
2737 '_,
2738 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2739 .map(Into::into)
2740 }
2741 }
2742 };
2743 #[derive(serde::Serialize, serde::Deserialize)]
2744 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2745 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2750 #[derive(Clone)]
2751 pub struct pauseCall {
2752 #[allow(missing_docs)]
2753 pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
2754 }
2755 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2757 #[derive(Clone)]
2758 pub struct pauseReturn {}
2759 #[allow(
2760 non_camel_case_types,
2761 non_snake_case,
2762 clippy::pub_underscore_fields,
2763 clippy::style
2764 )]
2765 const _: () = {
2766 use alloy::sol_types as alloy_sol_types;
2767 {
2768 #[doc(hidden)]
2769 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2770 #[doc(hidden)]
2771 type UnderlyingRustTuple<'a> = (
2772 alloy::sol_types::private::primitives::aliases::U256,
2773 );
2774 #[cfg(test)]
2775 #[allow(dead_code, unreachable_patterns)]
2776 fn _type_assertion(
2777 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2778 ) {
2779 match _t {
2780 alloy_sol_types::private::AssertTypeEq::<
2781 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2782 >(_) => {}
2783 }
2784 }
2785 #[automatically_derived]
2786 #[doc(hidden)]
2787 impl ::core::convert::From<pauseCall> for UnderlyingRustTuple<'_> {
2788 fn from(value: pauseCall) -> Self {
2789 (value.newPausedStatus,)
2790 }
2791 }
2792 #[automatically_derived]
2793 #[doc(hidden)]
2794 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseCall {
2795 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2796 Self { newPausedStatus: tuple.0 }
2797 }
2798 }
2799 }
2800 {
2801 #[doc(hidden)]
2802 type UnderlyingSolTuple<'a> = ();
2803 #[doc(hidden)]
2804 type UnderlyingRustTuple<'a> = ();
2805 #[cfg(test)]
2806 #[allow(dead_code, unreachable_patterns)]
2807 fn _type_assertion(
2808 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2809 ) {
2810 match _t {
2811 alloy_sol_types::private::AssertTypeEq::<
2812 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2813 >(_) => {}
2814 }
2815 }
2816 #[automatically_derived]
2817 #[doc(hidden)]
2818 impl ::core::convert::From<pauseReturn> for UnderlyingRustTuple<'_> {
2819 fn from(value: pauseReturn) -> Self {
2820 ()
2821 }
2822 }
2823 #[automatically_derived]
2824 #[doc(hidden)]
2825 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseReturn {
2826 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2827 Self {}
2828 }
2829 }
2830 }
2831 impl pauseReturn {
2832 fn _tokenize(
2833 &self,
2834 ) -> <pauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2835 ()
2836 }
2837 }
2838 #[automatically_derived]
2839 impl alloy_sol_types::SolCall for pauseCall {
2840 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2841 type Token<'a> = <Self::Parameters<
2842 'a,
2843 > as alloy_sol_types::SolType>::Token<'a>;
2844 type Return = pauseReturn;
2845 type ReturnTuple<'a> = ();
2846 type ReturnToken<'a> = <Self::ReturnTuple<
2847 'a,
2848 > as alloy_sol_types::SolType>::Token<'a>;
2849 const SIGNATURE: &'static str = "pause(uint256)";
2850 const SELECTOR: [u8; 4] = [19u8, 100u8, 57u8, 221u8];
2851 #[inline]
2852 fn new<'a>(
2853 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2854 ) -> Self {
2855 tuple.into()
2856 }
2857 #[inline]
2858 fn tokenize(&self) -> Self::Token<'_> {
2859 (
2860 <alloy::sol_types::sol_data::Uint<
2861 256,
2862 > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
2863 )
2864 }
2865 #[inline]
2866 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2867 pauseReturn::_tokenize(ret)
2868 }
2869 #[inline]
2870 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2871 <Self::ReturnTuple<
2872 '_,
2873 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2874 .map(Into::into)
2875 }
2876 #[inline]
2877 fn abi_decode_returns_validate(
2878 data: &[u8],
2879 ) -> alloy_sol_types::Result<Self::Return> {
2880 <Self::ReturnTuple<
2881 '_,
2882 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2883 .map(Into::into)
2884 }
2885 }
2886 };
2887 #[derive(serde::Serialize, serde::Deserialize)]
2888 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2889 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2894 #[derive(Clone)]
2895 pub struct pauseAllCall;
2896 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2898 #[derive(Clone)]
2899 pub struct pauseAllReturn {}
2900 #[allow(
2901 non_camel_case_types,
2902 non_snake_case,
2903 clippy::pub_underscore_fields,
2904 clippy::style
2905 )]
2906 const _: () = {
2907 use alloy::sol_types as alloy_sol_types;
2908 {
2909 #[doc(hidden)]
2910 type UnderlyingSolTuple<'a> = ();
2911 #[doc(hidden)]
2912 type UnderlyingRustTuple<'a> = ();
2913 #[cfg(test)]
2914 #[allow(dead_code, unreachable_patterns)]
2915 fn _type_assertion(
2916 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2917 ) {
2918 match _t {
2919 alloy_sol_types::private::AssertTypeEq::<
2920 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2921 >(_) => {}
2922 }
2923 }
2924 #[automatically_derived]
2925 #[doc(hidden)]
2926 impl ::core::convert::From<pauseAllCall> for UnderlyingRustTuple<'_> {
2927 fn from(value: pauseAllCall) -> Self {
2928 ()
2929 }
2930 }
2931 #[automatically_derived]
2932 #[doc(hidden)]
2933 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllCall {
2934 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2935 Self
2936 }
2937 }
2938 }
2939 {
2940 #[doc(hidden)]
2941 type UnderlyingSolTuple<'a> = ();
2942 #[doc(hidden)]
2943 type UnderlyingRustTuple<'a> = ();
2944 #[cfg(test)]
2945 #[allow(dead_code, unreachable_patterns)]
2946 fn _type_assertion(
2947 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2948 ) {
2949 match _t {
2950 alloy_sol_types::private::AssertTypeEq::<
2951 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2952 >(_) => {}
2953 }
2954 }
2955 #[automatically_derived]
2956 #[doc(hidden)]
2957 impl ::core::convert::From<pauseAllReturn> for UnderlyingRustTuple<'_> {
2958 fn from(value: pauseAllReturn) -> Self {
2959 ()
2960 }
2961 }
2962 #[automatically_derived]
2963 #[doc(hidden)]
2964 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllReturn {
2965 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2966 Self {}
2967 }
2968 }
2969 }
2970 impl pauseAllReturn {
2971 fn _tokenize(
2972 &self,
2973 ) -> <pauseAllCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2974 ()
2975 }
2976 }
2977 #[automatically_derived]
2978 impl alloy_sol_types::SolCall for pauseAllCall {
2979 type Parameters<'a> = ();
2980 type Token<'a> = <Self::Parameters<
2981 'a,
2982 > as alloy_sol_types::SolType>::Token<'a>;
2983 type Return = pauseAllReturn;
2984 type ReturnTuple<'a> = ();
2985 type ReturnToken<'a> = <Self::ReturnTuple<
2986 'a,
2987 > as alloy_sol_types::SolType>::Token<'a>;
2988 const SIGNATURE: &'static str = "pauseAll()";
2989 const SELECTOR: [u8; 4] = [89u8, 92u8, 106u8, 103u8];
2990 #[inline]
2991 fn new<'a>(
2992 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2993 ) -> Self {
2994 tuple.into()
2995 }
2996 #[inline]
2997 fn tokenize(&self) -> Self::Token<'_> {
2998 ()
2999 }
3000 #[inline]
3001 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3002 pauseAllReturn::_tokenize(ret)
3003 }
3004 #[inline]
3005 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3006 <Self::ReturnTuple<
3007 '_,
3008 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3009 .map(Into::into)
3010 }
3011 #[inline]
3012 fn abi_decode_returns_validate(
3013 data: &[u8],
3014 ) -> alloy_sol_types::Result<Self::Return> {
3015 <Self::ReturnTuple<
3016 '_,
3017 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3018 .map(Into::into)
3019 }
3020 }
3021 };
3022 #[derive(serde::Serialize, serde::Deserialize)]
3023 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3024 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3029 #[derive(Clone)]
3030 pub struct paused_0Call {
3031 #[allow(missing_docs)]
3032 pub index: u8,
3033 }
3034 #[derive(serde::Serialize, serde::Deserialize)]
3035 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3036 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3038 #[derive(Clone)]
3039 pub struct paused_0Return {
3040 #[allow(missing_docs)]
3041 pub _0: bool,
3042 }
3043 #[allow(
3044 non_camel_case_types,
3045 non_snake_case,
3046 clippy::pub_underscore_fields,
3047 clippy::style
3048 )]
3049 const _: () = {
3050 use alloy::sol_types as alloy_sol_types;
3051 {
3052 #[doc(hidden)]
3053 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3054 #[doc(hidden)]
3055 type UnderlyingRustTuple<'a> = (u8,);
3056 #[cfg(test)]
3057 #[allow(dead_code, unreachable_patterns)]
3058 fn _type_assertion(
3059 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3060 ) {
3061 match _t {
3062 alloy_sol_types::private::AssertTypeEq::<
3063 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3064 >(_) => {}
3065 }
3066 }
3067 #[automatically_derived]
3068 #[doc(hidden)]
3069 impl ::core::convert::From<paused_0Call> for UnderlyingRustTuple<'_> {
3070 fn from(value: paused_0Call) -> Self {
3071 (value.index,)
3072 }
3073 }
3074 #[automatically_derived]
3075 #[doc(hidden)]
3076 impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Call {
3077 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3078 Self { index: tuple.0 }
3079 }
3080 }
3081 }
3082 {
3083 #[doc(hidden)]
3084 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3085 #[doc(hidden)]
3086 type UnderlyingRustTuple<'a> = (bool,);
3087 #[cfg(test)]
3088 #[allow(dead_code, unreachable_patterns)]
3089 fn _type_assertion(
3090 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3091 ) {
3092 match _t {
3093 alloy_sol_types::private::AssertTypeEq::<
3094 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3095 >(_) => {}
3096 }
3097 }
3098 #[automatically_derived]
3099 #[doc(hidden)]
3100 impl ::core::convert::From<paused_0Return> for UnderlyingRustTuple<'_> {
3101 fn from(value: paused_0Return) -> Self {
3102 (value._0,)
3103 }
3104 }
3105 #[automatically_derived]
3106 #[doc(hidden)]
3107 impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Return {
3108 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3109 Self { _0: tuple.0 }
3110 }
3111 }
3112 }
3113 #[automatically_derived]
3114 impl alloy_sol_types::SolCall for paused_0Call {
3115 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3116 type Token<'a> = <Self::Parameters<
3117 'a,
3118 > as alloy_sol_types::SolType>::Token<'a>;
3119 type Return = bool;
3120 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3121 type ReturnToken<'a> = <Self::ReturnTuple<
3122 'a,
3123 > as alloy_sol_types::SolType>::Token<'a>;
3124 const SIGNATURE: &'static str = "paused(uint8)";
3125 const SELECTOR: [u8; 4] = [90u8, 200u8, 106u8, 183u8];
3126 #[inline]
3127 fn new<'a>(
3128 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3129 ) -> Self {
3130 tuple.into()
3131 }
3132 #[inline]
3133 fn tokenize(&self) -> Self::Token<'_> {
3134 (
3135 <alloy::sol_types::sol_data::Uint<
3136 8,
3137 > as alloy_sol_types::SolType>::tokenize(&self.index),
3138 )
3139 }
3140 #[inline]
3141 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3142 (
3143 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
3144 ret,
3145 ),
3146 )
3147 }
3148 #[inline]
3149 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3150 <Self::ReturnTuple<
3151 '_,
3152 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3153 .map(|r| {
3154 let r: paused_0Return = r.into();
3155 r._0
3156 })
3157 }
3158 #[inline]
3159 fn abi_decode_returns_validate(
3160 data: &[u8],
3161 ) -> alloy_sol_types::Result<Self::Return> {
3162 <Self::ReturnTuple<
3163 '_,
3164 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3165 .map(|r| {
3166 let r: paused_0Return = r.into();
3167 r._0
3168 })
3169 }
3170 }
3171 };
3172 #[derive(serde::Serialize, serde::Deserialize)]
3173 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3174 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3179 #[derive(Clone)]
3180 pub struct paused_1Call;
3181 #[derive(serde::Serialize, serde::Deserialize)]
3182 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3183 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3185 #[derive(Clone)]
3186 pub struct paused_1Return {
3187 #[allow(missing_docs)]
3188 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3189 }
3190 #[allow(
3191 non_camel_case_types,
3192 non_snake_case,
3193 clippy::pub_underscore_fields,
3194 clippy::style
3195 )]
3196 const _: () = {
3197 use alloy::sol_types as alloy_sol_types;
3198 {
3199 #[doc(hidden)]
3200 type UnderlyingSolTuple<'a> = ();
3201 #[doc(hidden)]
3202 type UnderlyingRustTuple<'a> = ();
3203 #[cfg(test)]
3204 #[allow(dead_code, unreachable_patterns)]
3205 fn _type_assertion(
3206 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3207 ) {
3208 match _t {
3209 alloy_sol_types::private::AssertTypeEq::<
3210 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3211 >(_) => {}
3212 }
3213 }
3214 #[automatically_derived]
3215 #[doc(hidden)]
3216 impl ::core::convert::From<paused_1Call> for UnderlyingRustTuple<'_> {
3217 fn from(value: paused_1Call) -> Self {
3218 ()
3219 }
3220 }
3221 #[automatically_derived]
3222 #[doc(hidden)]
3223 impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Call {
3224 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3225 Self
3226 }
3227 }
3228 }
3229 {
3230 #[doc(hidden)]
3231 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3232 #[doc(hidden)]
3233 type UnderlyingRustTuple<'a> = (
3234 alloy::sol_types::private::primitives::aliases::U256,
3235 );
3236 #[cfg(test)]
3237 #[allow(dead_code, unreachable_patterns)]
3238 fn _type_assertion(
3239 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3240 ) {
3241 match _t {
3242 alloy_sol_types::private::AssertTypeEq::<
3243 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3244 >(_) => {}
3245 }
3246 }
3247 #[automatically_derived]
3248 #[doc(hidden)]
3249 impl ::core::convert::From<paused_1Return> for UnderlyingRustTuple<'_> {
3250 fn from(value: paused_1Return) -> Self {
3251 (value._0,)
3252 }
3253 }
3254 #[automatically_derived]
3255 #[doc(hidden)]
3256 impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Return {
3257 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3258 Self { _0: tuple.0 }
3259 }
3260 }
3261 }
3262 #[automatically_derived]
3263 impl alloy_sol_types::SolCall for paused_1Call {
3264 type Parameters<'a> = ();
3265 type Token<'a> = <Self::Parameters<
3266 'a,
3267 > as alloy_sol_types::SolType>::Token<'a>;
3268 type Return = alloy::sol_types::private::primitives::aliases::U256;
3269 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3270 type ReturnToken<'a> = <Self::ReturnTuple<
3271 'a,
3272 > as alloy_sol_types::SolType>::Token<'a>;
3273 const SIGNATURE: &'static str = "paused()";
3274 const SELECTOR: [u8; 4] = [92u8, 151u8, 90u8, 187u8];
3275 #[inline]
3276 fn new<'a>(
3277 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3278 ) -> Self {
3279 tuple.into()
3280 }
3281 #[inline]
3282 fn tokenize(&self) -> Self::Token<'_> {
3283 ()
3284 }
3285 #[inline]
3286 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3287 (
3288 <alloy::sol_types::sol_data::Uint<
3289 256,
3290 > as alloy_sol_types::SolType>::tokenize(ret),
3291 )
3292 }
3293 #[inline]
3294 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3295 <Self::ReturnTuple<
3296 '_,
3297 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3298 .map(|r| {
3299 let r: paused_1Return = r.into();
3300 r._0
3301 })
3302 }
3303 #[inline]
3304 fn abi_decode_returns_validate(
3305 data: &[u8],
3306 ) -> alloy_sol_types::Result<Self::Return> {
3307 <Self::ReturnTuple<
3308 '_,
3309 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3310 .map(|r| {
3311 let r: paused_1Return = r.into();
3312 r._0
3313 })
3314 }
3315 }
3316 };
3317 #[derive(serde::Serialize, serde::Deserialize)]
3318 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3319 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3324 #[derive(Clone)]
3325 pub struct pauserRegistryCall;
3326 #[derive(serde::Serialize, serde::Deserialize)]
3327 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3328 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3330 #[derive(Clone)]
3331 pub struct pauserRegistryReturn {
3332 #[allow(missing_docs)]
3333 pub _0: alloy::sol_types::private::Address,
3334 }
3335 #[allow(
3336 non_camel_case_types,
3337 non_snake_case,
3338 clippy::pub_underscore_fields,
3339 clippy::style
3340 )]
3341 const _: () = {
3342 use alloy::sol_types as alloy_sol_types;
3343 {
3344 #[doc(hidden)]
3345 type UnderlyingSolTuple<'a> = ();
3346 #[doc(hidden)]
3347 type UnderlyingRustTuple<'a> = ();
3348 #[cfg(test)]
3349 #[allow(dead_code, unreachable_patterns)]
3350 fn _type_assertion(
3351 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3352 ) {
3353 match _t {
3354 alloy_sol_types::private::AssertTypeEq::<
3355 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3356 >(_) => {}
3357 }
3358 }
3359 #[automatically_derived]
3360 #[doc(hidden)]
3361 impl ::core::convert::From<pauserRegistryCall> for UnderlyingRustTuple<'_> {
3362 fn from(value: pauserRegistryCall) -> Self {
3363 ()
3364 }
3365 }
3366 #[automatically_derived]
3367 #[doc(hidden)]
3368 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauserRegistryCall {
3369 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3370 Self
3371 }
3372 }
3373 }
3374 {
3375 #[doc(hidden)]
3376 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3377 #[doc(hidden)]
3378 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3379 #[cfg(test)]
3380 #[allow(dead_code, unreachable_patterns)]
3381 fn _type_assertion(
3382 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3383 ) {
3384 match _t {
3385 alloy_sol_types::private::AssertTypeEq::<
3386 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3387 >(_) => {}
3388 }
3389 }
3390 #[automatically_derived]
3391 #[doc(hidden)]
3392 impl ::core::convert::From<pauserRegistryReturn>
3393 for UnderlyingRustTuple<'_> {
3394 fn from(value: pauserRegistryReturn) -> Self {
3395 (value._0,)
3396 }
3397 }
3398 #[automatically_derived]
3399 #[doc(hidden)]
3400 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3401 for pauserRegistryReturn {
3402 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3403 Self { _0: tuple.0 }
3404 }
3405 }
3406 }
3407 #[automatically_derived]
3408 impl alloy_sol_types::SolCall for pauserRegistryCall {
3409 type Parameters<'a> = ();
3410 type Token<'a> = <Self::Parameters<
3411 'a,
3412 > as alloy_sol_types::SolType>::Token<'a>;
3413 type Return = alloy::sol_types::private::Address;
3414 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3415 type ReturnToken<'a> = <Self::ReturnTuple<
3416 'a,
3417 > as alloy_sol_types::SolType>::Token<'a>;
3418 const SIGNATURE: &'static str = "pauserRegistry()";
3419 const SELECTOR: [u8; 4] = [136u8, 111u8, 17u8, 149u8];
3420 #[inline]
3421 fn new<'a>(
3422 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3423 ) -> Self {
3424 tuple.into()
3425 }
3426 #[inline]
3427 fn tokenize(&self) -> Self::Token<'_> {
3428 ()
3429 }
3430 #[inline]
3431 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3432 (
3433 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3434 ret,
3435 ),
3436 )
3437 }
3438 #[inline]
3439 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3440 <Self::ReturnTuple<
3441 '_,
3442 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3443 .map(|r| {
3444 let r: pauserRegistryReturn = r.into();
3445 r._0
3446 })
3447 }
3448 #[inline]
3449 fn abi_decode_returns_validate(
3450 data: &[u8],
3451 ) -> alloy_sol_types::Result<Self::Return> {
3452 <Self::ReturnTuple<
3453 '_,
3454 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3455 .map(|r| {
3456 let r: pauserRegistryReturn = r.into();
3457 r._0
3458 })
3459 }
3460 }
3461 };
3462 #[derive(serde::Serialize, serde::Deserialize)]
3463 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3464 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3469 #[derive(Clone)]
3470 pub struct sharesCall {
3471 #[allow(missing_docs)]
3472 pub user: alloy::sol_types::private::Address,
3473 }
3474 #[derive(serde::Serialize, serde::Deserialize)]
3475 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3476 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3478 #[derive(Clone)]
3479 pub struct sharesReturn {
3480 #[allow(missing_docs)]
3481 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3482 }
3483 #[allow(
3484 non_camel_case_types,
3485 non_snake_case,
3486 clippy::pub_underscore_fields,
3487 clippy::style
3488 )]
3489 const _: () = {
3490 use alloy::sol_types as alloy_sol_types;
3491 {
3492 #[doc(hidden)]
3493 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3494 #[doc(hidden)]
3495 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3496 #[cfg(test)]
3497 #[allow(dead_code, unreachable_patterns)]
3498 fn _type_assertion(
3499 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3500 ) {
3501 match _t {
3502 alloy_sol_types::private::AssertTypeEq::<
3503 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3504 >(_) => {}
3505 }
3506 }
3507 #[automatically_derived]
3508 #[doc(hidden)]
3509 impl ::core::convert::From<sharesCall> for UnderlyingRustTuple<'_> {
3510 fn from(value: sharesCall) -> Self {
3511 (value.user,)
3512 }
3513 }
3514 #[automatically_derived]
3515 #[doc(hidden)]
3516 impl ::core::convert::From<UnderlyingRustTuple<'_>> for sharesCall {
3517 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3518 Self { user: tuple.0 }
3519 }
3520 }
3521 }
3522 {
3523 #[doc(hidden)]
3524 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3525 #[doc(hidden)]
3526 type UnderlyingRustTuple<'a> = (
3527 alloy::sol_types::private::primitives::aliases::U256,
3528 );
3529 #[cfg(test)]
3530 #[allow(dead_code, unreachable_patterns)]
3531 fn _type_assertion(
3532 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3533 ) {
3534 match _t {
3535 alloy_sol_types::private::AssertTypeEq::<
3536 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3537 >(_) => {}
3538 }
3539 }
3540 #[automatically_derived]
3541 #[doc(hidden)]
3542 impl ::core::convert::From<sharesReturn> for UnderlyingRustTuple<'_> {
3543 fn from(value: sharesReturn) -> Self {
3544 (value._0,)
3545 }
3546 }
3547 #[automatically_derived]
3548 #[doc(hidden)]
3549 impl ::core::convert::From<UnderlyingRustTuple<'_>> for sharesReturn {
3550 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3551 Self { _0: tuple.0 }
3552 }
3553 }
3554 }
3555 #[automatically_derived]
3556 impl alloy_sol_types::SolCall for sharesCall {
3557 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3558 type Token<'a> = <Self::Parameters<
3559 'a,
3560 > as alloy_sol_types::SolType>::Token<'a>;
3561 type Return = alloy::sol_types::private::primitives::aliases::U256;
3562 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3563 type ReturnToken<'a> = <Self::ReturnTuple<
3564 'a,
3565 > as alloy_sol_types::SolType>::Token<'a>;
3566 const SIGNATURE: &'static str = "shares(address)";
3567 const SELECTOR: [u8; 4] = [206u8, 124u8, 42u8, 194u8];
3568 #[inline]
3569 fn new<'a>(
3570 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3571 ) -> Self {
3572 tuple.into()
3573 }
3574 #[inline]
3575 fn tokenize(&self) -> Self::Token<'_> {
3576 (
3577 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3578 &self.user,
3579 ),
3580 )
3581 }
3582 #[inline]
3583 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3584 (
3585 <alloy::sol_types::sol_data::Uint<
3586 256,
3587 > as alloy_sol_types::SolType>::tokenize(ret),
3588 )
3589 }
3590 #[inline]
3591 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3592 <Self::ReturnTuple<
3593 '_,
3594 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3595 .map(|r| {
3596 let r: sharesReturn = r.into();
3597 r._0
3598 })
3599 }
3600 #[inline]
3601 fn abi_decode_returns_validate(
3602 data: &[u8],
3603 ) -> alloy_sol_types::Result<Self::Return> {
3604 <Self::ReturnTuple<
3605 '_,
3606 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3607 .map(|r| {
3608 let r: sharesReturn = r.into();
3609 r._0
3610 })
3611 }
3612 }
3613 };
3614 #[derive(serde::Serialize, serde::Deserialize)]
3615 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3616 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3621 #[derive(Clone)]
3622 pub struct sharesToUnderlyingCall {
3623 #[allow(missing_docs)]
3624 pub amountShares: alloy::sol_types::private::primitives::aliases::U256,
3625 }
3626 #[derive(serde::Serialize, serde::Deserialize)]
3627 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3628 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3630 #[derive(Clone)]
3631 pub struct sharesToUnderlyingReturn {
3632 #[allow(missing_docs)]
3633 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3634 }
3635 #[allow(
3636 non_camel_case_types,
3637 non_snake_case,
3638 clippy::pub_underscore_fields,
3639 clippy::style
3640 )]
3641 const _: () = {
3642 use alloy::sol_types as alloy_sol_types;
3643 {
3644 #[doc(hidden)]
3645 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3646 #[doc(hidden)]
3647 type UnderlyingRustTuple<'a> = (
3648 alloy::sol_types::private::primitives::aliases::U256,
3649 );
3650 #[cfg(test)]
3651 #[allow(dead_code, unreachable_patterns)]
3652 fn _type_assertion(
3653 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3654 ) {
3655 match _t {
3656 alloy_sol_types::private::AssertTypeEq::<
3657 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3658 >(_) => {}
3659 }
3660 }
3661 #[automatically_derived]
3662 #[doc(hidden)]
3663 impl ::core::convert::From<sharesToUnderlyingCall>
3664 for UnderlyingRustTuple<'_> {
3665 fn from(value: sharesToUnderlyingCall) -> Self {
3666 (value.amountShares,)
3667 }
3668 }
3669 #[automatically_derived]
3670 #[doc(hidden)]
3671 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3672 for sharesToUnderlyingCall {
3673 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3674 Self { amountShares: tuple.0 }
3675 }
3676 }
3677 }
3678 {
3679 #[doc(hidden)]
3680 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3681 #[doc(hidden)]
3682 type UnderlyingRustTuple<'a> = (
3683 alloy::sol_types::private::primitives::aliases::U256,
3684 );
3685 #[cfg(test)]
3686 #[allow(dead_code, unreachable_patterns)]
3687 fn _type_assertion(
3688 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3689 ) {
3690 match _t {
3691 alloy_sol_types::private::AssertTypeEq::<
3692 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3693 >(_) => {}
3694 }
3695 }
3696 #[automatically_derived]
3697 #[doc(hidden)]
3698 impl ::core::convert::From<sharesToUnderlyingReturn>
3699 for UnderlyingRustTuple<'_> {
3700 fn from(value: sharesToUnderlyingReturn) -> Self {
3701 (value._0,)
3702 }
3703 }
3704 #[automatically_derived]
3705 #[doc(hidden)]
3706 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3707 for sharesToUnderlyingReturn {
3708 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3709 Self { _0: tuple.0 }
3710 }
3711 }
3712 }
3713 #[automatically_derived]
3714 impl alloy_sol_types::SolCall for sharesToUnderlyingCall {
3715 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3716 type Token<'a> = <Self::Parameters<
3717 'a,
3718 > as alloy_sol_types::SolType>::Token<'a>;
3719 type Return = alloy::sol_types::private::primitives::aliases::U256;
3720 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3721 type ReturnToken<'a> = <Self::ReturnTuple<
3722 'a,
3723 > as alloy_sol_types::SolType>::Token<'a>;
3724 const SIGNATURE: &'static str = "sharesToUnderlying(uint256)";
3725 const SELECTOR: [u8; 4] = [243u8, 231u8, 56u8, 117u8];
3726 #[inline]
3727 fn new<'a>(
3728 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3729 ) -> Self {
3730 tuple.into()
3731 }
3732 #[inline]
3733 fn tokenize(&self) -> Self::Token<'_> {
3734 (
3735 <alloy::sol_types::sol_data::Uint<
3736 256,
3737 > as alloy_sol_types::SolType>::tokenize(&self.amountShares),
3738 )
3739 }
3740 #[inline]
3741 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3742 (
3743 <alloy::sol_types::sol_data::Uint<
3744 256,
3745 > as alloy_sol_types::SolType>::tokenize(ret),
3746 )
3747 }
3748 #[inline]
3749 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3750 <Self::ReturnTuple<
3751 '_,
3752 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3753 .map(|r| {
3754 let r: sharesToUnderlyingReturn = r.into();
3755 r._0
3756 })
3757 }
3758 #[inline]
3759 fn abi_decode_returns_validate(
3760 data: &[u8],
3761 ) -> alloy_sol_types::Result<Self::Return> {
3762 <Self::ReturnTuple<
3763 '_,
3764 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3765 .map(|r| {
3766 let r: sharesToUnderlyingReturn = r.into();
3767 r._0
3768 })
3769 }
3770 }
3771 };
3772 #[derive(serde::Serialize, serde::Deserialize)]
3773 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3774 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3779 #[derive(Clone)]
3780 pub struct sharesToUnderlyingViewCall {
3781 #[allow(missing_docs)]
3782 pub amountShares: alloy::sol_types::private::primitives::aliases::U256,
3783 }
3784 #[derive(serde::Serialize, serde::Deserialize)]
3785 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3786 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3788 #[derive(Clone)]
3789 pub struct sharesToUnderlyingViewReturn {
3790 #[allow(missing_docs)]
3791 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3792 }
3793 #[allow(
3794 non_camel_case_types,
3795 non_snake_case,
3796 clippy::pub_underscore_fields,
3797 clippy::style
3798 )]
3799 const _: () = {
3800 use alloy::sol_types as alloy_sol_types;
3801 {
3802 #[doc(hidden)]
3803 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3804 #[doc(hidden)]
3805 type UnderlyingRustTuple<'a> = (
3806 alloy::sol_types::private::primitives::aliases::U256,
3807 );
3808 #[cfg(test)]
3809 #[allow(dead_code, unreachable_patterns)]
3810 fn _type_assertion(
3811 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3812 ) {
3813 match _t {
3814 alloy_sol_types::private::AssertTypeEq::<
3815 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3816 >(_) => {}
3817 }
3818 }
3819 #[automatically_derived]
3820 #[doc(hidden)]
3821 impl ::core::convert::From<sharesToUnderlyingViewCall>
3822 for UnderlyingRustTuple<'_> {
3823 fn from(value: sharesToUnderlyingViewCall) -> Self {
3824 (value.amountShares,)
3825 }
3826 }
3827 #[automatically_derived]
3828 #[doc(hidden)]
3829 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3830 for sharesToUnderlyingViewCall {
3831 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3832 Self { amountShares: tuple.0 }
3833 }
3834 }
3835 }
3836 {
3837 #[doc(hidden)]
3838 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3839 #[doc(hidden)]
3840 type UnderlyingRustTuple<'a> = (
3841 alloy::sol_types::private::primitives::aliases::U256,
3842 );
3843 #[cfg(test)]
3844 #[allow(dead_code, unreachable_patterns)]
3845 fn _type_assertion(
3846 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3847 ) {
3848 match _t {
3849 alloy_sol_types::private::AssertTypeEq::<
3850 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3851 >(_) => {}
3852 }
3853 }
3854 #[automatically_derived]
3855 #[doc(hidden)]
3856 impl ::core::convert::From<sharesToUnderlyingViewReturn>
3857 for UnderlyingRustTuple<'_> {
3858 fn from(value: sharesToUnderlyingViewReturn) -> Self {
3859 (value._0,)
3860 }
3861 }
3862 #[automatically_derived]
3863 #[doc(hidden)]
3864 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3865 for sharesToUnderlyingViewReturn {
3866 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3867 Self { _0: tuple.0 }
3868 }
3869 }
3870 }
3871 #[automatically_derived]
3872 impl alloy_sol_types::SolCall for sharesToUnderlyingViewCall {
3873 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3874 type Token<'a> = <Self::Parameters<
3875 'a,
3876 > as alloy_sol_types::SolType>::Token<'a>;
3877 type Return = alloy::sol_types::private::primitives::aliases::U256;
3878 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3879 type ReturnToken<'a> = <Self::ReturnTuple<
3880 'a,
3881 > as alloy_sol_types::SolType>::Token<'a>;
3882 const SIGNATURE: &'static str = "sharesToUnderlyingView(uint256)";
3883 const SELECTOR: [u8; 4] = [122u8, 139u8, 38u8, 55u8];
3884 #[inline]
3885 fn new<'a>(
3886 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3887 ) -> Self {
3888 tuple.into()
3889 }
3890 #[inline]
3891 fn tokenize(&self) -> Self::Token<'_> {
3892 (
3893 <alloy::sol_types::sol_data::Uint<
3894 256,
3895 > as alloy_sol_types::SolType>::tokenize(&self.amountShares),
3896 )
3897 }
3898 #[inline]
3899 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3900 (
3901 <alloy::sol_types::sol_data::Uint<
3902 256,
3903 > as alloy_sol_types::SolType>::tokenize(ret),
3904 )
3905 }
3906 #[inline]
3907 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3908 <Self::ReturnTuple<
3909 '_,
3910 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3911 .map(|r| {
3912 let r: sharesToUnderlyingViewReturn = r.into();
3913 r._0
3914 })
3915 }
3916 #[inline]
3917 fn abi_decode_returns_validate(
3918 data: &[u8],
3919 ) -> alloy_sol_types::Result<Self::Return> {
3920 <Self::ReturnTuple<
3921 '_,
3922 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3923 .map(|r| {
3924 let r: sharesToUnderlyingViewReturn = r.into();
3925 r._0
3926 })
3927 }
3928 }
3929 };
3930 #[derive(serde::Serialize, serde::Deserialize)]
3931 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3932 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3937 #[derive(Clone)]
3938 pub struct strategyManagerCall;
3939 #[derive(serde::Serialize, serde::Deserialize)]
3940 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3941 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3943 #[derive(Clone)]
3944 pub struct strategyManagerReturn {
3945 #[allow(missing_docs)]
3946 pub _0: alloy::sol_types::private::Address,
3947 }
3948 #[allow(
3949 non_camel_case_types,
3950 non_snake_case,
3951 clippy::pub_underscore_fields,
3952 clippy::style
3953 )]
3954 const _: () = {
3955 use alloy::sol_types as alloy_sol_types;
3956 {
3957 #[doc(hidden)]
3958 type UnderlyingSolTuple<'a> = ();
3959 #[doc(hidden)]
3960 type UnderlyingRustTuple<'a> = ();
3961 #[cfg(test)]
3962 #[allow(dead_code, unreachable_patterns)]
3963 fn _type_assertion(
3964 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3965 ) {
3966 match _t {
3967 alloy_sol_types::private::AssertTypeEq::<
3968 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3969 >(_) => {}
3970 }
3971 }
3972 #[automatically_derived]
3973 #[doc(hidden)]
3974 impl ::core::convert::From<strategyManagerCall> for UnderlyingRustTuple<'_> {
3975 fn from(value: strategyManagerCall) -> Self {
3976 ()
3977 }
3978 }
3979 #[automatically_derived]
3980 #[doc(hidden)]
3981 impl ::core::convert::From<UnderlyingRustTuple<'_>> for strategyManagerCall {
3982 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3983 Self
3984 }
3985 }
3986 }
3987 {
3988 #[doc(hidden)]
3989 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3990 #[doc(hidden)]
3991 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3992 #[cfg(test)]
3993 #[allow(dead_code, unreachable_patterns)]
3994 fn _type_assertion(
3995 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3996 ) {
3997 match _t {
3998 alloy_sol_types::private::AssertTypeEq::<
3999 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4000 >(_) => {}
4001 }
4002 }
4003 #[automatically_derived]
4004 #[doc(hidden)]
4005 impl ::core::convert::From<strategyManagerReturn>
4006 for UnderlyingRustTuple<'_> {
4007 fn from(value: strategyManagerReturn) -> Self {
4008 (value._0,)
4009 }
4010 }
4011 #[automatically_derived]
4012 #[doc(hidden)]
4013 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4014 for strategyManagerReturn {
4015 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4016 Self { _0: tuple.0 }
4017 }
4018 }
4019 }
4020 #[automatically_derived]
4021 impl alloy_sol_types::SolCall for strategyManagerCall {
4022 type Parameters<'a> = ();
4023 type Token<'a> = <Self::Parameters<
4024 'a,
4025 > as alloy_sol_types::SolType>::Token<'a>;
4026 type Return = alloy::sol_types::private::Address;
4027 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
4028 type ReturnToken<'a> = <Self::ReturnTuple<
4029 'a,
4030 > as alloy_sol_types::SolType>::Token<'a>;
4031 const SIGNATURE: &'static str = "strategyManager()";
4032 const SELECTOR: [u8; 4] = [57u8, 183u8, 14u8, 56u8];
4033 #[inline]
4034 fn new<'a>(
4035 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4036 ) -> Self {
4037 tuple.into()
4038 }
4039 #[inline]
4040 fn tokenize(&self) -> Self::Token<'_> {
4041 ()
4042 }
4043 #[inline]
4044 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4045 (
4046 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4047 ret,
4048 ),
4049 )
4050 }
4051 #[inline]
4052 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4053 <Self::ReturnTuple<
4054 '_,
4055 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4056 .map(|r| {
4057 let r: strategyManagerReturn = r.into();
4058 r._0
4059 })
4060 }
4061 #[inline]
4062 fn abi_decode_returns_validate(
4063 data: &[u8],
4064 ) -> alloy_sol_types::Result<Self::Return> {
4065 <Self::ReturnTuple<
4066 '_,
4067 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4068 .map(|r| {
4069 let r: strategyManagerReturn = r.into();
4070 r._0
4071 })
4072 }
4073 }
4074 };
4075 #[derive(serde::Serialize, serde::Deserialize)]
4076 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4077 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4082 #[derive(Clone)]
4083 pub struct totalSharesCall;
4084 #[derive(serde::Serialize, serde::Deserialize)]
4085 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4086 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4088 #[derive(Clone)]
4089 pub struct totalSharesReturn {
4090 #[allow(missing_docs)]
4091 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4092 }
4093 #[allow(
4094 non_camel_case_types,
4095 non_snake_case,
4096 clippy::pub_underscore_fields,
4097 clippy::style
4098 )]
4099 const _: () = {
4100 use alloy::sol_types as alloy_sol_types;
4101 {
4102 #[doc(hidden)]
4103 type UnderlyingSolTuple<'a> = ();
4104 #[doc(hidden)]
4105 type UnderlyingRustTuple<'a> = ();
4106 #[cfg(test)]
4107 #[allow(dead_code, unreachable_patterns)]
4108 fn _type_assertion(
4109 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4110 ) {
4111 match _t {
4112 alloy_sol_types::private::AssertTypeEq::<
4113 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4114 >(_) => {}
4115 }
4116 }
4117 #[automatically_derived]
4118 #[doc(hidden)]
4119 impl ::core::convert::From<totalSharesCall> for UnderlyingRustTuple<'_> {
4120 fn from(value: totalSharesCall) -> Self {
4121 ()
4122 }
4123 }
4124 #[automatically_derived]
4125 #[doc(hidden)]
4126 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSharesCall {
4127 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4128 Self
4129 }
4130 }
4131 }
4132 {
4133 #[doc(hidden)]
4134 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4135 #[doc(hidden)]
4136 type UnderlyingRustTuple<'a> = (
4137 alloy::sol_types::private::primitives::aliases::U256,
4138 );
4139 #[cfg(test)]
4140 #[allow(dead_code, unreachable_patterns)]
4141 fn _type_assertion(
4142 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4143 ) {
4144 match _t {
4145 alloy_sol_types::private::AssertTypeEq::<
4146 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4147 >(_) => {}
4148 }
4149 }
4150 #[automatically_derived]
4151 #[doc(hidden)]
4152 impl ::core::convert::From<totalSharesReturn> for UnderlyingRustTuple<'_> {
4153 fn from(value: totalSharesReturn) -> Self {
4154 (value._0,)
4155 }
4156 }
4157 #[automatically_derived]
4158 #[doc(hidden)]
4159 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSharesReturn {
4160 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4161 Self { _0: tuple.0 }
4162 }
4163 }
4164 }
4165 #[automatically_derived]
4166 impl alloy_sol_types::SolCall for totalSharesCall {
4167 type Parameters<'a> = ();
4168 type Token<'a> = <Self::Parameters<
4169 'a,
4170 > as alloy_sol_types::SolType>::Token<'a>;
4171 type Return = alloy::sol_types::private::primitives::aliases::U256;
4172 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4173 type ReturnToken<'a> = <Self::ReturnTuple<
4174 'a,
4175 > as alloy_sol_types::SolType>::Token<'a>;
4176 const SIGNATURE: &'static str = "totalShares()";
4177 const SELECTOR: [u8; 4] = [58u8, 152u8, 239u8, 57u8];
4178 #[inline]
4179 fn new<'a>(
4180 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4181 ) -> Self {
4182 tuple.into()
4183 }
4184 #[inline]
4185 fn tokenize(&self) -> Self::Token<'_> {
4186 ()
4187 }
4188 #[inline]
4189 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4190 (
4191 <alloy::sol_types::sol_data::Uint<
4192 256,
4193 > as alloy_sol_types::SolType>::tokenize(ret),
4194 )
4195 }
4196 #[inline]
4197 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4198 <Self::ReturnTuple<
4199 '_,
4200 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4201 .map(|r| {
4202 let r: totalSharesReturn = r.into();
4203 r._0
4204 })
4205 }
4206 #[inline]
4207 fn abi_decode_returns_validate(
4208 data: &[u8],
4209 ) -> alloy_sol_types::Result<Self::Return> {
4210 <Self::ReturnTuple<
4211 '_,
4212 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4213 .map(|r| {
4214 let r: totalSharesReturn = r.into();
4215 r._0
4216 })
4217 }
4218 }
4219 };
4220 #[derive(serde::Serialize, serde::Deserialize)]
4221 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4222 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4227 #[derive(Clone)]
4228 pub struct underlyingToSharesCall {
4229 #[allow(missing_docs)]
4230 pub amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
4231 }
4232 #[derive(serde::Serialize, serde::Deserialize)]
4233 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4234 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4236 #[derive(Clone)]
4237 pub struct underlyingToSharesReturn {
4238 #[allow(missing_docs)]
4239 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4240 }
4241 #[allow(
4242 non_camel_case_types,
4243 non_snake_case,
4244 clippy::pub_underscore_fields,
4245 clippy::style
4246 )]
4247 const _: () = {
4248 use alloy::sol_types as alloy_sol_types;
4249 {
4250 #[doc(hidden)]
4251 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4252 #[doc(hidden)]
4253 type UnderlyingRustTuple<'a> = (
4254 alloy::sol_types::private::primitives::aliases::U256,
4255 );
4256 #[cfg(test)]
4257 #[allow(dead_code, unreachable_patterns)]
4258 fn _type_assertion(
4259 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4260 ) {
4261 match _t {
4262 alloy_sol_types::private::AssertTypeEq::<
4263 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4264 >(_) => {}
4265 }
4266 }
4267 #[automatically_derived]
4268 #[doc(hidden)]
4269 impl ::core::convert::From<underlyingToSharesCall>
4270 for UnderlyingRustTuple<'_> {
4271 fn from(value: underlyingToSharesCall) -> Self {
4272 (value.amountUnderlying,)
4273 }
4274 }
4275 #[automatically_derived]
4276 #[doc(hidden)]
4277 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4278 for underlyingToSharesCall {
4279 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4280 Self { amountUnderlying: tuple.0 }
4281 }
4282 }
4283 }
4284 {
4285 #[doc(hidden)]
4286 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4287 #[doc(hidden)]
4288 type UnderlyingRustTuple<'a> = (
4289 alloy::sol_types::private::primitives::aliases::U256,
4290 );
4291 #[cfg(test)]
4292 #[allow(dead_code, unreachable_patterns)]
4293 fn _type_assertion(
4294 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4295 ) {
4296 match _t {
4297 alloy_sol_types::private::AssertTypeEq::<
4298 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4299 >(_) => {}
4300 }
4301 }
4302 #[automatically_derived]
4303 #[doc(hidden)]
4304 impl ::core::convert::From<underlyingToSharesReturn>
4305 for UnderlyingRustTuple<'_> {
4306 fn from(value: underlyingToSharesReturn) -> Self {
4307 (value._0,)
4308 }
4309 }
4310 #[automatically_derived]
4311 #[doc(hidden)]
4312 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4313 for underlyingToSharesReturn {
4314 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4315 Self { _0: tuple.0 }
4316 }
4317 }
4318 }
4319 #[automatically_derived]
4320 impl alloy_sol_types::SolCall for underlyingToSharesCall {
4321 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4322 type Token<'a> = <Self::Parameters<
4323 'a,
4324 > as alloy_sol_types::SolType>::Token<'a>;
4325 type Return = alloy::sol_types::private::primitives::aliases::U256;
4326 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4327 type ReturnToken<'a> = <Self::ReturnTuple<
4328 'a,
4329 > as alloy_sol_types::SolType>::Token<'a>;
4330 const SIGNATURE: &'static str = "underlyingToShares(uint256)";
4331 const SELECTOR: [u8; 4] = [140u8, 135u8, 16u8, 25u8];
4332 #[inline]
4333 fn new<'a>(
4334 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4335 ) -> Self {
4336 tuple.into()
4337 }
4338 #[inline]
4339 fn tokenize(&self) -> Self::Token<'_> {
4340 (
4341 <alloy::sol_types::sol_data::Uint<
4342 256,
4343 > as alloy_sol_types::SolType>::tokenize(&self.amountUnderlying),
4344 )
4345 }
4346 #[inline]
4347 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4348 (
4349 <alloy::sol_types::sol_data::Uint<
4350 256,
4351 > as alloy_sol_types::SolType>::tokenize(ret),
4352 )
4353 }
4354 #[inline]
4355 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4356 <Self::ReturnTuple<
4357 '_,
4358 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4359 .map(|r| {
4360 let r: underlyingToSharesReturn = r.into();
4361 r._0
4362 })
4363 }
4364 #[inline]
4365 fn abi_decode_returns_validate(
4366 data: &[u8],
4367 ) -> alloy_sol_types::Result<Self::Return> {
4368 <Self::ReturnTuple<
4369 '_,
4370 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4371 .map(|r| {
4372 let r: underlyingToSharesReturn = r.into();
4373 r._0
4374 })
4375 }
4376 }
4377 };
4378 #[derive(serde::Serialize, serde::Deserialize)]
4379 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4380 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4385 #[derive(Clone)]
4386 pub struct underlyingToSharesViewCall {
4387 #[allow(missing_docs)]
4388 pub amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
4389 }
4390 #[derive(serde::Serialize, serde::Deserialize)]
4391 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4392 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4394 #[derive(Clone)]
4395 pub struct underlyingToSharesViewReturn {
4396 #[allow(missing_docs)]
4397 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4398 }
4399 #[allow(
4400 non_camel_case_types,
4401 non_snake_case,
4402 clippy::pub_underscore_fields,
4403 clippy::style
4404 )]
4405 const _: () = {
4406 use alloy::sol_types as alloy_sol_types;
4407 {
4408 #[doc(hidden)]
4409 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4410 #[doc(hidden)]
4411 type UnderlyingRustTuple<'a> = (
4412 alloy::sol_types::private::primitives::aliases::U256,
4413 );
4414 #[cfg(test)]
4415 #[allow(dead_code, unreachable_patterns)]
4416 fn _type_assertion(
4417 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4418 ) {
4419 match _t {
4420 alloy_sol_types::private::AssertTypeEq::<
4421 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4422 >(_) => {}
4423 }
4424 }
4425 #[automatically_derived]
4426 #[doc(hidden)]
4427 impl ::core::convert::From<underlyingToSharesViewCall>
4428 for UnderlyingRustTuple<'_> {
4429 fn from(value: underlyingToSharesViewCall) -> Self {
4430 (value.amountUnderlying,)
4431 }
4432 }
4433 #[automatically_derived]
4434 #[doc(hidden)]
4435 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4436 for underlyingToSharesViewCall {
4437 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4438 Self { amountUnderlying: tuple.0 }
4439 }
4440 }
4441 }
4442 {
4443 #[doc(hidden)]
4444 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4445 #[doc(hidden)]
4446 type UnderlyingRustTuple<'a> = (
4447 alloy::sol_types::private::primitives::aliases::U256,
4448 );
4449 #[cfg(test)]
4450 #[allow(dead_code, unreachable_patterns)]
4451 fn _type_assertion(
4452 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4453 ) {
4454 match _t {
4455 alloy_sol_types::private::AssertTypeEq::<
4456 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4457 >(_) => {}
4458 }
4459 }
4460 #[automatically_derived]
4461 #[doc(hidden)]
4462 impl ::core::convert::From<underlyingToSharesViewReturn>
4463 for UnderlyingRustTuple<'_> {
4464 fn from(value: underlyingToSharesViewReturn) -> Self {
4465 (value._0,)
4466 }
4467 }
4468 #[automatically_derived]
4469 #[doc(hidden)]
4470 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4471 for underlyingToSharesViewReturn {
4472 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4473 Self { _0: tuple.0 }
4474 }
4475 }
4476 }
4477 #[automatically_derived]
4478 impl alloy_sol_types::SolCall for underlyingToSharesViewCall {
4479 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4480 type Token<'a> = <Self::Parameters<
4481 'a,
4482 > as alloy_sol_types::SolType>::Token<'a>;
4483 type Return = alloy::sol_types::private::primitives::aliases::U256;
4484 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4485 type ReturnToken<'a> = <Self::ReturnTuple<
4486 'a,
4487 > as alloy_sol_types::SolType>::Token<'a>;
4488 const SIGNATURE: &'static str = "underlyingToSharesView(uint256)";
4489 const SELECTOR: [u8; 4] = [227u8, 218u8, 229u8, 28u8];
4490 #[inline]
4491 fn new<'a>(
4492 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4493 ) -> Self {
4494 tuple.into()
4495 }
4496 #[inline]
4497 fn tokenize(&self) -> Self::Token<'_> {
4498 (
4499 <alloy::sol_types::sol_data::Uint<
4500 256,
4501 > as alloy_sol_types::SolType>::tokenize(&self.amountUnderlying),
4502 )
4503 }
4504 #[inline]
4505 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4506 (
4507 <alloy::sol_types::sol_data::Uint<
4508 256,
4509 > as alloy_sol_types::SolType>::tokenize(ret),
4510 )
4511 }
4512 #[inline]
4513 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4514 <Self::ReturnTuple<
4515 '_,
4516 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4517 .map(|r| {
4518 let r: underlyingToSharesViewReturn = r.into();
4519 r._0
4520 })
4521 }
4522 #[inline]
4523 fn abi_decode_returns_validate(
4524 data: &[u8],
4525 ) -> alloy_sol_types::Result<Self::Return> {
4526 <Self::ReturnTuple<
4527 '_,
4528 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4529 .map(|r| {
4530 let r: underlyingToSharesViewReturn = r.into();
4531 r._0
4532 })
4533 }
4534 }
4535 };
4536 #[derive(serde::Serialize, serde::Deserialize)]
4537 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4538 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4543 #[derive(Clone)]
4544 pub struct underlyingTokenCall;
4545 #[derive(serde::Serialize, serde::Deserialize)]
4546 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4547 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4549 #[derive(Clone)]
4550 pub struct underlyingTokenReturn {
4551 #[allow(missing_docs)]
4552 pub _0: alloy::sol_types::private::Address,
4553 }
4554 #[allow(
4555 non_camel_case_types,
4556 non_snake_case,
4557 clippy::pub_underscore_fields,
4558 clippy::style
4559 )]
4560 const _: () = {
4561 use alloy::sol_types as alloy_sol_types;
4562 {
4563 #[doc(hidden)]
4564 type UnderlyingSolTuple<'a> = ();
4565 #[doc(hidden)]
4566 type UnderlyingRustTuple<'a> = ();
4567 #[cfg(test)]
4568 #[allow(dead_code, unreachable_patterns)]
4569 fn _type_assertion(
4570 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4571 ) {
4572 match _t {
4573 alloy_sol_types::private::AssertTypeEq::<
4574 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4575 >(_) => {}
4576 }
4577 }
4578 #[automatically_derived]
4579 #[doc(hidden)]
4580 impl ::core::convert::From<underlyingTokenCall> for UnderlyingRustTuple<'_> {
4581 fn from(value: underlyingTokenCall) -> Self {
4582 ()
4583 }
4584 }
4585 #[automatically_derived]
4586 #[doc(hidden)]
4587 impl ::core::convert::From<UnderlyingRustTuple<'_>> for underlyingTokenCall {
4588 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4589 Self
4590 }
4591 }
4592 }
4593 {
4594 #[doc(hidden)]
4595 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4596 #[doc(hidden)]
4597 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4598 #[cfg(test)]
4599 #[allow(dead_code, unreachable_patterns)]
4600 fn _type_assertion(
4601 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4602 ) {
4603 match _t {
4604 alloy_sol_types::private::AssertTypeEq::<
4605 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4606 >(_) => {}
4607 }
4608 }
4609 #[automatically_derived]
4610 #[doc(hidden)]
4611 impl ::core::convert::From<underlyingTokenReturn>
4612 for UnderlyingRustTuple<'_> {
4613 fn from(value: underlyingTokenReturn) -> Self {
4614 (value._0,)
4615 }
4616 }
4617 #[automatically_derived]
4618 #[doc(hidden)]
4619 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4620 for underlyingTokenReturn {
4621 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4622 Self { _0: tuple.0 }
4623 }
4624 }
4625 }
4626 #[automatically_derived]
4627 impl alloy_sol_types::SolCall for underlyingTokenCall {
4628 type Parameters<'a> = ();
4629 type Token<'a> = <Self::Parameters<
4630 'a,
4631 > as alloy_sol_types::SolType>::Token<'a>;
4632 type Return = alloy::sol_types::private::Address;
4633 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
4634 type ReturnToken<'a> = <Self::ReturnTuple<
4635 'a,
4636 > as alloy_sol_types::SolType>::Token<'a>;
4637 const SIGNATURE: &'static str = "underlyingToken()";
4638 const SELECTOR: [u8; 4] = [36u8, 149u8, 165u8, 153u8];
4639 #[inline]
4640 fn new<'a>(
4641 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4642 ) -> Self {
4643 tuple.into()
4644 }
4645 #[inline]
4646 fn tokenize(&self) -> Self::Token<'_> {
4647 ()
4648 }
4649 #[inline]
4650 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4651 (
4652 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4653 ret,
4654 ),
4655 )
4656 }
4657 #[inline]
4658 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4659 <Self::ReturnTuple<
4660 '_,
4661 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4662 .map(|r| {
4663 let r: underlyingTokenReturn = r.into();
4664 r._0
4665 })
4666 }
4667 #[inline]
4668 fn abi_decode_returns_validate(
4669 data: &[u8],
4670 ) -> alloy_sol_types::Result<Self::Return> {
4671 <Self::ReturnTuple<
4672 '_,
4673 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4674 .map(|r| {
4675 let r: underlyingTokenReturn = r.into();
4676 r._0
4677 })
4678 }
4679 }
4680 };
4681 #[derive(serde::Serialize, serde::Deserialize)]
4682 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4683 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4688 #[derive(Clone)]
4689 pub struct unpauseCall {
4690 #[allow(missing_docs)]
4691 pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
4692 }
4693 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4695 #[derive(Clone)]
4696 pub struct unpauseReturn {}
4697 #[allow(
4698 non_camel_case_types,
4699 non_snake_case,
4700 clippy::pub_underscore_fields,
4701 clippy::style
4702 )]
4703 const _: () = {
4704 use alloy::sol_types as alloy_sol_types;
4705 {
4706 #[doc(hidden)]
4707 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4708 #[doc(hidden)]
4709 type UnderlyingRustTuple<'a> = (
4710 alloy::sol_types::private::primitives::aliases::U256,
4711 );
4712 #[cfg(test)]
4713 #[allow(dead_code, unreachable_patterns)]
4714 fn _type_assertion(
4715 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4716 ) {
4717 match _t {
4718 alloy_sol_types::private::AssertTypeEq::<
4719 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4720 >(_) => {}
4721 }
4722 }
4723 #[automatically_derived]
4724 #[doc(hidden)]
4725 impl ::core::convert::From<unpauseCall> for UnderlyingRustTuple<'_> {
4726 fn from(value: unpauseCall) -> Self {
4727 (value.newPausedStatus,)
4728 }
4729 }
4730 #[automatically_derived]
4731 #[doc(hidden)]
4732 impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseCall {
4733 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4734 Self { newPausedStatus: tuple.0 }
4735 }
4736 }
4737 }
4738 {
4739 #[doc(hidden)]
4740 type UnderlyingSolTuple<'a> = ();
4741 #[doc(hidden)]
4742 type UnderlyingRustTuple<'a> = ();
4743 #[cfg(test)]
4744 #[allow(dead_code, unreachable_patterns)]
4745 fn _type_assertion(
4746 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4747 ) {
4748 match _t {
4749 alloy_sol_types::private::AssertTypeEq::<
4750 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4751 >(_) => {}
4752 }
4753 }
4754 #[automatically_derived]
4755 #[doc(hidden)]
4756 impl ::core::convert::From<unpauseReturn> for UnderlyingRustTuple<'_> {
4757 fn from(value: unpauseReturn) -> Self {
4758 ()
4759 }
4760 }
4761 #[automatically_derived]
4762 #[doc(hidden)]
4763 impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseReturn {
4764 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4765 Self {}
4766 }
4767 }
4768 }
4769 impl unpauseReturn {
4770 fn _tokenize(
4771 &self,
4772 ) -> <unpauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4773 ()
4774 }
4775 }
4776 #[automatically_derived]
4777 impl alloy_sol_types::SolCall for unpauseCall {
4778 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4779 type Token<'a> = <Self::Parameters<
4780 'a,
4781 > as alloy_sol_types::SolType>::Token<'a>;
4782 type Return = unpauseReturn;
4783 type ReturnTuple<'a> = ();
4784 type ReturnToken<'a> = <Self::ReturnTuple<
4785 'a,
4786 > as alloy_sol_types::SolType>::Token<'a>;
4787 const SIGNATURE: &'static str = "unpause(uint256)";
4788 const SELECTOR: [u8; 4] = [250u8, 188u8, 28u8, 188u8];
4789 #[inline]
4790 fn new<'a>(
4791 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4792 ) -> Self {
4793 tuple.into()
4794 }
4795 #[inline]
4796 fn tokenize(&self) -> Self::Token<'_> {
4797 (
4798 <alloy::sol_types::sol_data::Uint<
4799 256,
4800 > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
4801 )
4802 }
4803 #[inline]
4804 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4805 unpauseReturn::_tokenize(ret)
4806 }
4807 #[inline]
4808 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4809 <Self::ReturnTuple<
4810 '_,
4811 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4812 .map(Into::into)
4813 }
4814 #[inline]
4815 fn abi_decode_returns_validate(
4816 data: &[u8],
4817 ) -> alloy_sol_types::Result<Self::Return> {
4818 <Self::ReturnTuple<
4819 '_,
4820 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4821 .map(Into::into)
4822 }
4823 }
4824 };
4825 #[derive(serde::Serialize, serde::Deserialize)]
4826 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4827 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4832 #[derive(Clone)]
4833 pub struct userUnderlyingCall {
4834 #[allow(missing_docs)]
4835 pub user: alloy::sol_types::private::Address,
4836 }
4837 #[derive(serde::Serialize, serde::Deserialize)]
4838 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4839 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4841 #[derive(Clone)]
4842 pub struct userUnderlyingReturn {
4843 #[allow(missing_docs)]
4844 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4845 }
4846 #[allow(
4847 non_camel_case_types,
4848 non_snake_case,
4849 clippy::pub_underscore_fields,
4850 clippy::style
4851 )]
4852 const _: () = {
4853 use alloy::sol_types as alloy_sol_types;
4854 {
4855 #[doc(hidden)]
4856 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4857 #[doc(hidden)]
4858 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4859 #[cfg(test)]
4860 #[allow(dead_code, unreachable_patterns)]
4861 fn _type_assertion(
4862 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4863 ) {
4864 match _t {
4865 alloy_sol_types::private::AssertTypeEq::<
4866 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4867 >(_) => {}
4868 }
4869 }
4870 #[automatically_derived]
4871 #[doc(hidden)]
4872 impl ::core::convert::From<userUnderlyingCall> for UnderlyingRustTuple<'_> {
4873 fn from(value: userUnderlyingCall) -> Self {
4874 (value.user,)
4875 }
4876 }
4877 #[automatically_derived]
4878 #[doc(hidden)]
4879 impl ::core::convert::From<UnderlyingRustTuple<'_>> for userUnderlyingCall {
4880 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4881 Self { user: tuple.0 }
4882 }
4883 }
4884 }
4885 {
4886 #[doc(hidden)]
4887 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4888 #[doc(hidden)]
4889 type UnderlyingRustTuple<'a> = (
4890 alloy::sol_types::private::primitives::aliases::U256,
4891 );
4892 #[cfg(test)]
4893 #[allow(dead_code, unreachable_patterns)]
4894 fn _type_assertion(
4895 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4896 ) {
4897 match _t {
4898 alloy_sol_types::private::AssertTypeEq::<
4899 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4900 >(_) => {}
4901 }
4902 }
4903 #[automatically_derived]
4904 #[doc(hidden)]
4905 impl ::core::convert::From<userUnderlyingReturn>
4906 for UnderlyingRustTuple<'_> {
4907 fn from(value: userUnderlyingReturn) -> Self {
4908 (value._0,)
4909 }
4910 }
4911 #[automatically_derived]
4912 #[doc(hidden)]
4913 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4914 for userUnderlyingReturn {
4915 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4916 Self { _0: tuple.0 }
4917 }
4918 }
4919 }
4920 #[automatically_derived]
4921 impl alloy_sol_types::SolCall for userUnderlyingCall {
4922 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4923 type Token<'a> = <Self::Parameters<
4924 'a,
4925 > as alloy_sol_types::SolType>::Token<'a>;
4926 type Return = alloy::sol_types::private::primitives::aliases::U256;
4927 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4928 type ReturnToken<'a> = <Self::ReturnTuple<
4929 'a,
4930 > as alloy_sol_types::SolType>::Token<'a>;
4931 const SIGNATURE: &'static str = "userUnderlying(address)";
4932 const SELECTOR: [u8; 4] = [143u8, 106u8, 98u8, 64u8];
4933 #[inline]
4934 fn new<'a>(
4935 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4936 ) -> Self {
4937 tuple.into()
4938 }
4939 #[inline]
4940 fn tokenize(&self) -> Self::Token<'_> {
4941 (
4942 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4943 &self.user,
4944 ),
4945 )
4946 }
4947 #[inline]
4948 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4949 (
4950 <alloy::sol_types::sol_data::Uint<
4951 256,
4952 > as alloy_sol_types::SolType>::tokenize(ret),
4953 )
4954 }
4955 #[inline]
4956 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4957 <Self::ReturnTuple<
4958 '_,
4959 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4960 .map(|r| {
4961 let r: userUnderlyingReturn = r.into();
4962 r._0
4963 })
4964 }
4965 #[inline]
4966 fn abi_decode_returns_validate(
4967 data: &[u8],
4968 ) -> alloy_sol_types::Result<Self::Return> {
4969 <Self::ReturnTuple<
4970 '_,
4971 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4972 .map(|r| {
4973 let r: userUnderlyingReturn = r.into();
4974 r._0
4975 })
4976 }
4977 }
4978 };
4979 #[derive(serde::Serialize, serde::Deserialize)]
4980 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4981 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4986 #[derive(Clone)]
4987 pub struct userUnderlyingViewCall {
4988 #[allow(missing_docs)]
4989 pub user: alloy::sol_types::private::Address,
4990 }
4991 #[derive(serde::Serialize, serde::Deserialize)]
4992 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4993 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4995 #[derive(Clone)]
4996 pub struct userUnderlyingViewReturn {
4997 #[allow(missing_docs)]
4998 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4999 }
5000 #[allow(
5001 non_camel_case_types,
5002 non_snake_case,
5003 clippy::pub_underscore_fields,
5004 clippy::style
5005 )]
5006 const _: () = {
5007 use alloy::sol_types as alloy_sol_types;
5008 {
5009 #[doc(hidden)]
5010 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5011 #[doc(hidden)]
5012 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5013 #[cfg(test)]
5014 #[allow(dead_code, unreachable_patterns)]
5015 fn _type_assertion(
5016 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5017 ) {
5018 match _t {
5019 alloy_sol_types::private::AssertTypeEq::<
5020 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5021 >(_) => {}
5022 }
5023 }
5024 #[automatically_derived]
5025 #[doc(hidden)]
5026 impl ::core::convert::From<userUnderlyingViewCall>
5027 for UnderlyingRustTuple<'_> {
5028 fn from(value: userUnderlyingViewCall) -> Self {
5029 (value.user,)
5030 }
5031 }
5032 #[automatically_derived]
5033 #[doc(hidden)]
5034 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5035 for userUnderlyingViewCall {
5036 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5037 Self { user: tuple.0 }
5038 }
5039 }
5040 }
5041 {
5042 #[doc(hidden)]
5043 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5044 #[doc(hidden)]
5045 type UnderlyingRustTuple<'a> = (
5046 alloy::sol_types::private::primitives::aliases::U256,
5047 );
5048 #[cfg(test)]
5049 #[allow(dead_code, unreachable_patterns)]
5050 fn _type_assertion(
5051 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5052 ) {
5053 match _t {
5054 alloy_sol_types::private::AssertTypeEq::<
5055 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5056 >(_) => {}
5057 }
5058 }
5059 #[automatically_derived]
5060 #[doc(hidden)]
5061 impl ::core::convert::From<userUnderlyingViewReturn>
5062 for UnderlyingRustTuple<'_> {
5063 fn from(value: userUnderlyingViewReturn) -> Self {
5064 (value._0,)
5065 }
5066 }
5067 #[automatically_derived]
5068 #[doc(hidden)]
5069 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5070 for userUnderlyingViewReturn {
5071 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5072 Self { _0: tuple.0 }
5073 }
5074 }
5075 }
5076 #[automatically_derived]
5077 impl alloy_sol_types::SolCall for userUnderlyingViewCall {
5078 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
5079 type Token<'a> = <Self::Parameters<
5080 'a,
5081 > as alloy_sol_types::SolType>::Token<'a>;
5082 type Return = alloy::sol_types::private::primitives::aliases::U256;
5083 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5084 type ReturnToken<'a> = <Self::ReturnTuple<
5085 'a,
5086 > as alloy_sol_types::SolType>::Token<'a>;
5087 const SIGNATURE: &'static str = "userUnderlyingView(address)";
5088 const SELECTOR: [u8; 4] = [85u8, 60u8, 165u8, 248u8];
5089 #[inline]
5090 fn new<'a>(
5091 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5092 ) -> Self {
5093 tuple.into()
5094 }
5095 #[inline]
5096 fn tokenize(&self) -> Self::Token<'_> {
5097 (
5098 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5099 &self.user,
5100 ),
5101 )
5102 }
5103 #[inline]
5104 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5105 (
5106 <alloy::sol_types::sol_data::Uint<
5107 256,
5108 > as alloy_sol_types::SolType>::tokenize(ret),
5109 )
5110 }
5111 #[inline]
5112 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5113 <Self::ReturnTuple<
5114 '_,
5115 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5116 .map(|r| {
5117 let r: userUnderlyingViewReturn = r.into();
5118 r._0
5119 })
5120 }
5121 #[inline]
5122 fn abi_decode_returns_validate(
5123 data: &[u8],
5124 ) -> alloy_sol_types::Result<Self::Return> {
5125 <Self::ReturnTuple<
5126 '_,
5127 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5128 .map(|r| {
5129 let r: userUnderlyingViewReturn = r.into();
5130 r._0
5131 })
5132 }
5133 }
5134 };
5135 #[derive(serde::Serialize, serde::Deserialize)]
5136 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5137 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5142 #[derive(Clone)]
5143 pub struct versionCall;
5144 #[derive(serde::Serialize, serde::Deserialize)]
5145 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5146 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5148 #[derive(Clone)]
5149 pub struct versionReturn {
5150 #[allow(missing_docs)]
5151 pub _0: alloy::sol_types::private::String,
5152 }
5153 #[allow(
5154 non_camel_case_types,
5155 non_snake_case,
5156 clippy::pub_underscore_fields,
5157 clippy::style
5158 )]
5159 const _: () = {
5160 use alloy::sol_types as alloy_sol_types;
5161 {
5162 #[doc(hidden)]
5163 type UnderlyingSolTuple<'a> = ();
5164 #[doc(hidden)]
5165 type UnderlyingRustTuple<'a> = ();
5166 #[cfg(test)]
5167 #[allow(dead_code, unreachable_patterns)]
5168 fn _type_assertion(
5169 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5170 ) {
5171 match _t {
5172 alloy_sol_types::private::AssertTypeEq::<
5173 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5174 >(_) => {}
5175 }
5176 }
5177 #[automatically_derived]
5178 #[doc(hidden)]
5179 impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
5180 fn from(value: versionCall) -> Self {
5181 ()
5182 }
5183 }
5184 #[automatically_derived]
5185 #[doc(hidden)]
5186 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
5187 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5188 Self
5189 }
5190 }
5191 }
5192 {
5193 #[doc(hidden)]
5194 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
5195 #[doc(hidden)]
5196 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
5197 #[cfg(test)]
5198 #[allow(dead_code, unreachable_patterns)]
5199 fn _type_assertion(
5200 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5201 ) {
5202 match _t {
5203 alloy_sol_types::private::AssertTypeEq::<
5204 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5205 >(_) => {}
5206 }
5207 }
5208 #[automatically_derived]
5209 #[doc(hidden)]
5210 impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
5211 fn from(value: versionReturn) -> Self {
5212 (value._0,)
5213 }
5214 }
5215 #[automatically_derived]
5216 #[doc(hidden)]
5217 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
5218 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5219 Self { _0: tuple.0 }
5220 }
5221 }
5222 }
5223 #[automatically_derived]
5224 impl alloy_sol_types::SolCall for versionCall {
5225 type Parameters<'a> = ();
5226 type Token<'a> = <Self::Parameters<
5227 'a,
5228 > as alloy_sol_types::SolType>::Token<'a>;
5229 type Return = alloy::sol_types::private::String;
5230 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
5231 type ReturnToken<'a> = <Self::ReturnTuple<
5232 'a,
5233 > as alloy_sol_types::SolType>::Token<'a>;
5234 const SIGNATURE: &'static str = "version()";
5235 const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
5236 #[inline]
5237 fn new<'a>(
5238 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5239 ) -> Self {
5240 tuple.into()
5241 }
5242 #[inline]
5243 fn tokenize(&self) -> Self::Token<'_> {
5244 ()
5245 }
5246 #[inline]
5247 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5248 (
5249 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
5250 ret,
5251 ),
5252 )
5253 }
5254 #[inline]
5255 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5256 <Self::ReturnTuple<
5257 '_,
5258 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5259 .map(|r| {
5260 let r: versionReturn = r.into();
5261 r._0
5262 })
5263 }
5264 #[inline]
5265 fn abi_decode_returns_validate(
5266 data: &[u8],
5267 ) -> alloy_sol_types::Result<Self::Return> {
5268 <Self::ReturnTuple<
5269 '_,
5270 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5271 .map(|r| {
5272 let r: versionReturn = r.into();
5273 r._0
5274 })
5275 }
5276 }
5277 };
5278 #[derive(serde::Serialize, serde::Deserialize)]
5279 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5280 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5285 #[derive(Clone)]
5286 pub struct withdrawCall {
5287 #[allow(missing_docs)]
5288 pub recipient: alloy::sol_types::private::Address,
5289 #[allow(missing_docs)]
5290 pub token: alloy::sol_types::private::Address,
5291 #[allow(missing_docs)]
5292 pub amountShares: alloy::sol_types::private::primitives::aliases::U256,
5293 }
5294 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5296 #[derive(Clone)]
5297 pub struct withdrawReturn {}
5298 #[allow(
5299 non_camel_case_types,
5300 non_snake_case,
5301 clippy::pub_underscore_fields,
5302 clippy::style
5303 )]
5304 const _: () = {
5305 use alloy::sol_types as alloy_sol_types;
5306 {
5307 #[doc(hidden)]
5308 type UnderlyingSolTuple<'a> = (
5309 alloy::sol_types::sol_data::Address,
5310 alloy::sol_types::sol_data::Address,
5311 alloy::sol_types::sol_data::Uint<256>,
5312 );
5313 #[doc(hidden)]
5314 type UnderlyingRustTuple<'a> = (
5315 alloy::sol_types::private::Address,
5316 alloy::sol_types::private::Address,
5317 alloy::sol_types::private::primitives::aliases::U256,
5318 );
5319 #[cfg(test)]
5320 #[allow(dead_code, unreachable_patterns)]
5321 fn _type_assertion(
5322 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5323 ) {
5324 match _t {
5325 alloy_sol_types::private::AssertTypeEq::<
5326 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5327 >(_) => {}
5328 }
5329 }
5330 #[automatically_derived]
5331 #[doc(hidden)]
5332 impl ::core::convert::From<withdrawCall> for UnderlyingRustTuple<'_> {
5333 fn from(value: withdrawCall) -> Self {
5334 (value.recipient, value.token, value.amountShares)
5335 }
5336 }
5337 #[automatically_derived]
5338 #[doc(hidden)]
5339 impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawCall {
5340 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5341 Self {
5342 recipient: tuple.0,
5343 token: tuple.1,
5344 amountShares: tuple.2,
5345 }
5346 }
5347 }
5348 }
5349 {
5350 #[doc(hidden)]
5351 type UnderlyingSolTuple<'a> = ();
5352 #[doc(hidden)]
5353 type UnderlyingRustTuple<'a> = ();
5354 #[cfg(test)]
5355 #[allow(dead_code, unreachable_patterns)]
5356 fn _type_assertion(
5357 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5358 ) {
5359 match _t {
5360 alloy_sol_types::private::AssertTypeEq::<
5361 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5362 >(_) => {}
5363 }
5364 }
5365 #[automatically_derived]
5366 #[doc(hidden)]
5367 impl ::core::convert::From<withdrawReturn> for UnderlyingRustTuple<'_> {
5368 fn from(value: withdrawReturn) -> Self {
5369 ()
5370 }
5371 }
5372 #[automatically_derived]
5373 #[doc(hidden)]
5374 impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawReturn {
5375 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5376 Self {}
5377 }
5378 }
5379 }
5380 impl withdrawReturn {
5381 fn _tokenize(
5382 &self,
5383 ) -> <withdrawCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
5384 ()
5385 }
5386 }
5387 #[automatically_derived]
5388 impl alloy_sol_types::SolCall for withdrawCall {
5389 type Parameters<'a> = (
5390 alloy::sol_types::sol_data::Address,
5391 alloy::sol_types::sol_data::Address,
5392 alloy::sol_types::sol_data::Uint<256>,
5393 );
5394 type Token<'a> = <Self::Parameters<
5395 'a,
5396 > as alloy_sol_types::SolType>::Token<'a>;
5397 type Return = withdrawReturn;
5398 type ReturnTuple<'a> = ();
5399 type ReturnToken<'a> = <Self::ReturnTuple<
5400 'a,
5401 > as alloy_sol_types::SolType>::Token<'a>;
5402 const SIGNATURE: &'static str = "withdraw(address,address,uint256)";
5403 const SELECTOR: [u8; 4] = [217u8, 202u8, 237u8, 18u8];
5404 #[inline]
5405 fn new<'a>(
5406 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5407 ) -> Self {
5408 tuple.into()
5409 }
5410 #[inline]
5411 fn tokenize(&self) -> Self::Token<'_> {
5412 (
5413 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5414 &self.recipient,
5415 ),
5416 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5417 &self.token,
5418 ),
5419 <alloy::sol_types::sol_data::Uint<
5420 256,
5421 > as alloy_sol_types::SolType>::tokenize(&self.amountShares),
5422 )
5423 }
5424 #[inline]
5425 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5426 withdrawReturn::_tokenize(ret)
5427 }
5428 #[inline]
5429 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5430 <Self::ReturnTuple<
5431 '_,
5432 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5433 .map(Into::into)
5434 }
5435 #[inline]
5436 fn abi_decode_returns_validate(
5437 data: &[u8],
5438 ) -> alloy_sol_types::Result<Self::Return> {
5439 <Self::ReturnTuple<
5440 '_,
5441 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5442 .map(Into::into)
5443 }
5444 }
5445 };
5446 #[derive(serde::Serialize, serde::Deserialize)]
5448 #[derive()]
5449 pub enum StrategyBaseCalls {
5450 #[allow(missing_docs)]
5451 deposit(depositCall),
5452 #[allow(missing_docs)]
5453 explanation(explanationCall),
5454 #[allow(missing_docs)]
5455 initialize(initializeCall),
5456 #[allow(missing_docs)]
5457 pause(pauseCall),
5458 #[allow(missing_docs)]
5459 pauseAll(pauseAllCall),
5460 #[allow(missing_docs)]
5461 paused_0(paused_0Call),
5462 #[allow(missing_docs)]
5463 paused_1(paused_1Call),
5464 #[allow(missing_docs)]
5465 pauserRegistry(pauserRegistryCall),
5466 #[allow(missing_docs)]
5467 shares(sharesCall),
5468 #[allow(missing_docs)]
5469 sharesToUnderlying(sharesToUnderlyingCall),
5470 #[allow(missing_docs)]
5471 sharesToUnderlyingView(sharesToUnderlyingViewCall),
5472 #[allow(missing_docs)]
5473 strategyManager(strategyManagerCall),
5474 #[allow(missing_docs)]
5475 totalShares(totalSharesCall),
5476 #[allow(missing_docs)]
5477 underlyingToShares(underlyingToSharesCall),
5478 #[allow(missing_docs)]
5479 underlyingToSharesView(underlyingToSharesViewCall),
5480 #[allow(missing_docs)]
5481 underlyingToken(underlyingTokenCall),
5482 #[allow(missing_docs)]
5483 unpause(unpauseCall),
5484 #[allow(missing_docs)]
5485 userUnderlying(userUnderlyingCall),
5486 #[allow(missing_docs)]
5487 userUnderlyingView(userUnderlyingViewCall),
5488 #[allow(missing_docs)]
5489 version(versionCall),
5490 #[allow(missing_docs)]
5491 withdraw(withdrawCall),
5492 }
5493 #[automatically_derived]
5494 impl StrategyBaseCalls {
5495 pub const SELECTORS: &'static [[u8; 4usize]] = &[
5502 [19u8, 100u8, 57u8, 221u8],
5503 [36u8, 149u8, 165u8, 153u8],
5504 [57u8, 183u8, 14u8, 56u8],
5505 [58u8, 152u8, 239u8, 57u8],
5506 [71u8, 231u8, 239u8, 36u8],
5507 [84u8, 253u8, 77u8, 80u8],
5508 [85u8, 60u8, 165u8, 248u8],
5509 [89u8, 92u8, 106u8, 103u8],
5510 [90u8, 200u8, 106u8, 183u8],
5511 [92u8, 151u8, 90u8, 187u8],
5512 [122u8, 139u8, 38u8, 55u8],
5513 [136u8, 111u8, 17u8, 149u8],
5514 [140u8, 135u8, 16u8, 25u8],
5515 [143u8, 106u8, 98u8, 64u8],
5516 [171u8, 89u8, 33u8, 225u8],
5517 [196u8, 214u8, 109u8, 232u8],
5518 [206u8, 124u8, 42u8, 194u8],
5519 [217u8, 202u8, 237u8, 18u8],
5520 [227u8, 218u8, 229u8, 28u8],
5521 [243u8, 231u8, 56u8, 117u8],
5522 [250u8, 188u8, 28u8, 188u8],
5523 ];
5524 }
5525 #[automatically_derived]
5526 impl alloy_sol_types::SolInterface for StrategyBaseCalls {
5527 const NAME: &'static str = "StrategyBaseCalls";
5528 const MIN_DATA_LENGTH: usize = 0usize;
5529 const COUNT: usize = 21usize;
5530 #[inline]
5531 fn selector(&self) -> [u8; 4] {
5532 match self {
5533 Self::deposit(_) => <depositCall as alloy_sol_types::SolCall>::SELECTOR,
5534 Self::explanation(_) => {
5535 <explanationCall as alloy_sol_types::SolCall>::SELECTOR
5536 }
5537 Self::initialize(_) => {
5538 <initializeCall as alloy_sol_types::SolCall>::SELECTOR
5539 }
5540 Self::pause(_) => <pauseCall as alloy_sol_types::SolCall>::SELECTOR,
5541 Self::pauseAll(_) => <pauseAllCall as alloy_sol_types::SolCall>::SELECTOR,
5542 Self::paused_0(_) => <paused_0Call as alloy_sol_types::SolCall>::SELECTOR,
5543 Self::paused_1(_) => <paused_1Call as alloy_sol_types::SolCall>::SELECTOR,
5544 Self::pauserRegistry(_) => {
5545 <pauserRegistryCall as alloy_sol_types::SolCall>::SELECTOR
5546 }
5547 Self::shares(_) => <sharesCall as alloy_sol_types::SolCall>::SELECTOR,
5548 Self::sharesToUnderlying(_) => {
5549 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::SELECTOR
5550 }
5551 Self::sharesToUnderlyingView(_) => {
5552 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::SELECTOR
5553 }
5554 Self::strategyManager(_) => {
5555 <strategyManagerCall as alloy_sol_types::SolCall>::SELECTOR
5556 }
5557 Self::totalShares(_) => {
5558 <totalSharesCall as alloy_sol_types::SolCall>::SELECTOR
5559 }
5560 Self::underlyingToShares(_) => {
5561 <underlyingToSharesCall as alloy_sol_types::SolCall>::SELECTOR
5562 }
5563 Self::underlyingToSharesView(_) => {
5564 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::SELECTOR
5565 }
5566 Self::underlyingToken(_) => {
5567 <underlyingTokenCall as alloy_sol_types::SolCall>::SELECTOR
5568 }
5569 Self::unpause(_) => <unpauseCall as alloy_sol_types::SolCall>::SELECTOR,
5570 Self::userUnderlying(_) => {
5571 <userUnderlyingCall as alloy_sol_types::SolCall>::SELECTOR
5572 }
5573 Self::userUnderlyingView(_) => {
5574 <userUnderlyingViewCall as alloy_sol_types::SolCall>::SELECTOR
5575 }
5576 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
5577 Self::withdraw(_) => <withdrawCall as alloy_sol_types::SolCall>::SELECTOR,
5578 }
5579 }
5580 #[inline]
5581 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5582 Self::SELECTORS.get(i).copied()
5583 }
5584 #[inline]
5585 fn valid_selector(selector: [u8; 4]) -> bool {
5586 Self::SELECTORS.binary_search(&selector).is_ok()
5587 }
5588 #[inline]
5589 #[allow(non_snake_case)]
5590 fn abi_decode_raw(
5591 selector: [u8; 4],
5592 data: &[u8],
5593 ) -> alloy_sol_types::Result<Self> {
5594 static DECODE_SHIMS: &[fn(
5595 &[u8],
5596 ) -> alloy_sol_types::Result<StrategyBaseCalls>] = &[
5597 {
5598 fn pause(data: &[u8]) -> alloy_sol_types::Result<StrategyBaseCalls> {
5599 <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5600 .map(StrategyBaseCalls::pause)
5601 }
5602 pause
5603 },
5604 {
5605 fn underlyingToken(
5606 data: &[u8],
5607 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5608 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
5609 data,
5610 )
5611 .map(StrategyBaseCalls::underlyingToken)
5612 }
5613 underlyingToken
5614 },
5615 {
5616 fn strategyManager(
5617 data: &[u8],
5618 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5619 <strategyManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
5620 data,
5621 )
5622 .map(StrategyBaseCalls::strategyManager)
5623 }
5624 strategyManager
5625 },
5626 {
5627 fn totalShares(
5628 data: &[u8],
5629 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5630 <totalSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
5631 data,
5632 )
5633 .map(StrategyBaseCalls::totalShares)
5634 }
5635 totalShares
5636 },
5637 {
5638 fn deposit(
5639 data: &[u8],
5640 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5641 <depositCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5642 .map(StrategyBaseCalls::deposit)
5643 }
5644 deposit
5645 },
5646 {
5647 fn version(
5648 data: &[u8],
5649 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5650 <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5651 .map(StrategyBaseCalls::version)
5652 }
5653 version
5654 },
5655 {
5656 fn userUnderlyingView(
5657 data: &[u8],
5658 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5659 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_decode_raw(
5660 data,
5661 )
5662 .map(StrategyBaseCalls::userUnderlyingView)
5663 }
5664 userUnderlyingView
5665 },
5666 {
5667 fn pauseAll(
5668 data: &[u8],
5669 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5670 <pauseAllCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5671 .map(StrategyBaseCalls::pauseAll)
5672 }
5673 pauseAll
5674 },
5675 {
5676 fn paused_0(
5677 data: &[u8],
5678 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5679 <paused_0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
5680 .map(StrategyBaseCalls::paused_0)
5681 }
5682 paused_0
5683 },
5684 {
5685 fn paused_1(
5686 data: &[u8],
5687 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5688 <paused_1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
5689 .map(StrategyBaseCalls::paused_1)
5690 }
5691 paused_1
5692 },
5693 {
5694 fn sharesToUnderlyingView(
5695 data: &[u8],
5696 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5697 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_decode_raw(
5698 data,
5699 )
5700 .map(StrategyBaseCalls::sharesToUnderlyingView)
5701 }
5702 sharesToUnderlyingView
5703 },
5704 {
5705 fn pauserRegistry(
5706 data: &[u8],
5707 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5708 <pauserRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
5709 data,
5710 )
5711 .map(StrategyBaseCalls::pauserRegistry)
5712 }
5713 pauserRegistry
5714 },
5715 {
5716 fn underlyingToShares(
5717 data: &[u8],
5718 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5719 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
5720 data,
5721 )
5722 .map(StrategyBaseCalls::underlyingToShares)
5723 }
5724 underlyingToShares
5725 },
5726 {
5727 fn userUnderlying(
5728 data: &[u8],
5729 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5730 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_decode_raw(
5731 data,
5732 )
5733 .map(StrategyBaseCalls::userUnderlying)
5734 }
5735 userUnderlying
5736 },
5737 {
5738 fn explanation(
5739 data: &[u8],
5740 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5741 <explanationCall as alloy_sol_types::SolCall>::abi_decode_raw(
5742 data,
5743 )
5744 .map(StrategyBaseCalls::explanation)
5745 }
5746 explanation
5747 },
5748 {
5749 fn initialize(
5750 data: &[u8],
5751 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5752 <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
5753 data,
5754 )
5755 .map(StrategyBaseCalls::initialize)
5756 }
5757 initialize
5758 },
5759 {
5760 fn shares(
5761 data: &[u8],
5762 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5763 <sharesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5764 .map(StrategyBaseCalls::shares)
5765 }
5766 shares
5767 },
5768 {
5769 fn withdraw(
5770 data: &[u8],
5771 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5772 <withdrawCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5773 .map(StrategyBaseCalls::withdraw)
5774 }
5775 withdraw
5776 },
5777 {
5778 fn underlyingToSharesView(
5779 data: &[u8],
5780 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5781 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_decode_raw(
5782 data,
5783 )
5784 .map(StrategyBaseCalls::underlyingToSharesView)
5785 }
5786 underlyingToSharesView
5787 },
5788 {
5789 fn sharesToUnderlying(
5790 data: &[u8],
5791 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5792 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_decode_raw(
5793 data,
5794 )
5795 .map(StrategyBaseCalls::sharesToUnderlying)
5796 }
5797 sharesToUnderlying
5798 },
5799 {
5800 fn unpause(
5801 data: &[u8],
5802 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5803 <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5804 .map(StrategyBaseCalls::unpause)
5805 }
5806 unpause
5807 },
5808 ];
5809 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5810 return Err(
5811 alloy_sol_types::Error::unknown_selector(
5812 <Self as alloy_sol_types::SolInterface>::NAME,
5813 selector,
5814 ),
5815 );
5816 };
5817 DECODE_SHIMS[idx](data)
5818 }
5819 #[inline]
5820 #[allow(non_snake_case)]
5821 fn abi_decode_raw_validate(
5822 selector: [u8; 4],
5823 data: &[u8],
5824 ) -> alloy_sol_types::Result<Self> {
5825 static DECODE_VALIDATE_SHIMS: &[fn(
5826 &[u8],
5827 ) -> alloy_sol_types::Result<StrategyBaseCalls>] = &[
5828 {
5829 fn pause(data: &[u8]) -> alloy_sol_types::Result<StrategyBaseCalls> {
5830 <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5831 data,
5832 )
5833 .map(StrategyBaseCalls::pause)
5834 }
5835 pause
5836 },
5837 {
5838 fn underlyingToken(
5839 data: &[u8],
5840 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5841 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5842 data,
5843 )
5844 .map(StrategyBaseCalls::underlyingToken)
5845 }
5846 underlyingToken
5847 },
5848 {
5849 fn strategyManager(
5850 data: &[u8],
5851 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5852 <strategyManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5853 data,
5854 )
5855 .map(StrategyBaseCalls::strategyManager)
5856 }
5857 strategyManager
5858 },
5859 {
5860 fn totalShares(
5861 data: &[u8],
5862 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5863 <totalSharesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5864 data,
5865 )
5866 .map(StrategyBaseCalls::totalShares)
5867 }
5868 totalShares
5869 },
5870 {
5871 fn deposit(
5872 data: &[u8],
5873 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5874 <depositCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5875 data,
5876 )
5877 .map(StrategyBaseCalls::deposit)
5878 }
5879 deposit
5880 },
5881 {
5882 fn version(
5883 data: &[u8],
5884 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5885 <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5886 data,
5887 )
5888 .map(StrategyBaseCalls::version)
5889 }
5890 version
5891 },
5892 {
5893 fn userUnderlyingView(
5894 data: &[u8],
5895 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5896 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5897 data,
5898 )
5899 .map(StrategyBaseCalls::userUnderlyingView)
5900 }
5901 userUnderlyingView
5902 },
5903 {
5904 fn pauseAll(
5905 data: &[u8],
5906 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5907 <pauseAllCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5908 data,
5909 )
5910 .map(StrategyBaseCalls::pauseAll)
5911 }
5912 pauseAll
5913 },
5914 {
5915 fn paused_0(
5916 data: &[u8],
5917 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5918 <paused_0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5919 data,
5920 )
5921 .map(StrategyBaseCalls::paused_0)
5922 }
5923 paused_0
5924 },
5925 {
5926 fn paused_1(
5927 data: &[u8],
5928 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5929 <paused_1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5930 data,
5931 )
5932 .map(StrategyBaseCalls::paused_1)
5933 }
5934 paused_1
5935 },
5936 {
5937 fn sharesToUnderlyingView(
5938 data: &[u8],
5939 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5940 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5941 data,
5942 )
5943 .map(StrategyBaseCalls::sharesToUnderlyingView)
5944 }
5945 sharesToUnderlyingView
5946 },
5947 {
5948 fn pauserRegistry(
5949 data: &[u8],
5950 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5951 <pauserRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5952 data,
5953 )
5954 .map(StrategyBaseCalls::pauserRegistry)
5955 }
5956 pauserRegistry
5957 },
5958 {
5959 fn underlyingToShares(
5960 data: &[u8],
5961 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5962 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5963 data,
5964 )
5965 .map(StrategyBaseCalls::underlyingToShares)
5966 }
5967 underlyingToShares
5968 },
5969 {
5970 fn userUnderlying(
5971 data: &[u8],
5972 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5973 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5974 data,
5975 )
5976 .map(StrategyBaseCalls::userUnderlying)
5977 }
5978 userUnderlying
5979 },
5980 {
5981 fn explanation(
5982 data: &[u8],
5983 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5984 <explanationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5985 data,
5986 )
5987 .map(StrategyBaseCalls::explanation)
5988 }
5989 explanation
5990 },
5991 {
5992 fn initialize(
5993 data: &[u8],
5994 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5995 <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5996 data,
5997 )
5998 .map(StrategyBaseCalls::initialize)
5999 }
6000 initialize
6001 },
6002 {
6003 fn shares(
6004 data: &[u8],
6005 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
6006 <sharesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
6007 data,
6008 )
6009 .map(StrategyBaseCalls::shares)
6010 }
6011 shares
6012 },
6013 {
6014 fn withdraw(
6015 data: &[u8],
6016 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
6017 <withdrawCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
6018 data,
6019 )
6020 .map(StrategyBaseCalls::withdraw)
6021 }
6022 withdraw
6023 },
6024 {
6025 fn underlyingToSharesView(
6026 data: &[u8],
6027 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
6028 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
6029 data,
6030 )
6031 .map(StrategyBaseCalls::underlyingToSharesView)
6032 }
6033 underlyingToSharesView
6034 },
6035 {
6036 fn sharesToUnderlying(
6037 data: &[u8],
6038 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
6039 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
6040 data,
6041 )
6042 .map(StrategyBaseCalls::sharesToUnderlying)
6043 }
6044 sharesToUnderlying
6045 },
6046 {
6047 fn unpause(
6048 data: &[u8],
6049 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
6050 <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
6051 data,
6052 )
6053 .map(StrategyBaseCalls::unpause)
6054 }
6055 unpause
6056 },
6057 ];
6058 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
6059 return Err(
6060 alloy_sol_types::Error::unknown_selector(
6061 <Self as alloy_sol_types::SolInterface>::NAME,
6062 selector,
6063 ),
6064 );
6065 };
6066 DECODE_VALIDATE_SHIMS[idx](data)
6067 }
6068 #[inline]
6069 fn abi_encoded_size(&self) -> usize {
6070 match self {
6071 Self::deposit(inner) => {
6072 <depositCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6073 }
6074 Self::explanation(inner) => {
6075 <explanationCall as alloy_sol_types::SolCall>::abi_encoded_size(
6076 inner,
6077 )
6078 }
6079 Self::initialize(inner) => {
6080 <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6081 }
6082 Self::pause(inner) => {
6083 <pauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6084 }
6085 Self::pauseAll(inner) => {
6086 <pauseAllCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6087 }
6088 Self::paused_0(inner) => {
6089 <paused_0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6090 }
6091 Self::paused_1(inner) => {
6092 <paused_1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6093 }
6094 Self::pauserRegistry(inner) => {
6095 <pauserRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
6096 inner,
6097 )
6098 }
6099 Self::shares(inner) => {
6100 <sharesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6101 }
6102 Self::sharesToUnderlying(inner) => {
6103 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_encoded_size(
6104 inner,
6105 )
6106 }
6107 Self::sharesToUnderlyingView(inner) => {
6108 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encoded_size(
6109 inner,
6110 )
6111 }
6112 Self::strategyManager(inner) => {
6113 <strategyManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
6114 inner,
6115 )
6116 }
6117 Self::totalShares(inner) => {
6118 <totalSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
6119 inner,
6120 )
6121 }
6122 Self::underlyingToShares(inner) => {
6123 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
6124 inner,
6125 )
6126 }
6127 Self::underlyingToSharesView(inner) => {
6128 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_encoded_size(
6129 inner,
6130 )
6131 }
6132 Self::underlyingToken(inner) => {
6133 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
6134 inner,
6135 )
6136 }
6137 Self::unpause(inner) => {
6138 <unpauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6139 }
6140 Self::userUnderlying(inner) => {
6141 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_encoded_size(
6142 inner,
6143 )
6144 }
6145 Self::userUnderlyingView(inner) => {
6146 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encoded_size(
6147 inner,
6148 )
6149 }
6150 Self::version(inner) => {
6151 <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6152 }
6153 Self::withdraw(inner) => {
6154 <withdrawCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6155 }
6156 }
6157 }
6158 #[inline]
6159 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
6160 match self {
6161 Self::deposit(inner) => {
6162 <depositCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6163 }
6164 Self::explanation(inner) => {
6165 <explanationCall as alloy_sol_types::SolCall>::abi_encode_raw(
6166 inner,
6167 out,
6168 )
6169 }
6170 Self::initialize(inner) => {
6171 <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
6172 inner,
6173 out,
6174 )
6175 }
6176 Self::pause(inner) => {
6177 <pauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6178 }
6179 Self::pauseAll(inner) => {
6180 <pauseAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
6181 inner,
6182 out,
6183 )
6184 }
6185 Self::paused_0(inner) => {
6186 <paused_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
6187 inner,
6188 out,
6189 )
6190 }
6191 Self::paused_1(inner) => {
6192 <paused_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
6193 inner,
6194 out,
6195 )
6196 }
6197 Self::pauserRegistry(inner) => {
6198 <pauserRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
6199 inner,
6200 out,
6201 )
6202 }
6203 Self::shares(inner) => {
6204 <sharesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6205 }
6206 Self::sharesToUnderlying(inner) => {
6207 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_encode_raw(
6208 inner,
6209 out,
6210 )
6211 }
6212 Self::sharesToUnderlyingView(inner) => {
6213 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encode_raw(
6214 inner,
6215 out,
6216 )
6217 }
6218 Self::strategyManager(inner) => {
6219 <strategyManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
6220 inner,
6221 out,
6222 )
6223 }
6224 Self::totalShares(inner) => {
6225 <totalSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
6226 inner,
6227 out,
6228 )
6229 }
6230 Self::underlyingToShares(inner) => {
6231 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
6232 inner,
6233 out,
6234 )
6235 }
6236 Self::underlyingToSharesView(inner) => {
6237 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_encode_raw(
6238 inner,
6239 out,
6240 )
6241 }
6242 Self::underlyingToken(inner) => {
6243 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
6244 inner,
6245 out,
6246 )
6247 }
6248 Self::unpause(inner) => {
6249 <unpauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6250 }
6251 Self::userUnderlying(inner) => {
6252 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_encode_raw(
6253 inner,
6254 out,
6255 )
6256 }
6257 Self::userUnderlyingView(inner) => {
6258 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encode_raw(
6259 inner,
6260 out,
6261 )
6262 }
6263 Self::version(inner) => {
6264 <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6265 }
6266 Self::withdraw(inner) => {
6267 <withdrawCall as alloy_sol_types::SolCall>::abi_encode_raw(
6268 inner,
6269 out,
6270 )
6271 }
6272 }
6273 }
6274 }
6275 #[derive(serde::Serialize, serde::Deserialize)]
6277 #[derive(Debug, PartialEq, Eq, Hash)]
6278 pub enum StrategyBaseErrors {
6279 #[allow(missing_docs)]
6280 BalanceExceedsMaxTotalDeposits(BalanceExceedsMaxTotalDeposits),
6281 #[allow(missing_docs)]
6282 CurrentlyPaused(CurrentlyPaused),
6283 #[allow(missing_docs)]
6284 InputAddressZero(InputAddressZero),
6285 #[allow(missing_docs)]
6286 InvalidNewPausedStatus(InvalidNewPausedStatus),
6287 #[allow(missing_docs)]
6288 InvalidShortString(InvalidShortString),
6289 #[allow(missing_docs)]
6290 MaxPerDepositExceedsMax(MaxPerDepositExceedsMax),
6291 #[allow(missing_docs)]
6292 NewSharesZero(NewSharesZero),
6293 #[allow(missing_docs)]
6294 OnlyPauser(OnlyPauser),
6295 #[allow(missing_docs)]
6296 OnlyStrategyManager(OnlyStrategyManager),
6297 #[allow(missing_docs)]
6298 OnlyUnderlyingToken(OnlyUnderlyingToken),
6299 #[allow(missing_docs)]
6300 OnlyUnpauser(OnlyUnpauser),
6301 #[allow(missing_docs)]
6302 StringTooLong(StringTooLong),
6303 #[allow(missing_docs)]
6304 TotalSharesExceedsMax(TotalSharesExceedsMax),
6305 #[allow(missing_docs)]
6306 WithdrawalAmountExceedsTotalDeposits(WithdrawalAmountExceedsTotalDeposits),
6307 }
6308 #[automatically_derived]
6309 impl StrategyBaseErrors {
6310 pub const SELECTORS: &'static [[u8; 4usize]] = &[
6317 [20u8, 172u8, 30u8, 220u8],
6318 [24u8, 114u8, 93u8, 166u8],
6319 [48u8, 90u8, 39u8, 169u8],
6320 [72u8, 218u8, 113u8, 79u8],
6321 [94u8, 41u8, 209u8, 70u8],
6322 [115u8, 99u8, 33u8, 118u8],
6323 [117u8, 223u8, 81u8, 220u8],
6324 [121u8, 72u8, 33u8, 255u8],
6325 [132u8, 10u8, 72u8, 213u8],
6326 [179u8, 81u8, 43u8, 12u8],
6327 [180u8, 105u8, 223u8, 48u8],
6328 [196u8, 170u8, 247u8, 64u8],
6329 [198u8, 29u8, 202u8, 93u8],
6330 [216u8, 107u8, 174u8, 103u8],
6331 ];
6332 }
6333 #[automatically_derived]
6334 impl alloy_sol_types::SolInterface for StrategyBaseErrors {
6335 const NAME: &'static str = "StrategyBaseErrors";
6336 const MIN_DATA_LENGTH: usize = 0usize;
6337 const COUNT: usize = 14usize;
6338 #[inline]
6339 fn selector(&self) -> [u8; 4] {
6340 match self {
6341 Self::BalanceExceedsMaxTotalDeposits(_) => {
6342 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::SELECTOR
6343 }
6344 Self::CurrentlyPaused(_) => {
6345 <CurrentlyPaused as alloy_sol_types::SolError>::SELECTOR
6346 }
6347 Self::InputAddressZero(_) => {
6348 <InputAddressZero as alloy_sol_types::SolError>::SELECTOR
6349 }
6350 Self::InvalidNewPausedStatus(_) => {
6351 <InvalidNewPausedStatus as alloy_sol_types::SolError>::SELECTOR
6352 }
6353 Self::InvalidShortString(_) => {
6354 <InvalidShortString as alloy_sol_types::SolError>::SELECTOR
6355 }
6356 Self::MaxPerDepositExceedsMax(_) => {
6357 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::SELECTOR
6358 }
6359 Self::NewSharesZero(_) => {
6360 <NewSharesZero as alloy_sol_types::SolError>::SELECTOR
6361 }
6362 Self::OnlyPauser(_) => {
6363 <OnlyPauser as alloy_sol_types::SolError>::SELECTOR
6364 }
6365 Self::OnlyStrategyManager(_) => {
6366 <OnlyStrategyManager as alloy_sol_types::SolError>::SELECTOR
6367 }
6368 Self::OnlyUnderlyingToken(_) => {
6369 <OnlyUnderlyingToken as alloy_sol_types::SolError>::SELECTOR
6370 }
6371 Self::OnlyUnpauser(_) => {
6372 <OnlyUnpauser as alloy_sol_types::SolError>::SELECTOR
6373 }
6374 Self::StringTooLong(_) => {
6375 <StringTooLong as alloy_sol_types::SolError>::SELECTOR
6376 }
6377 Self::TotalSharesExceedsMax(_) => {
6378 <TotalSharesExceedsMax as alloy_sol_types::SolError>::SELECTOR
6379 }
6380 Self::WithdrawalAmountExceedsTotalDeposits(_) => {
6381 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::SELECTOR
6382 }
6383 }
6384 }
6385 #[inline]
6386 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
6387 Self::SELECTORS.get(i).copied()
6388 }
6389 #[inline]
6390 fn valid_selector(selector: [u8; 4]) -> bool {
6391 Self::SELECTORS.binary_search(&selector).is_ok()
6392 }
6393 #[inline]
6394 #[allow(non_snake_case)]
6395 fn abi_decode_raw(
6396 selector: [u8; 4],
6397 data: &[u8],
6398 ) -> alloy_sol_types::Result<Self> {
6399 static DECODE_SHIMS: &[fn(
6400 &[u8],
6401 ) -> alloy_sol_types::Result<StrategyBaseErrors>] = &[
6402 {
6403 fn MaxPerDepositExceedsMax(
6404 data: &[u8],
6405 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6406 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_decode_raw(
6407 data,
6408 )
6409 .map(StrategyBaseErrors::MaxPerDepositExceedsMax)
6410 }
6411 MaxPerDepositExceedsMax
6412 },
6413 {
6414 fn NewSharesZero(
6415 data: &[u8],
6416 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6417 <NewSharesZero as alloy_sol_types::SolError>::abi_decode_raw(
6418 data,
6419 )
6420 .map(StrategyBaseErrors::NewSharesZero)
6421 }
6422 NewSharesZero
6423 },
6424 {
6425 fn StringTooLong(
6426 data: &[u8],
6427 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6428 <StringTooLong as alloy_sol_types::SolError>::abi_decode_raw(
6429 data,
6430 )
6431 .map(StrategyBaseErrors::StringTooLong)
6432 }
6433 StringTooLong
6434 },
6435 {
6436 fn OnlyStrategyManager(
6437 data: &[u8],
6438 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6439 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_decode_raw(
6440 data,
6441 )
6442 .map(StrategyBaseErrors::OnlyStrategyManager)
6443 }
6444 OnlyStrategyManager
6445 },
6446 {
6447 fn TotalSharesExceedsMax(
6448 data: &[u8],
6449 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6450 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_decode_raw(
6451 data,
6452 )
6453 .map(StrategyBaseErrors::TotalSharesExceedsMax)
6454 }
6455 TotalSharesExceedsMax
6456 },
6457 {
6458 fn InputAddressZero(
6459 data: &[u8],
6460 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6461 <InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw(
6462 data,
6463 )
6464 .map(StrategyBaseErrors::InputAddressZero)
6465 }
6466 InputAddressZero
6467 },
6468 {
6469 fn OnlyPauser(
6470 data: &[u8],
6471 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6472 <OnlyPauser as alloy_sol_types::SolError>::abi_decode_raw(data)
6473 .map(StrategyBaseErrors::OnlyPauser)
6474 }
6475 OnlyPauser
6476 },
6477 {
6478 fn OnlyUnpauser(
6479 data: &[u8],
6480 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6481 <OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw(data)
6482 .map(StrategyBaseErrors::OnlyUnpauser)
6483 }
6484 OnlyUnpauser
6485 },
6486 {
6487 fn CurrentlyPaused(
6488 data: &[u8],
6489 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6490 <CurrentlyPaused as alloy_sol_types::SolError>::abi_decode_raw(
6491 data,
6492 )
6493 .map(StrategyBaseErrors::CurrentlyPaused)
6494 }
6495 CurrentlyPaused
6496 },
6497 {
6498 fn InvalidShortString(
6499 data: &[u8],
6500 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6501 <InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw(
6502 data,
6503 )
6504 .map(StrategyBaseErrors::InvalidShortString)
6505 }
6506 InvalidShortString
6507 },
6508 {
6509 fn WithdrawalAmountExceedsTotalDeposits(
6510 data: &[u8],
6511 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6512 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_decode_raw(
6513 data,
6514 )
6515 .map(
6516 StrategyBaseErrors::WithdrawalAmountExceedsTotalDeposits,
6517 )
6518 }
6519 WithdrawalAmountExceedsTotalDeposits
6520 },
6521 {
6522 fn OnlyUnderlyingToken(
6523 data: &[u8],
6524 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6525 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_decode_raw(
6526 data,
6527 )
6528 .map(StrategyBaseErrors::OnlyUnderlyingToken)
6529 }
6530 OnlyUnderlyingToken
6531 },
6532 {
6533 fn InvalidNewPausedStatus(
6534 data: &[u8],
6535 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6536 <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_decode_raw(
6537 data,
6538 )
6539 .map(StrategyBaseErrors::InvalidNewPausedStatus)
6540 }
6541 InvalidNewPausedStatus
6542 },
6543 {
6544 fn BalanceExceedsMaxTotalDeposits(
6545 data: &[u8],
6546 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6547 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_decode_raw(
6548 data,
6549 )
6550 .map(StrategyBaseErrors::BalanceExceedsMaxTotalDeposits)
6551 }
6552 BalanceExceedsMaxTotalDeposits
6553 },
6554 ];
6555 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
6556 return Err(
6557 alloy_sol_types::Error::unknown_selector(
6558 <Self as alloy_sol_types::SolInterface>::NAME,
6559 selector,
6560 ),
6561 );
6562 };
6563 DECODE_SHIMS[idx](data)
6564 }
6565 #[inline]
6566 #[allow(non_snake_case)]
6567 fn abi_decode_raw_validate(
6568 selector: [u8; 4],
6569 data: &[u8],
6570 ) -> alloy_sol_types::Result<Self> {
6571 static DECODE_VALIDATE_SHIMS: &[fn(
6572 &[u8],
6573 ) -> alloy_sol_types::Result<StrategyBaseErrors>] = &[
6574 {
6575 fn MaxPerDepositExceedsMax(
6576 data: &[u8],
6577 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6578 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_decode_raw_validate(
6579 data,
6580 )
6581 .map(StrategyBaseErrors::MaxPerDepositExceedsMax)
6582 }
6583 MaxPerDepositExceedsMax
6584 },
6585 {
6586 fn NewSharesZero(
6587 data: &[u8],
6588 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6589 <NewSharesZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
6590 data,
6591 )
6592 .map(StrategyBaseErrors::NewSharesZero)
6593 }
6594 NewSharesZero
6595 },
6596 {
6597 fn StringTooLong(
6598 data: &[u8],
6599 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6600 <StringTooLong as alloy_sol_types::SolError>::abi_decode_raw_validate(
6601 data,
6602 )
6603 .map(StrategyBaseErrors::StringTooLong)
6604 }
6605 StringTooLong
6606 },
6607 {
6608 fn OnlyStrategyManager(
6609 data: &[u8],
6610 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6611 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_decode_raw_validate(
6612 data,
6613 )
6614 .map(StrategyBaseErrors::OnlyStrategyManager)
6615 }
6616 OnlyStrategyManager
6617 },
6618 {
6619 fn TotalSharesExceedsMax(
6620 data: &[u8],
6621 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6622 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_decode_raw_validate(
6623 data,
6624 )
6625 .map(StrategyBaseErrors::TotalSharesExceedsMax)
6626 }
6627 TotalSharesExceedsMax
6628 },
6629 {
6630 fn InputAddressZero(
6631 data: &[u8],
6632 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6633 <InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
6634 data,
6635 )
6636 .map(StrategyBaseErrors::InputAddressZero)
6637 }
6638 InputAddressZero
6639 },
6640 {
6641 fn OnlyPauser(
6642 data: &[u8],
6643 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6644 <OnlyPauser as alloy_sol_types::SolError>::abi_decode_raw_validate(
6645 data,
6646 )
6647 .map(StrategyBaseErrors::OnlyPauser)
6648 }
6649 OnlyPauser
6650 },
6651 {
6652 fn OnlyUnpauser(
6653 data: &[u8],
6654 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6655 <OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw_validate(
6656 data,
6657 )
6658 .map(StrategyBaseErrors::OnlyUnpauser)
6659 }
6660 OnlyUnpauser
6661 },
6662 {
6663 fn CurrentlyPaused(
6664 data: &[u8],
6665 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6666 <CurrentlyPaused as alloy_sol_types::SolError>::abi_decode_raw_validate(
6667 data,
6668 )
6669 .map(StrategyBaseErrors::CurrentlyPaused)
6670 }
6671 CurrentlyPaused
6672 },
6673 {
6674 fn InvalidShortString(
6675 data: &[u8],
6676 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6677 <InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw_validate(
6678 data,
6679 )
6680 .map(StrategyBaseErrors::InvalidShortString)
6681 }
6682 InvalidShortString
6683 },
6684 {
6685 fn WithdrawalAmountExceedsTotalDeposits(
6686 data: &[u8],
6687 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6688 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_decode_raw_validate(
6689 data,
6690 )
6691 .map(
6692 StrategyBaseErrors::WithdrawalAmountExceedsTotalDeposits,
6693 )
6694 }
6695 WithdrawalAmountExceedsTotalDeposits
6696 },
6697 {
6698 fn OnlyUnderlyingToken(
6699 data: &[u8],
6700 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6701 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_decode_raw_validate(
6702 data,
6703 )
6704 .map(StrategyBaseErrors::OnlyUnderlyingToken)
6705 }
6706 OnlyUnderlyingToken
6707 },
6708 {
6709 fn InvalidNewPausedStatus(
6710 data: &[u8],
6711 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6712 <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_decode_raw_validate(
6713 data,
6714 )
6715 .map(StrategyBaseErrors::InvalidNewPausedStatus)
6716 }
6717 InvalidNewPausedStatus
6718 },
6719 {
6720 fn BalanceExceedsMaxTotalDeposits(
6721 data: &[u8],
6722 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
6723 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_decode_raw_validate(
6724 data,
6725 )
6726 .map(StrategyBaseErrors::BalanceExceedsMaxTotalDeposits)
6727 }
6728 BalanceExceedsMaxTotalDeposits
6729 },
6730 ];
6731 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
6732 return Err(
6733 alloy_sol_types::Error::unknown_selector(
6734 <Self as alloy_sol_types::SolInterface>::NAME,
6735 selector,
6736 ),
6737 );
6738 };
6739 DECODE_VALIDATE_SHIMS[idx](data)
6740 }
6741 #[inline]
6742 fn abi_encoded_size(&self) -> usize {
6743 match self {
6744 Self::BalanceExceedsMaxTotalDeposits(inner) => {
6745 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_encoded_size(
6746 inner,
6747 )
6748 }
6749 Self::CurrentlyPaused(inner) => {
6750 <CurrentlyPaused as alloy_sol_types::SolError>::abi_encoded_size(
6751 inner,
6752 )
6753 }
6754 Self::InputAddressZero(inner) => {
6755 <InputAddressZero as alloy_sol_types::SolError>::abi_encoded_size(
6756 inner,
6757 )
6758 }
6759 Self::InvalidNewPausedStatus(inner) => {
6760 <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encoded_size(
6761 inner,
6762 )
6763 }
6764 Self::InvalidShortString(inner) => {
6765 <InvalidShortString as alloy_sol_types::SolError>::abi_encoded_size(
6766 inner,
6767 )
6768 }
6769 Self::MaxPerDepositExceedsMax(inner) => {
6770 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_encoded_size(
6771 inner,
6772 )
6773 }
6774 Self::NewSharesZero(inner) => {
6775 <NewSharesZero as alloy_sol_types::SolError>::abi_encoded_size(inner)
6776 }
6777 Self::OnlyPauser(inner) => {
6778 <OnlyPauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
6779 }
6780 Self::OnlyStrategyManager(inner) => {
6781 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_encoded_size(
6782 inner,
6783 )
6784 }
6785 Self::OnlyUnderlyingToken(inner) => {
6786 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_encoded_size(
6787 inner,
6788 )
6789 }
6790 Self::OnlyUnpauser(inner) => {
6791 <OnlyUnpauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
6792 }
6793 Self::StringTooLong(inner) => {
6794 <StringTooLong as alloy_sol_types::SolError>::abi_encoded_size(inner)
6795 }
6796 Self::TotalSharesExceedsMax(inner) => {
6797 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_encoded_size(
6798 inner,
6799 )
6800 }
6801 Self::WithdrawalAmountExceedsTotalDeposits(inner) => {
6802 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_encoded_size(
6803 inner,
6804 )
6805 }
6806 }
6807 }
6808 #[inline]
6809 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
6810 match self {
6811 Self::BalanceExceedsMaxTotalDeposits(inner) => {
6812 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_encode_raw(
6813 inner,
6814 out,
6815 )
6816 }
6817 Self::CurrentlyPaused(inner) => {
6818 <CurrentlyPaused as alloy_sol_types::SolError>::abi_encode_raw(
6819 inner,
6820 out,
6821 )
6822 }
6823 Self::InputAddressZero(inner) => {
6824 <InputAddressZero as alloy_sol_types::SolError>::abi_encode_raw(
6825 inner,
6826 out,
6827 )
6828 }
6829 Self::InvalidNewPausedStatus(inner) => {
6830 <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encode_raw(
6831 inner,
6832 out,
6833 )
6834 }
6835 Self::InvalidShortString(inner) => {
6836 <InvalidShortString as alloy_sol_types::SolError>::abi_encode_raw(
6837 inner,
6838 out,
6839 )
6840 }
6841 Self::MaxPerDepositExceedsMax(inner) => {
6842 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_encode_raw(
6843 inner,
6844 out,
6845 )
6846 }
6847 Self::NewSharesZero(inner) => {
6848 <NewSharesZero as alloy_sol_types::SolError>::abi_encode_raw(
6849 inner,
6850 out,
6851 )
6852 }
6853 Self::OnlyPauser(inner) => {
6854 <OnlyPauser as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
6855 }
6856 Self::OnlyStrategyManager(inner) => {
6857 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_encode_raw(
6858 inner,
6859 out,
6860 )
6861 }
6862 Self::OnlyUnderlyingToken(inner) => {
6863 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_encode_raw(
6864 inner,
6865 out,
6866 )
6867 }
6868 Self::OnlyUnpauser(inner) => {
6869 <OnlyUnpauser as alloy_sol_types::SolError>::abi_encode_raw(
6870 inner,
6871 out,
6872 )
6873 }
6874 Self::StringTooLong(inner) => {
6875 <StringTooLong as alloy_sol_types::SolError>::abi_encode_raw(
6876 inner,
6877 out,
6878 )
6879 }
6880 Self::TotalSharesExceedsMax(inner) => {
6881 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_encode_raw(
6882 inner,
6883 out,
6884 )
6885 }
6886 Self::WithdrawalAmountExceedsTotalDeposits(inner) => {
6887 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_encode_raw(
6888 inner,
6889 out,
6890 )
6891 }
6892 }
6893 }
6894 }
6895 #[derive(serde::Serialize, serde::Deserialize)]
6897 #[derive(Debug, PartialEq, Eq, Hash)]
6898 pub enum StrategyBaseEvents {
6899 #[allow(missing_docs)]
6900 ExchangeRateEmitted(ExchangeRateEmitted),
6901 #[allow(missing_docs)]
6902 Initialized(Initialized),
6903 #[allow(missing_docs)]
6904 Paused(Paused),
6905 #[allow(missing_docs)]
6906 StrategyTokenSet(StrategyTokenSet),
6907 #[allow(missing_docs)]
6908 Unpaused(Unpaused),
6909 }
6910 #[automatically_derived]
6911 impl StrategyBaseEvents {
6912 pub const SELECTORS: &'static [[u8; 32usize]] = &[
6919 [
6920 28u8, 84u8, 7u8, 7u8, 176u8, 14u8, 181u8, 66u8, 123u8, 107u8, 119u8,
6921 79u8, 199u8, 153u8, 215u8, 86u8, 81u8, 106u8, 84u8, 174u8, 225u8, 8u8,
6922 182u8, 75u8, 50u8, 122u8, 204u8, 85u8, 175u8, 85u8, 117u8, 7u8,
6923 ],
6924 [
6925 53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8,
6926 2u8, 188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8,
6927 228u8, 152u8, 107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
6928 ],
6929 [
6930 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
6931 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
6932 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
6933 ],
6934 [
6935 171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8,
6936 188u8, 152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8,
6937 11u8, 182u8, 224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
6938 ],
6939 [
6940 210u8, 73u8, 79u8, 52u8, 121u8, 229u8, 218u8, 73u8, 211u8, 134u8, 101u8,
6941 124u8, 41u8, 44u8, 97u8, 11u8, 91u8, 1u8, 223u8, 49u8, 61u8, 7u8, 198u8,
6942 46u8, 176u8, 207u8, 164u8, 153u8, 36u8, 163u8, 27u8, 232u8,
6943 ],
6944 ];
6945 }
6946 #[automatically_derived]
6947 impl alloy_sol_types::SolEventInterface for StrategyBaseEvents {
6948 const NAME: &'static str = "StrategyBaseEvents";
6949 const COUNT: usize = 5usize;
6950 fn decode_raw_log(
6951 topics: &[alloy_sol_types::Word],
6952 data: &[u8],
6953 ) -> alloy_sol_types::Result<Self> {
6954 match topics.first().copied() {
6955 Some(
6956 <ExchangeRateEmitted as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
6957 ) => {
6958 <ExchangeRateEmitted as alloy_sol_types::SolEvent>::decode_raw_log(
6959 topics,
6960 data,
6961 )
6962 .map(Self::ExchangeRateEmitted)
6963 }
6964 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6965 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
6966 topics,
6967 data,
6968 )
6969 .map(Self::Initialized)
6970 }
6971 Some(<Paused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6972 <Paused as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
6973 .map(Self::Paused)
6974 }
6975 Some(<StrategyTokenSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6976 <StrategyTokenSet as alloy_sol_types::SolEvent>::decode_raw_log(
6977 topics,
6978 data,
6979 )
6980 .map(Self::StrategyTokenSet)
6981 }
6982 Some(<Unpaused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6983 <Unpaused as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
6984 .map(Self::Unpaused)
6985 }
6986 _ => {
6987 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
6988 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
6989 log: alloy_sol_types::private::Box::new(
6990 alloy_sol_types::private::LogData::new_unchecked(
6991 topics.to_vec(),
6992 data.to_vec().into(),
6993 ),
6994 ),
6995 })
6996 }
6997 }
6998 }
6999 }
7000 #[automatically_derived]
7001 impl alloy_sol_types::private::IntoLogData for StrategyBaseEvents {
7002 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
7003 match self {
7004 Self::ExchangeRateEmitted(inner) => {
7005 alloy_sol_types::private::IntoLogData::to_log_data(inner)
7006 }
7007 Self::Initialized(inner) => {
7008 alloy_sol_types::private::IntoLogData::to_log_data(inner)
7009 }
7010 Self::Paused(inner) => {
7011 alloy_sol_types::private::IntoLogData::to_log_data(inner)
7012 }
7013 Self::StrategyTokenSet(inner) => {
7014 alloy_sol_types::private::IntoLogData::to_log_data(inner)
7015 }
7016 Self::Unpaused(inner) => {
7017 alloy_sol_types::private::IntoLogData::to_log_data(inner)
7018 }
7019 }
7020 }
7021 fn into_log_data(self) -> alloy_sol_types::private::LogData {
7022 match self {
7023 Self::ExchangeRateEmitted(inner) => {
7024 alloy_sol_types::private::IntoLogData::into_log_data(inner)
7025 }
7026 Self::Initialized(inner) => {
7027 alloy_sol_types::private::IntoLogData::into_log_data(inner)
7028 }
7029 Self::Paused(inner) => {
7030 alloy_sol_types::private::IntoLogData::into_log_data(inner)
7031 }
7032 Self::StrategyTokenSet(inner) => {
7033 alloy_sol_types::private::IntoLogData::into_log_data(inner)
7034 }
7035 Self::Unpaused(inner) => {
7036 alloy_sol_types::private::IntoLogData::into_log_data(inner)
7037 }
7038 }
7039 }
7040 }
7041 use alloy::contract as alloy_contract;
7042 #[inline]
7046 pub const fn new<
7047 P: alloy_contract::private::Provider<N>,
7048 N: alloy_contract::private::Network,
7049 >(
7050 address: alloy_sol_types::private::Address,
7051 provider: P,
7052 ) -> StrategyBaseInstance<P, N> {
7053 StrategyBaseInstance::<P, N>::new(address, provider)
7054 }
7055 #[inline]
7061 pub fn deploy<
7062 P: alloy_contract::private::Provider<N>,
7063 N: alloy_contract::private::Network,
7064 >(
7065 provider: P,
7066 _strategyManager: alloy::sol_types::private::Address,
7067 _pauserRegistry: alloy::sol_types::private::Address,
7068 _version: alloy::sol_types::private::String,
7069 ) -> impl ::core::future::Future<
7070 Output = alloy_contract::Result<StrategyBaseInstance<P, N>>,
7071 > {
7072 StrategyBaseInstance::<
7073 P,
7074 N,
7075 >::deploy(provider, _strategyManager, _pauserRegistry, _version)
7076 }
7077 #[inline]
7083 pub fn deploy_builder<
7084 P: alloy_contract::private::Provider<N>,
7085 N: alloy_contract::private::Network,
7086 >(
7087 provider: P,
7088 _strategyManager: alloy::sol_types::private::Address,
7089 _pauserRegistry: alloy::sol_types::private::Address,
7090 _version: alloy::sol_types::private::String,
7091 ) -> alloy_contract::RawCallBuilder<P, N> {
7092 StrategyBaseInstance::<
7093 P,
7094 N,
7095 >::deploy_builder(provider, _strategyManager, _pauserRegistry, _version)
7096 }
7097 #[derive(Clone)]
7109 pub struct StrategyBaseInstance<P, N = alloy_contract::private::Ethereum> {
7110 address: alloy_sol_types::private::Address,
7111 provider: P,
7112 _network: ::core::marker::PhantomData<N>,
7113 }
7114 #[automatically_derived]
7115 impl<P, N> ::core::fmt::Debug for StrategyBaseInstance<P, N> {
7116 #[inline]
7117 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7118 f.debug_tuple("StrategyBaseInstance").field(&self.address).finish()
7119 }
7120 }
7121 #[automatically_derived]
7123 impl<
7124 P: alloy_contract::private::Provider<N>,
7125 N: alloy_contract::private::Network,
7126 > StrategyBaseInstance<P, N> {
7127 #[inline]
7131 pub const fn new(
7132 address: alloy_sol_types::private::Address,
7133 provider: P,
7134 ) -> Self {
7135 Self {
7136 address,
7137 provider,
7138 _network: ::core::marker::PhantomData,
7139 }
7140 }
7141 #[inline]
7147 pub async fn deploy(
7148 provider: P,
7149 _strategyManager: alloy::sol_types::private::Address,
7150 _pauserRegistry: alloy::sol_types::private::Address,
7151 _version: alloy::sol_types::private::String,
7152 ) -> alloy_contract::Result<StrategyBaseInstance<P, N>> {
7153 let call_builder = Self::deploy_builder(
7154 provider,
7155 _strategyManager,
7156 _pauserRegistry,
7157 _version,
7158 );
7159 let contract_address = call_builder.deploy().await?;
7160 Ok(Self::new(contract_address, call_builder.provider))
7161 }
7162 #[inline]
7168 pub fn deploy_builder(
7169 provider: P,
7170 _strategyManager: alloy::sol_types::private::Address,
7171 _pauserRegistry: alloy::sol_types::private::Address,
7172 _version: alloy::sol_types::private::String,
7173 ) -> alloy_contract::RawCallBuilder<P, N> {
7174 alloy_contract::RawCallBuilder::new_raw_deploy(
7175 provider,
7176 [
7177 &BYTECODE[..],
7178 &alloy_sol_types::SolConstructor::abi_encode(
7179 &constructorCall {
7180 _strategyManager,
7181 _pauserRegistry,
7182 _version,
7183 },
7184 )[..],
7185 ]
7186 .concat()
7187 .into(),
7188 )
7189 }
7190 #[inline]
7192 pub const fn address(&self) -> &alloy_sol_types::private::Address {
7193 &self.address
7194 }
7195 #[inline]
7197 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
7198 self.address = address;
7199 }
7200 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
7202 self.set_address(address);
7203 self
7204 }
7205 #[inline]
7207 pub const fn provider(&self) -> &P {
7208 &self.provider
7209 }
7210 }
7211 impl<P: ::core::clone::Clone, N> StrategyBaseInstance<&P, N> {
7212 #[inline]
7214 pub fn with_cloned_provider(self) -> StrategyBaseInstance<P, N> {
7215 StrategyBaseInstance {
7216 address: self.address,
7217 provider: ::core::clone::Clone::clone(&self.provider),
7218 _network: ::core::marker::PhantomData,
7219 }
7220 }
7221 }
7222 #[automatically_derived]
7224 impl<
7225 P: alloy_contract::private::Provider<N>,
7226 N: alloy_contract::private::Network,
7227 > StrategyBaseInstance<P, N> {
7228 pub fn call_builder<C: alloy_sol_types::SolCall>(
7233 &self,
7234 call: &C,
7235 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
7236 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
7237 }
7238 pub fn deposit(
7240 &self,
7241 token: alloy::sol_types::private::Address,
7242 amount: alloy::sol_types::private::primitives::aliases::U256,
7243 ) -> alloy_contract::SolCallBuilder<&P, depositCall, N> {
7244 self.call_builder(&depositCall { token, amount })
7245 }
7246 pub fn explanation(
7248 &self,
7249 ) -> alloy_contract::SolCallBuilder<&P, explanationCall, N> {
7250 self.call_builder(&explanationCall)
7251 }
7252 pub fn initialize(
7254 &self,
7255 _underlyingToken: alloy::sol_types::private::Address,
7256 ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
7257 self.call_builder(&initializeCall { _underlyingToken })
7258 }
7259 pub fn pause(
7261 &self,
7262 newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
7263 ) -> alloy_contract::SolCallBuilder<&P, pauseCall, N> {
7264 self.call_builder(&pauseCall { newPausedStatus })
7265 }
7266 pub fn pauseAll(&self) -> alloy_contract::SolCallBuilder<&P, pauseAllCall, N> {
7268 self.call_builder(&pauseAllCall)
7269 }
7270 pub fn paused_0(
7272 &self,
7273 index: u8,
7274 ) -> alloy_contract::SolCallBuilder<&P, paused_0Call, N> {
7275 self.call_builder(&paused_0Call { index })
7276 }
7277 pub fn paused_1(&self) -> alloy_contract::SolCallBuilder<&P, paused_1Call, N> {
7279 self.call_builder(&paused_1Call)
7280 }
7281 pub fn pauserRegistry(
7283 &self,
7284 ) -> alloy_contract::SolCallBuilder<&P, pauserRegistryCall, N> {
7285 self.call_builder(&pauserRegistryCall)
7286 }
7287 pub fn shares(
7289 &self,
7290 user: alloy::sol_types::private::Address,
7291 ) -> alloy_contract::SolCallBuilder<&P, sharesCall, N> {
7292 self.call_builder(&sharesCall { user })
7293 }
7294 pub fn sharesToUnderlying(
7296 &self,
7297 amountShares: alloy::sol_types::private::primitives::aliases::U256,
7298 ) -> alloy_contract::SolCallBuilder<&P, sharesToUnderlyingCall, N> {
7299 self.call_builder(
7300 &sharesToUnderlyingCall {
7301 amountShares,
7302 },
7303 )
7304 }
7305 pub fn sharesToUnderlyingView(
7307 &self,
7308 amountShares: alloy::sol_types::private::primitives::aliases::U256,
7309 ) -> alloy_contract::SolCallBuilder<&P, sharesToUnderlyingViewCall, N> {
7310 self.call_builder(
7311 &sharesToUnderlyingViewCall {
7312 amountShares,
7313 },
7314 )
7315 }
7316 pub fn strategyManager(
7318 &self,
7319 ) -> alloy_contract::SolCallBuilder<&P, strategyManagerCall, N> {
7320 self.call_builder(&strategyManagerCall)
7321 }
7322 pub fn totalShares(
7324 &self,
7325 ) -> alloy_contract::SolCallBuilder<&P, totalSharesCall, N> {
7326 self.call_builder(&totalSharesCall)
7327 }
7328 pub fn underlyingToShares(
7330 &self,
7331 amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
7332 ) -> alloy_contract::SolCallBuilder<&P, underlyingToSharesCall, N> {
7333 self.call_builder(
7334 &underlyingToSharesCall {
7335 amountUnderlying,
7336 },
7337 )
7338 }
7339 pub fn underlyingToSharesView(
7341 &self,
7342 amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
7343 ) -> alloy_contract::SolCallBuilder<&P, underlyingToSharesViewCall, N> {
7344 self.call_builder(
7345 &underlyingToSharesViewCall {
7346 amountUnderlying,
7347 },
7348 )
7349 }
7350 pub fn underlyingToken(
7352 &self,
7353 ) -> alloy_contract::SolCallBuilder<&P, underlyingTokenCall, N> {
7354 self.call_builder(&underlyingTokenCall)
7355 }
7356 pub fn unpause(
7358 &self,
7359 newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
7360 ) -> alloy_contract::SolCallBuilder<&P, unpauseCall, N> {
7361 self.call_builder(&unpauseCall { newPausedStatus })
7362 }
7363 pub fn userUnderlying(
7365 &self,
7366 user: alloy::sol_types::private::Address,
7367 ) -> alloy_contract::SolCallBuilder<&P, userUnderlyingCall, N> {
7368 self.call_builder(&userUnderlyingCall { user })
7369 }
7370 pub fn userUnderlyingView(
7372 &self,
7373 user: alloy::sol_types::private::Address,
7374 ) -> alloy_contract::SolCallBuilder<&P, userUnderlyingViewCall, N> {
7375 self.call_builder(&userUnderlyingViewCall { user })
7376 }
7377 pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
7379 self.call_builder(&versionCall)
7380 }
7381 pub fn withdraw(
7383 &self,
7384 recipient: alloy::sol_types::private::Address,
7385 token: alloy::sol_types::private::Address,
7386 amountShares: alloy::sol_types::private::primitives::aliases::U256,
7387 ) -> alloy_contract::SolCallBuilder<&P, withdrawCall, N> {
7388 self.call_builder(
7389 &withdrawCall {
7390 recipient,
7391 token,
7392 amountShares,
7393 },
7394 )
7395 }
7396 }
7397 #[automatically_derived]
7399 impl<
7400 P: alloy_contract::private::Provider<N>,
7401 N: alloy_contract::private::Network,
7402 > StrategyBaseInstance<P, N> {
7403 pub fn event_filter<E: alloy_sol_types::SolEvent>(
7408 &self,
7409 ) -> alloy_contract::Event<&P, E, N> {
7410 alloy_contract::Event::new_sol(&self.provider, &self.address)
7411 }
7412 pub fn ExchangeRateEmitted_filter(
7414 &self,
7415 ) -> alloy_contract::Event<&P, ExchangeRateEmitted, N> {
7416 self.event_filter::<ExchangeRateEmitted>()
7417 }
7418 pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
7420 self.event_filter::<Initialized>()
7421 }
7422 pub fn Paused_filter(&self) -> alloy_contract::Event<&P, Paused, N> {
7424 self.event_filter::<Paused>()
7425 }
7426 pub fn StrategyTokenSet_filter(
7428 &self,
7429 ) -> alloy_contract::Event<&P, StrategyTokenSet, N> {
7430 self.event_filter::<StrategyTokenSet>()
7431 }
7432 pub fn Unpaused_filter(&self) -> alloy_contract::Event<&P, Unpaused, N> {
7434 self.event_filter::<Unpaused>()
7435 }
7436 }
7437}