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\x1E8\x03\x80a\x16\x1E\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\xC5a\x03Y_9_\x81\x81a\x01y\x01R\x81\x81a\x04\x13\x01R\x81\x81a\x07\xDC\x01Ra\x08y\x01R_a\x053\x01R_\x81\x81a\x02D\x01R\x81\x81a\x03\x1D\x01R\x81\x81a\x05\x86\x01Ra\t\xA7\x01Ra\x12\xC5_\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\x94W\x80c\xCE|*\xC2\x14a\x02\xA7W\x80c\xD9\xCA\xED\x12\x14a\x02\xBAW\x80c\xE3\xDA\xE5\x1C\x14a\x02\xCDW\x80c\xF3\xE78u\x14a\x02\xE0W\x80c\xFA\xBC\x1C\xBC\x14a\x02\xF3W__\xFD[\x80cz\x8B&7\x14a\x02,W\x80c\x88o\x11\x95\x14a\x02?W\x80c\x8C\x87\x10\x19\x14a\x02fW\x80c\x8Fjb@\x14a\x02yW\x80c\xABY!\xE1\x14a\x02\x8CW__\xFD[\x80cT\xFDMP\x11a\0\xFAW\x80cT\xFDMP\x14a\x01\xC5W\x80cU<\xA5\xF8\x14a\x01\xDAW\x80cY\\jg\x14a\x01\xEDW\x80cZ\xC8j\xB7\x14a\x01\xF5W\x80c\\\x97Z\xBB\x14a\x02$W__\xFD[\x80c\x13d9\xDD\x14a\x016W\x80c$\x95\xA5\x99\x14a\x01KW\x80c9\xB7\x0E8\x14a\x01tW\x80c:\x98\xEF9\x14a\x01\x9BW\x80cG\xE7\xEF$\x14a\x01\xB2W[__\xFD[a\x01Ia\x01D6`\x04a\x10\x02V[a\x03\x06V[\0[`2Ta\x01^\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Qa\x01k\x91\x90a\x10\x19V[`@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\xA4`3T\x81V[`@Q\x90\x81R` \x01a\x01kV[a\x01\xA4a\x01\xC06`\x04a\x10DV[a\x03\xE0V[a\x01\xCDa\x05,V[`@Qa\x01k\x91\x90a\x10\x90V[a\x01\xA4a\x01\xE86`\x04a\x10\xC2V[a\x05\\V[a\x01Ia\x05oV[a\x02\x14a\x02\x036`\x04a\x10\xF2V[`\x01\x80T`\xFF\x90\x92\x16\x1B\x90\x81\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\x01kV[`\x01Ta\x01\xA4V[a\x01\xA4a\x02:6`\x04a\x10\x02V[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\xA4a\x02t6`\x04a\x10\x02V[a\x06lV[a\x01\xA4a\x02\x876`\x04a\x10\xC2V[a\x06vV[a\x01\xCDa\x06\x83V[a\x01Ia\x02\xA26`\x04a\x10\xC2V[a\x06\xA3V[a\x01\xA4a\x02\xB56`\x04a\x10\xC2V[a\x07\xB5V[a\x01Ia\x02\xC86`\x04a\x11\rV[a\x08GV[a\x01\xA4a\x02\xDB6`\x04a\x10\x02V[a\tdV[a\x01\xA4a\x02\xEE6`\x04a\x10\x02V[a\t\x9BV[a\x01Ia\x03\x016`\x04a\x10\x02V[a\t\xA5V[`@Qc#}\xFBG`\xE1\x1B\x81R`\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\x90cF\xFB\xF6\x8E\x90a\x03R\x903\x90`\x04\x01a\x10\x19V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03mW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x91\x91\x90a\x11KV[a\x03\xAEW`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x81\x81\x16\x81\x14a\x03\xD3W`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xDC\x82a\n\xBBV[PPV[`\x01\x80T_\x91\x82\x91\x81\x16\x03a\x04\x08W`@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\x04QW`@QcH\xDAqO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04[\x84\x84a\n\xF8V[`3T_a\x04ka\x03\xE8\x83a\x11~V[\x90P_a\x03\xE8a\x04ya\x0B&V[a\x04\x83\x91\x90a\x11~V[\x90P_a\x04\x90\x87\x83a\x11\x91V[\x90P\x80a\x04\x9D\x84\x89a\x11\xA4V[a\x04\xA7\x91\x90a\x11\xBBV[\x95P\x85_\x03a\x04\xC9W`@Qc\x0C9.\xD3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\xD3\x86\x85a\x11~V[`3\x81\x90UoK;L\xA8Z\x86\xC4z\t\x8A\"?\xFF\xFF\xFF\xFF\x10\x15a\x05\x08W`@Qc/\x14\xE8\xA3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05!\x82a\x03\xE8`3Ta\x05\x1C\x91\x90a\x11~V[a\x0B\x95V[PPPPP\x92\x91PPV[``a\x05W\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\xE1V[\x90P\x90V[_a\x05ia\x02:\x83a\x07\xB5V[\x92\x91PPV[`@Qc#}\xFBG`\xE1\x1B\x81R`\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\x90cF\xFB\xF6\x8E\x90a\x05\xBB\x903\x90`\x04\x01a\x10\x19V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xFA\x91\x90a\x11KV[a\x06\x17W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x06!_\x19a\n\xBBV[V[__a\x03\xE8`3Ta\x065\x91\x90a\x11~V[\x90P_a\x03\xE8a\x06Ca\x0B&V[a\x06M\x91\x90a\x11~V[\x90P\x81a\x06Z\x85\x83a\x11\xA4V[a\x06d\x91\x90a\x11\xBBV[\x94\x93PPPPV[_a\x05i\x82a\tdV[_a\x05ia\x02\xEE\x83a\x07\xB5V[```@Q\x80`\x80\x01`@R\x80`M\x81R` \x01a\x12C`M\x919\x90P\x90V[_Ta\x01\0\x90\x04`\xFF\x16\x15\x80\x80\x15a\x06\xC1WP_T`\x01`\xFF\x90\x91\x16\x10[\x80a\x06\xDAWP0;\x15\x80\x15a\x06\xDAWP_T`\xFF\x16`\x01\x14[a\x07BW`@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\x07cW_\x80Ta\xFF\0\x19\x16a\x01\0\x17\x90U[a\x07l\x82a\x0C\x1EV[\x80\x15a\x03\xDCW_\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\x05i\x91\x90a\x11\xDAV[`\x01\x80T`\x02\x90\x81\x16\x03a\x08nW`@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\xB7W`@QcH\xDAqO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08\xC2\x84\x84\x84a\riV[`3T\x80\x83\x11\x15a\x08\xE6W`@Qc\x0BF\x9D\xF3`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x08\xF3a\x03\xE8\x83a\x11~V[\x90P_a\x03\xE8a\t\x01a\x0B&V[a\t\x0B\x91\x90a\x11~V[\x90P_\x82a\t\x19\x87\x84a\x11\xA4V[a\t#\x91\x90a\x11\xBBV[\x90Pa\t/\x86\x85a\x11\x91V[`3Ua\tOa\t?\x82\x84a\x11\x91V[a\x03\xE8`3Ta\x05\x1C\x91\x90a\x11~V[a\tZ\x88\x88\x83a\r\x9CV[PPPPPPPPV[__a\x03\xE8`3Ta\tv\x91\x90a\x11~V[\x90P_a\x03\xE8a\t\x84a\x0B&V[a\t\x8E\x91\x90a\x11~V[\x90P\x80a\x06Z\x83\x86a\x11\xA4V[_a\x05i\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\n\x01W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n%\x91\x90a\x11\xF1V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\nVW`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x80\x19\x82\x19\x81\x16\x14a\n}W`@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\xDCW`@Qc\x03\x12\xAB\xDD`\xE6\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`2T`@Qcp\xA0\x821`\xE0\x1B\x81R_\x91`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90a\x0BV\x900\x90`\x04\x01a\x10\x19V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0BqW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05W\x91\x90a\x11\xDAV[\x7F\xD2IO4y\xE5\xDAI\xD3\x86e|),a\x0B[\x01\xDF1=\x07\xC6.\xB0\xCF\xA4\x99$\xA3\x1B\xE8\x81a\x0B\xC9\x84g\r\xE0\xB6\xB3\xA7d\0\0a\x11\xA4V[a\x0B\xD3\x91\x90a\x11\xBBV[`@Q\x90\x81R` \x01a\x07\xA9V[``_a\x0B\xED\x83a\r\xB0V[`@\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\x88W`@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\x079V[`2\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90Ua\x0C\xAC_a\n\xBBV[\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\x1EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\rB\x91\x90a\x12\x0CV[`@\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\x97W`@Qc\x03\x12\xAB\xDD`\xE6\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPV[a\r\x97`\x01`\x01`\xA0\x1B\x03\x83\x16\x84\x83a\r\xD7V[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x05iW`@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\x97\x92\x86\x92\x91_\x91a\x0Ef\x91\x85\x16\x90\x84\x90a\x0E\xE5V[\x90P\x80Q_\x14\x80a\x0E\x86WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0E\x86\x91\x90a\x11KV[a\r\x97W`@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\x079V[``a\x06d\x84\x84_\x85\x85__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x0F\n\x91\x90a\x12'V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0FDW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0FIV[``\x91P[P\x91P\x91Pa\x0FZ\x87\x83\x83\x87a\x0FeV[\x97\x96PPPPPPPV[``\x83\x15a\x0F\xD3W\x82Q_\x03a\x0F\xCCW`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x0F\xCCW`@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\x079V[P\x81a\x06dV[a\x06d\x83\x83\x81Q\x15a\x0F\xE8W\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x079\x91\x90a\x10\x90V[_` \x82\x84\x03\x12\x15a\x10\x12W__\xFD[P5\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x10AW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\x10UW__\xFD[\x825a\x10`\x81a\x10-V[\x94` \x93\x90\x93\x015\x93PPPV[_[\x83\x81\x10\x15a\x10\x88W\x81\x81\x01Q\x83\x82\x01R` \x01a\x10pV[PP_\x91\x01RV[` \x81R_\x82Q\x80` \x84\x01Ra\x10\xAE\x81`@\x85\x01` \x87\x01a\x10nV[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x10\xD2W__\xFD[\x815a\x10\xDD\x81a\x10-V[\x93\x92PPPV[`\xFF\x81\x16\x81\x14a\x10AW__\xFD[_` \x82\x84\x03\x12\x15a\x11\x02W__\xFD[\x815a\x10\xDD\x81a\x10\xE4V[___``\x84\x86\x03\x12\x15a\x11\x1FW__\xFD[\x835a\x11*\x81a\x10-V[\x92P` \x84\x015a\x11:\x81a\x10-V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x11[W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x10\xDDW__\xFD[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x05iWa\x05ia\x11jV[\x81\x81\x03\x81\x81\x11\x15a\x05iWa\x05ia\x11jV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x05iWa\x05ia\x11jV[_\x82a\x11\xD5WcNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[P\x04\x90V[_` \x82\x84\x03\x12\x15a\x11\xEAW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x12\x01W__\xFD[\x81Qa\x10\xDD\x81a\x10-V[_` \x82\x84\x03\x12\x15a\x12\x1CW__\xFD[\x81Qa\x10\xDD\x81a\x10\xE4V[_\x82Qa\x128\x81\x84` \x87\x01a\x10nV[\x91\x90\x91\x01\x92\x91PPV\xFEBase Strategy implementation to inherit from for more complex implementations\xA2dipfsX\"\x12 D\xDE\xE7\xB3\xDF5\xB9\x0F\xCB\xC9\xA6\xC7p\xD7r\xF5\x9C\x14\xD2&\xABP\x03s\x9F\0k\xDF\xF7\xAB\xD0BdsolcC\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\x94W\x80c\xCE|*\xC2\x14a\x02\xA7W\x80c\xD9\xCA\xED\x12\x14a\x02\xBAW\x80c\xE3\xDA\xE5\x1C\x14a\x02\xCDW\x80c\xF3\xE78u\x14a\x02\xE0W\x80c\xFA\xBC\x1C\xBC\x14a\x02\xF3W__\xFD[\x80cz\x8B&7\x14a\x02,W\x80c\x88o\x11\x95\x14a\x02?W\x80c\x8C\x87\x10\x19\x14a\x02fW\x80c\x8Fjb@\x14a\x02yW\x80c\xABY!\xE1\x14a\x02\x8CW__\xFD[\x80cT\xFDMP\x11a\0\xFAW\x80cT\xFDMP\x14a\x01\xC5W\x80cU<\xA5\xF8\x14a\x01\xDAW\x80cY\\jg\x14a\x01\xEDW\x80cZ\xC8j\xB7\x14a\x01\xF5W\x80c\\\x97Z\xBB\x14a\x02$W__\xFD[\x80c\x13d9\xDD\x14a\x016W\x80c$\x95\xA5\x99\x14a\x01KW\x80c9\xB7\x0E8\x14a\x01tW\x80c:\x98\xEF9\x14a\x01\x9BW\x80cG\xE7\xEF$\x14a\x01\xB2W[__\xFD[a\x01Ia\x01D6`\x04a\x10\x02V[a\x03\x06V[\0[`2Ta\x01^\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Qa\x01k\x91\x90a\x10\x19V[`@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\xA4`3T\x81V[`@Q\x90\x81R` \x01a\x01kV[a\x01\xA4a\x01\xC06`\x04a\x10DV[a\x03\xE0V[a\x01\xCDa\x05,V[`@Qa\x01k\x91\x90a\x10\x90V[a\x01\xA4a\x01\xE86`\x04a\x10\xC2V[a\x05\\V[a\x01Ia\x05oV[a\x02\x14a\x02\x036`\x04a\x10\xF2V[`\x01\x80T`\xFF\x90\x92\x16\x1B\x90\x81\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\x01kV[`\x01Ta\x01\xA4V[a\x01\xA4a\x02:6`\x04a\x10\x02V[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\xA4a\x02t6`\x04a\x10\x02V[a\x06lV[a\x01\xA4a\x02\x876`\x04a\x10\xC2V[a\x06vV[a\x01\xCDa\x06\x83V[a\x01Ia\x02\xA26`\x04a\x10\xC2V[a\x06\xA3V[a\x01\xA4a\x02\xB56`\x04a\x10\xC2V[a\x07\xB5V[a\x01Ia\x02\xC86`\x04a\x11\rV[a\x08GV[a\x01\xA4a\x02\xDB6`\x04a\x10\x02V[a\tdV[a\x01\xA4a\x02\xEE6`\x04a\x10\x02V[a\t\x9BV[a\x01Ia\x03\x016`\x04a\x10\x02V[a\t\xA5V[`@Qc#}\xFBG`\xE1\x1B\x81R`\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\x90cF\xFB\xF6\x8E\x90a\x03R\x903\x90`\x04\x01a\x10\x19V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03mW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x91\x91\x90a\x11KV[a\x03\xAEW`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x81\x81\x16\x81\x14a\x03\xD3W`@Qc\xC6\x1D\xCA]`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xDC\x82a\n\xBBV[PPV[`\x01\x80T_\x91\x82\x91\x81\x16\x03a\x04\x08W`@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\x04QW`@QcH\xDAqO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04[\x84\x84a\n\xF8V[`3T_a\x04ka\x03\xE8\x83a\x11~V[\x90P_a\x03\xE8a\x04ya\x0B&V[a\x04\x83\x91\x90a\x11~V[\x90P_a\x04\x90\x87\x83a\x11\x91V[\x90P\x80a\x04\x9D\x84\x89a\x11\xA4V[a\x04\xA7\x91\x90a\x11\xBBV[\x95P\x85_\x03a\x04\xC9W`@Qc\x0C9.\xD3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\xD3\x86\x85a\x11~V[`3\x81\x90UoK;L\xA8Z\x86\xC4z\t\x8A\"?\xFF\xFF\xFF\xFF\x10\x15a\x05\x08W`@Qc/\x14\xE8\xA3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05!\x82a\x03\xE8`3Ta\x05\x1C\x91\x90a\x11~V[a\x0B\x95V[PPPPP\x92\x91PPV[``a\x05W\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\xE1V[\x90P\x90V[_a\x05ia\x02:\x83a\x07\xB5V[\x92\x91PPV[`@Qc#}\xFBG`\xE1\x1B\x81R`\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\x90cF\xFB\xF6\x8E\x90a\x05\xBB\x903\x90`\x04\x01a\x10\x19V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xFA\x91\x90a\x11KV[a\x06\x17W`@Qc\x1Dw\xD4w`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x06!_\x19a\n\xBBV[V[__a\x03\xE8`3Ta\x065\x91\x90a\x11~V[\x90P_a\x03\xE8a\x06Ca\x0B&V[a\x06M\x91\x90a\x11~V[\x90P\x81a\x06Z\x85\x83a\x11\xA4V[a\x06d\x91\x90a\x11\xBBV[\x94\x93PPPPV[_a\x05i\x82a\tdV[_a\x05ia\x02\xEE\x83a\x07\xB5V[```@Q\x80`\x80\x01`@R\x80`M\x81R` \x01a\x12C`M\x919\x90P\x90V[_Ta\x01\0\x90\x04`\xFF\x16\x15\x80\x80\x15a\x06\xC1WP_T`\x01`\xFF\x90\x91\x16\x10[\x80a\x06\xDAWP0;\x15\x80\x15a\x06\xDAWP_T`\xFF\x16`\x01\x14[a\x07BW`@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\x07cW_\x80Ta\xFF\0\x19\x16a\x01\0\x17\x90U[a\x07l\x82a\x0C\x1EV[\x80\x15a\x03\xDCW_\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\x05i\x91\x90a\x11\xDAV[`\x01\x80T`\x02\x90\x81\x16\x03a\x08nW`@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\xB7W`@QcH\xDAqO`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08\xC2\x84\x84\x84a\riV[`3T\x80\x83\x11\x15a\x08\xE6W`@Qc\x0BF\x9D\xF3`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x08\xF3a\x03\xE8\x83a\x11~V[\x90P_a\x03\xE8a\t\x01a\x0B&V[a\t\x0B\x91\x90a\x11~V[\x90P_\x82a\t\x19\x87\x84a\x11\xA4V[a\t#\x91\x90a\x11\xBBV[\x90Pa\t/\x86\x85a\x11\x91V[`3Ua\tOa\t?\x82\x84a\x11\x91V[a\x03\xE8`3Ta\x05\x1C\x91\x90a\x11~V[a\tZ\x88\x88\x83a\r\x9CV[PPPPPPPPV[__a\x03\xE8`3Ta\tv\x91\x90a\x11~V[\x90P_a\x03\xE8a\t\x84a\x0B&V[a\t\x8E\x91\x90a\x11~V[\x90P\x80a\x06Z\x83\x86a\x11\xA4V[_a\x05i\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\n\x01W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n%\x91\x90a\x11\xF1V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\nVW`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x80\x19\x82\x19\x81\x16\x14a\n}W`@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\xDCW`@Qc\x03\x12\xAB\xDD`\xE6\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`2T`@Qcp\xA0\x821`\xE0\x1B\x81R_\x91`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90a\x0BV\x900\x90`\x04\x01a\x10\x19V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0BqW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05W\x91\x90a\x11\xDAV[\x7F\xD2IO4y\xE5\xDAI\xD3\x86e|),a\x0B[\x01\xDF1=\x07\xC6.\xB0\xCF\xA4\x99$\xA3\x1B\xE8\x81a\x0B\xC9\x84g\r\xE0\xB6\xB3\xA7d\0\0a\x11\xA4V[a\x0B\xD3\x91\x90a\x11\xBBV[`@Q\x90\x81R` \x01a\x07\xA9V[``_a\x0B\xED\x83a\r\xB0V[`@\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\x88W`@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\x079V[`2\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90Ua\x0C\xAC_a\n\xBBV[\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\x1EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\rB\x91\x90a\x12\x0CV[`@\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\x97W`@Qc\x03\x12\xAB\xDD`\xE6\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPV[a\r\x97`\x01`\x01`\xA0\x1B\x03\x83\x16\x84\x83a\r\xD7V[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x05iW`@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\x97\x92\x86\x92\x91_\x91a\x0Ef\x91\x85\x16\x90\x84\x90a\x0E\xE5V[\x90P\x80Q_\x14\x80a\x0E\x86WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0E\x86\x91\x90a\x11KV[a\r\x97W`@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\x079V[``a\x06d\x84\x84_\x85\x85__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x0F\n\x91\x90a\x12'V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0FDW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0FIV[``\x91P[P\x91P\x91Pa\x0FZ\x87\x83\x83\x87a\x0FeV[\x97\x96PPPPPPPV[``\x83\x15a\x0F\xD3W\x82Q_\x03a\x0F\xCCW`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x0F\xCCW`@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\x079V[P\x81a\x06dV[a\x06d\x83\x83\x81Q\x15a\x0F\xE8W\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x079\x91\x90a\x10\x90V[_` \x82\x84\x03\x12\x15a\x10\x12W__\xFD[P5\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x10AW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\x10UW__\xFD[\x825a\x10`\x81a\x10-V[\x94` \x93\x90\x93\x015\x93PPPV[_[\x83\x81\x10\x15a\x10\x88W\x81\x81\x01Q\x83\x82\x01R` \x01a\x10pV[PP_\x91\x01RV[` \x81R_\x82Q\x80` \x84\x01Ra\x10\xAE\x81`@\x85\x01` \x87\x01a\x10nV[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x10\xD2W__\xFD[\x815a\x10\xDD\x81a\x10-V[\x93\x92PPPV[`\xFF\x81\x16\x81\x14a\x10AW__\xFD[_` \x82\x84\x03\x12\x15a\x11\x02W__\xFD[\x815a\x10\xDD\x81a\x10\xE4V[___``\x84\x86\x03\x12\x15a\x11\x1FW__\xFD[\x835a\x11*\x81a\x10-V[\x92P` \x84\x015a\x11:\x81a\x10-V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x11[W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x10\xDDW__\xFD[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x05iWa\x05ia\x11jV[\x81\x81\x03\x81\x81\x11\x15a\x05iWa\x05ia\x11jV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x05iWa\x05ia\x11jV[_\x82a\x11\xD5WcNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[P\x04\x90V[_` \x82\x84\x03\x12\x15a\x11\xEAW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x12\x01W__\xFD[\x81Qa\x10\xDD\x81a\x10-V[_` \x82\x84\x03\x12\x15a\x12\x1CW__\xFD[\x81Qa\x10\xDD\x81a\x10\xE4V[_\x82Qa\x128\x81\x84` \x87\x01a\x10nV[\x91\x90\x91\x01\x92\x91PPV\xFEBase Strategy implementation to inherit from for more complex implementations\xA2dipfsX\"\x12 D\xDE\xE7\xB3\xDF5\xB9\x0F\xCB\xC9\xA6\xC7p\xD7r\xF5\x9C\x14\xD2&\xABP\x03s\x9F\0k\xDF\xF7\xAB\xD0BdsolcC\0\x08\x1B\x003",
606 );
607 #[derive(Default, Debug, PartialEq, Eq, Hash)]
608 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
613 #[derive(Clone)]
614 pub struct BalanceExceedsMaxTotalDeposits {}
615 #[allow(
616 non_camel_case_types,
617 non_snake_case,
618 clippy::pub_underscore_fields,
619 clippy::style
620 )]
621 const _: () = {
622 use alloy::sol_types as alloy_sol_types;
623 #[doc(hidden)]
624 type UnderlyingSolTuple<'a> = ();
625 #[doc(hidden)]
626 type UnderlyingRustTuple<'a> = ();
627 #[cfg(test)]
628 #[allow(dead_code, unreachable_patterns)]
629 fn _type_assertion(
630 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
631 ) {
632 match _t {
633 alloy_sol_types::private::AssertTypeEq::<
634 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
635 >(_) => {}
636 }
637 }
638 #[automatically_derived]
639 #[doc(hidden)]
640 impl ::core::convert::From<BalanceExceedsMaxTotalDeposits>
641 for UnderlyingRustTuple<'_> {
642 fn from(value: BalanceExceedsMaxTotalDeposits) -> Self {
643 ()
644 }
645 }
646 #[automatically_derived]
647 #[doc(hidden)]
648 impl ::core::convert::From<UnderlyingRustTuple<'_>>
649 for BalanceExceedsMaxTotalDeposits {
650 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
651 Self {}
652 }
653 }
654 #[automatically_derived]
655 impl alloy_sol_types::SolError for BalanceExceedsMaxTotalDeposits {
656 type Parameters<'a> = UnderlyingSolTuple<'a>;
657 type Token<'a> = <Self::Parameters<
658 'a,
659 > as alloy_sol_types::SolType>::Token<'a>;
660 const SIGNATURE: &'static str = "BalanceExceedsMaxTotalDeposits()";
661 const SELECTOR: [u8; 4] = [216u8, 107u8, 174u8, 103u8];
662 #[inline]
663 fn new<'a>(
664 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
665 ) -> Self {
666 tuple.into()
667 }
668 #[inline]
669 fn tokenize(&self) -> Self::Token<'_> {
670 ()
671 }
672 }
673 };
674 #[derive(Default, Debug, PartialEq, Eq, Hash)]
675 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
680 #[derive(Clone)]
681 pub struct CurrentlyPaused {}
682 #[allow(
683 non_camel_case_types,
684 non_snake_case,
685 clippy::pub_underscore_fields,
686 clippy::style
687 )]
688 const _: () = {
689 use alloy::sol_types as alloy_sol_types;
690 #[doc(hidden)]
691 type UnderlyingSolTuple<'a> = ();
692 #[doc(hidden)]
693 type UnderlyingRustTuple<'a> = ();
694 #[cfg(test)]
695 #[allow(dead_code, unreachable_patterns)]
696 fn _type_assertion(
697 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
698 ) {
699 match _t {
700 alloy_sol_types::private::AssertTypeEq::<
701 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
702 >(_) => {}
703 }
704 }
705 #[automatically_derived]
706 #[doc(hidden)]
707 impl ::core::convert::From<CurrentlyPaused> for UnderlyingRustTuple<'_> {
708 fn from(value: CurrentlyPaused) -> Self {
709 ()
710 }
711 }
712 #[automatically_derived]
713 #[doc(hidden)]
714 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CurrentlyPaused {
715 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
716 Self {}
717 }
718 }
719 #[automatically_derived]
720 impl alloy_sol_types::SolError for CurrentlyPaused {
721 type Parameters<'a> = UnderlyingSolTuple<'a>;
722 type Token<'a> = <Self::Parameters<
723 'a,
724 > as alloy_sol_types::SolType>::Token<'a>;
725 const SIGNATURE: &'static str = "CurrentlyPaused()";
726 const SELECTOR: [u8; 4] = [132u8, 10u8, 72u8, 213u8];
727 #[inline]
728 fn new<'a>(
729 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
730 ) -> Self {
731 tuple.into()
732 }
733 #[inline]
734 fn tokenize(&self) -> Self::Token<'_> {
735 ()
736 }
737 }
738 };
739 #[derive(Default, Debug, PartialEq, Eq, Hash)]
740 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
745 #[derive(Clone)]
746 pub struct InputAddressZero {}
747 #[allow(
748 non_camel_case_types,
749 non_snake_case,
750 clippy::pub_underscore_fields,
751 clippy::style
752 )]
753 const _: () = {
754 use alloy::sol_types as alloy_sol_types;
755 #[doc(hidden)]
756 type UnderlyingSolTuple<'a> = ();
757 #[doc(hidden)]
758 type UnderlyingRustTuple<'a> = ();
759 #[cfg(test)]
760 #[allow(dead_code, unreachable_patterns)]
761 fn _type_assertion(
762 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
763 ) {
764 match _t {
765 alloy_sol_types::private::AssertTypeEq::<
766 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
767 >(_) => {}
768 }
769 }
770 #[automatically_derived]
771 #[doc(hidden)]
772 impl ::core::convert::From<InputAddressZero> for UnderlyingRustTuple<'_> {
773 fn from(value: InputAddressZero) -> Self {
774 ()
775 }
776 }
777 #[automatically_derived]
778 #[doc(hidden)]
779 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputAddressZero {
780 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
781 Self {}
782 }
783 }
784 #[automatically_derived]
785 impl alloy_sol_types::SolError for InputAddressZero {
786 type Parameters<'a> = UnderlyingSolTuple<'a>;
787 type Token<'a> = <Self::Parameters<
788 'a,
789 > as alloy_sol_types::SolType>::Token<'a>;
790 const SIGNATURE: &'static str = "InputAddressZero()";
791 const SELECTOR: [u8; 4] = [115u8, 99u8, 33u8, 118u8];
792 #[inline]
793 fn new<'a>(
794 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
795 ) -> Self {
796 tuple.into()
797 }
798 #[inline]
799 fn tokenize(&self) -> Self::Token<'_> {
800 ()
801 }
802 }
803 };
804 #[derive(Default, Debug, PartialEq, Eq, Hash)]
805 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
810 #[derive(Clone)]
811 pub struct InvalidNewPausedStatus {}
812 #[allow(
813 non_camel_case_types,
814 non_snake_case,
815 clippy::pub_underscore_fields,
816 clippy::style
817 )]
818 const _: () = {
819 use alloy::sol_types as alloy_sol_types;
820 #[doc(hidden)]
821 type UnderlyingSolTuple<'a> = ();
822 #[doc(hidden)]
823 type UnderlyingRustTuple<'a> = ();
824 #[cfg(test)]
825 #[allow(dead_code, unreachable_patterns)]
826 fn _type_assertion(
827 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
828 ) {
829 match _t {
830 alloy_sol_types::private::AssertTypeEq::<
831 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
832 >(_) => {}
833 }
834 }
835 #[automatically_derived]
836 #[doc(hidden)]
837 impl ::core::convert::From<InvalidNewPausedStatus> for UnderlyingRustTuple<'_> {
838 fn from(value: InvalidNewPausedStatus) -> Self {
839 ()
840 }
841 }
842 #[automatically_derived]
843 #[doc(hidden)]
844 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidNewPausedStatus {
845 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
846 Self {}
847 }
848 }
849 #[automatically_derived]
850 impl alloy_sol_types::SolError for InvalidNewPausedStatus {
851 type Parameters<'a> = UnderlyingSolTuple<'a>;
852 type Token<'a> = <Self::Parameters<
853 'a,
854 > as alloy_sol_types::SolType>::Token<'a>;
855 const SIGNATURE: &'static str = "InvalidNewPausedStatus()";
856 const SELECTOR: [u8; 4] = [198u8, 29u8, 202u8, 93u8];
857 #[inline]
858 fn new<'a>(
859 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
860 ) -> Self {
861 tuple.into()
862 }
863 #[inline]
864 fn tokenize(&self) -> Self::Token<'_> {
865 ()
866 }
867 }
868 };
869 #[derive(Default, Debug, PartialEq, Eq, Hash)]
870 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
875 #[derive(Clone)]
876 pub struct InvalidShortString {}
877 #[allow(
878 non_camel_case_types,
879 non_snake_case,
880 clippy::pub_underscore_fields,
881 clippy::style
882 )]
883 const _: () = {
884 use alloy::sol_types as alloy_sol_types;
885 #[doc(hidden)]
886 type UnderlyingSolTuple<'a> = ();
887 #[doc(hidden)]
888 type UnderlyingRustTuple<'a> = ();
889 #[cfg(test)]
890 #[allow(dead_code, unreachable_patterns)]
891 fn _type_assertion(
892 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
893 ) {
894 match _t {
895 alloy_sol_types::private::AssertTypeEq::<
896 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
897 >(_) => {}
898 }
899 }
900 #[automatically_derived]
901 #[doc(hidden)]
902 impl ::core::convert::From<InvalidShortString> for UnderlyingRustTuple<'_> {
903 fn from(value: InvalidShortString) -> Self {
904 ()
905 }
906 }
907 #[automatically_derived]
908 #[doc(hidden)]
909 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidShortString {
910 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
911 Self {}
912 }
913 }
914 #[automatically_derived]
915 impl alloy_sol_types::SolError for InvalidShortString {
916 type Parameters<'a> = UnderlyingSolTuple<'a>;
917 type Token<'a> = <Self::Parameters<
918 'a,
919 > as alloy_sol_types::SolType>::Token<'a>;
920 const SIGNATURE: &'static str = "InvalidShortString()";
921 const SELECTOR: [u8; 4] = [179u8, 81u8, 43u8, 12u8];
922 #[inline]
923 fn new<'a>(
924 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
925 ) -> Self {
926 tuple.into()
927 }
928 #[inline]
929 fn tokenize(&self) -> Self::Token<'_> {
930 ()
931 }
932 }
933 };
934 #[derive(Default, Debug, PartialEq, Eq, Hash)]
935 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
940 #[derive(Clone)]
941 pub struct MaxPerDepositExceedsMax {}
942 #[allow(
943 non_camel_case_types,
944 non_snake_case,
945 clippy::pub_underscore_fields,
946 clippy::style
947 )]
948 const _: () = {
949 use alloy::sol_types as alloy_sol_types;
950 #[doc(hidden)]
951 type UnderlyingSolTuple<'a> = ();
952 #[doc(hidden)]
953 type UnderlyingRustTuple<'a> = ();
954 #[cfg(test)]
955 #[allow(dead_code, unreachable_patterns)]
956 fn _type_assertion(
957 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
958 ) {
959 match _t {
960 alloy_sol_types::private::AssertTypeEq::<
961 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
962 >(_) => {}
963 }
964 }
965 #[automatically_derived]
966 #[doc(hidden)]
967 impl ::core::convert::From<MaxPerDepositExceedsMax> for UnderlyingRustTuple<'_> {
968 fn from(value: MaxPerDepositExceedsMax) -> Self {
969 ()
970 }
971 }
972 #[automatically_derived]
973 #[doc(hidden)]
974 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MaxPerDepositExceedsMax {
975 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
976 Self {}
977 }
978 }
979 #[automatically_derived]
980 impl alloy_sol_types::SolError for MaxPerDepositExceedsMax {
981 type Parameters<'a> = UnderlyingSolTuple<'a>;
982 type Token<'a> = <Self::Parameters<
983 'a,
984 > as alloy_sol_types::SolType>::Token<'a>;
985 const SIGNATURE: &'static str = "MaxPerDepositExceedsMax()";
986 const SELECTOR: [u8; 4] = [20u8, 172u8, 30u8, 220u8];
987 #[inline]
988 fn new<'a>(
989 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
990 ) -> Self {
991 tuple.into()
992 }
993 #[inline]
994 fn tokenize(&self) -> Self::Token<'_> {
995 ()
996 }
997 }
998 };
999 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1000 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1005 #[derive(Clone)]
1006 pub struct NewSharesZero {}
1007 #[allow(
1008 non_camel_case_types,
1009 non_snake_case,
1010 clippy::pub_underscore_fields,
1011 clippy::style
1012 )]
1013 const _: () = {
1014 use alloy::sol_types as alloy_sol_types;
1015 #[doc(hidden)]
1016 type UnderlyingSolTuple<'a> = ();
1017 #[doc(hidden)]
1018 type UnderlyingRustTuple<'a> = ();
1019 #[cfg(test)]
1020 #[allow(dead_code, unreachable_patterns)]
1021 fn _type_assertion(
1022 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1023 ) {
1024 match _t {
1025 alloy_sol_types::private::AssertTypeEq::<
1026 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1027 >(_) => {}
1028 }
1029 }
1030 #[automatically_derived]
1031 #[doc(hidden)]
1032 impl ::core::convert::From<NewSharesZero> for UnderlyingRustTuple<'_> {
1033 fn from(value: NewSharesZero) -> Self {
1034 ()
1035 }
1036 }
1037 #[automatically_derived]
1038 #[doc(hidden)]
1039 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NewSharesZero {
1040 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1041 Self {}
1042 }
1043 }
1044 #[automatically_derived]
1045 impl alloy_sol_types::SolError for NewSharesZero {
1046 type Parameters<'a> = UnderlyingSolTuple<'a>;
1047 type Token<'a> = <Self::Parameters<
1048 'a,
1049 > as alloy_sol_types::SolType>::Token<'a>;
1050 const SIGNATURE: &'static str = "NewSharesZero()";
1051 const SELECTOR: [u8; 4] = [24u8, 114u8, 93u8, 166u8];
1052 #[inline]
1053 fn new<'a>(
1054 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1055 ) -> Self {
1056 tuple.into()
1057 }
1058 #[inline]
1059 fn tokenize(&self) -> Self::Token<'_> {
1060 ()
1061 }
1062 }
1063 };
1064 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1065 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1070 #[derive(Clone)]
1071 pub struct OnlyPauser {}
1072 #[allow(
1073 non_camel_case_types,
1074 non_snake_case,
1075 clippy::pub_underscore_fields,
1076 clippy::style
1077 )]
1078 const _: () = {
1079 use alloy::sol_types as alloy_sol_types;
1080 #[doc(hidden)]
1081 type UnderlyingSolTuple<'a> = ();
1082 #[doc(hidden)]
1083 type UnderlyingRustTuple<'a> = ();
1084 #[cfg(test)]
1085 #[allow(dead_code, unreachable_patterns)]
1086 fn _type_assertion(
1087 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1088 ) {
1089 match _t {
1090 alloy_sol_types::private::AssertTypeEq::<
1091 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1092 >(_) => {}
1093 }
1094 }
1095 #[automatically_derived]
1096 #[doc(hidden)]
1097 impl ::core::convert::From<OnlyPauser> for UnderlyingRustTuple<'_> {
1098 fn from(value: OnlyPauser) -> Self {
1099 ()
1100 }
1101 }
1102 #[automatically_derived]
1103 #[doc(hidden)]
1104 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyPauser {
1105 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1106 Self {}
1107 }
1108 }
1109 #[automatically_derived]
1110 impl alloy_sol_types::SolError for OnlyPauser {
1111 type Parameters<'a> = UnderlyingSolTuple<'a>;
1112 type Token<'a> = <Self::Parameters<
1113 'a,
1114 > as alloy_sol_types::SolType>::Token<'a>;
1115 const SIGNATURE: &'static str = "OnlyPauser()";
1116 const SELECTOR: [u8; 4] = [117u8, 223u8, 81u8, 220u8];
1117 #[inline]
1118 fn new<'a>(
1119 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1120 ) -> Self {
1121 tuple.into()
1122 }
1123 #[inline]
1124 fn tokenize(&self) -> Self::Token<'_> {
1125 ()
1126 }
1127 }
1128 };
1129 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1130 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1135 #[derive(Clone)]
1136 pub struct OnlyStrategyManager {}
1137 #[allow(
1138 non_camel_case_types,
1139 non_snake_case,
1140 clippy::pub_underscore_fields,
1141 clippy::style
1142 )]
1143 const _: () = {
1144 use alloy::sol_types as alloy_sol_types;
1145 #[doc(hidden)]
1146 type UnderlyingSolTuple<'a> = ();
1147 #[doc(hidden)]
1148 type UnderlyingRustTuple<'a> = ();
1149 #[cfg(test)]
1150 #[allow(dead_code, unreachable_patterns)]
1151 fn _type_assertion(
1152 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1153 ) {
1154 match _t {
1155 alloy_sol_types::private::AssertTypeEq::<
1156 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1157 >(_) => {}
1158 }
1159 }
1160 #[automatically_derived]
1161 #[doc(hidden)]
1162 impl ::core::convert::From<OnlyStrategyManager> for UnderlyingRustTuple<'_> {
1163 fn from(value: OnlyStrategyManager) -> Self {
1164 ()
1165 }
1166 }
1167 #[automatically_derived]
1168 #[doc(hidden)]
1169 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyStrategyManager {
1170 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1171 Self {}
1172 }
1173 }
1174 #[automatically_derived]
1175 impl alloy_sol_types::SolError for OnlyStrategyManager {
1176 type Parameters<'a> = UnderlyingSolTuple<'a>;
1177 type Token<'a> = <Self::Parameters<
1178 'a,
1179 > as alloy_sol_types::SolType>::Token<'a>;
1180 const SIGNATURE: &'static str = "OnlyStrategyManager()";
1181 const SELECTOR: [u8; 4] = [72u8, 218u8, 113u8, 79u8];
1182 #[inline]
1183 fn new<'a>(
1184 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1185 ) -> Self {
1186 tuple.into()
1187 }
1188 #[inline]
1189 fn tokenize(&self) -> Self::Token<'_> {
1190 ()
1191 }
1192 }
1193 };
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 OnlyUnderlyingToken {}
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<OnlyUnderlyingToken> for UnderlyingRustTuple<'_> {
1228 fn from(value: OnlyUnderlyingToken) -> Self {
1229 ()
1230 }
1231 }
1232 #[automatically_derived]
1233 #[doc(hidden)]
1234 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnderlyingToken {
1235 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1236 Self {}
1237 }
1238 }
1239 #[automatically_derived]
1240 impl alloy_sol_types::SolError for OnlyUnderlyingToken {
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 = "OnlyUnderlyingToken()";
1246 const SELECTOR: [u8; 4] = [196u8, 170u8, 247u8, 64u8];
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 }
1258 };
1259 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1260 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1265 #[derive(Clone)]
1266 pub struct OnlyUnpauser {}
1267 #[allow(
1268 non_camel_case_types,
1269 non_snake_case,
1270 clippy::pub_underscore_fields,
1271 clippy::style
1272 )]
1273 const _: () = {
1274 use alloy::sol_types as alloy_sol_types;
1275 #[doc(hidden)]
1276 type UnderlyingSolTuple<'a> = ();
1277 #[doc(hidden)]
1278 type UnderlyingRustTuple<'a> = ();
1279 #[cfg(test)]
1280 #[allow(dead_code, unreachable_patterns)]
1281 fn _type_assertion(
1282 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1283 ) {
1284 match _t {
1285 alloy_sol_types::private::AssertTypeEq::<
1286 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1287 >(_) => {}
1288 }
1289 }
1290 #[automatically_derived]
1291 #[doc(hidden)]
1292 impl ::core::convert::From<OnlyUnpauser> for UnderlyingRustTuple<'_> {
1293 fn from(value: OnlyUnpauser) -> Self {
1294 ()
1295 }
1296 }
1297 #[automatically_derived]
1298 #[doc(hidden)]
1299 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnpauser {
1300 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1301 Self {}
1302 }
1303 }
1304 #[automatically_derived]
1305 impl alloy_sol_types::SolError for OnlyUnpauser {
1306 type Parameters<'a> = UnderlyingSolTuple<'a>;
1307 type Token<'a> = <Self::Parameters<
1308 'a,
1309 > as alloy_sol_types::SolType>::Token<'a>;
1310 const SIGNATURE: &'static str = "OnlyUnpauser()";
1311 const SELECTOR: [u8; 4] = [121u8, 72u8, 33u8, 255u8];
1312 #[inline]
1313 fn new<'a>(
1314 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1315 ) -> Self {
1316 tuple.into()
1317 }
1318 #[inline]
1319 fn tokenize(&self) -> Self::Token<'_> {
1320 ()
1321 }
1322 }
1323 };
1324 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1325 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1330 #[derive(Clone)]
1331 pub struct StringTooLong {
1332 #[allow(missing_docs)]
1333 pub str: alloy::sol_types::private::String,
1334 }
1335 #[allow(
1336 non_camel_case_types,
1337 non_snake_case,
1338 clippy::pub_underscore_fields,
1339 clippy::style
1340 )]
1341 const _: () = {
1342 use alloy::sol_types as alloy_sol_types;
1343 #[doc(hidden)]
1344 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1345 #[doc(hidden)]
1346 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1347 #[cfg(test)]
1348 #[allow(dead_code, unreachable_patterns)]
1349 fn _type_assertion(
1350 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1351 ) {
1352 match _t {
1353 alloy_sol_types::private::AssertTypeEq::<
1354 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1355 >(_) => {}
1356 }
1357 }
1358 #[automatically_derived]
1359 #[doc(hidden)]
1360 impl ::core::convert::From<StringTooLong> for UnderlyingRustTuple<'_> {
1361 fn from(value: StringTooLong) -> Self {
1362 (value.str,)
1363 }
1364 }
1365 #[automatically_derived]
1366 #[doc(hidden)]
1367 impl ::core::convert::From<UnderlyingRustTuple<'_>> for StringTooLong {
1368 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1369 Self { str: tuple.0 }
1370 }
1371 }
1372 #[automatically_derived]
1373 impl alloy_sol_types::SolError for StringTooLong {
1374 type Parameters<'a> = UnderlyingSolTuple<'a>;
1375 type Token<'a> = <Self::Parameters<
1376 'a,
1377 > as alloy_sol_types::SolType>::Token<'a>;
1378 const SIGNATURE: &'static str = "StringTooLong(string)";
1379 const SELECTOR: [u8; 4] = [48u8, 90u8, 39u8, 169u8];
1380 #[inline]
1381 fn new<'a>(
1382 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1383 ) -> Self {
1384 tuple.into()
1385 }
1386 #[inline]
1387 fn tokenize(&self) -> Self::Token<'_> {
1388 (
1389 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1390 &self.str,
1391 ),
1392 )
1393 }
1394 }
1395 };
1396 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1397 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1402 #[derive(Clone)]
1403 pub struct TotalSharesExceedsMax {}
1404 #[allow(
1405 non_camel_case_types,
1406 non_snake_case,
1407 clippy::pub_underscore_fields,
1408 clippy::style
1409 )]
1410 const _: () = {
1411 use alloy::sol_types as alloy_sol_types;
1412 #[doc(hidden)]
1413 type UnderlyingSolTuple<'a> = ();
1414 #[doc(hidden)]
1415 type UnderlyingRustTuple<'a> = ();
1416 #[cfg(test)]
1417 #[allow(dead_code, unreachable_patterns)]
1418 fn _type_assertion(
1419 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1420 ) {
1421 match _t {
1422 alloy_sol_types::private::AssertTypeEq::<
1423 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1424 >(_) => {}
1425 }
1426 }
1427 #[automatically_derived]
1428 #[doc(hidden)]
1429 impl ::core::convert::From<TotalSharesExceedsMax> for UnderlyingRustTuple<'_> {
1430 fn from(value: TotalSharesExceedsMax) -> Self {
1431 ()
1432 }
1433 }
1434 #[automatically_derived]
1435 #[doc(hidden)]
1436 impl ::core::convert::From<UnderlyingRustTuple<'_>> for TotalSharesExceedsMax {
1437 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1438 Self {}
1439 }
1440 }
1441 #[automatically_derived]
1442 impl alloy_sol_types::SolError for TotalSharesExceedsMax {
1443 type Parameters<'a> = UnderlyingSolTuple<'a>;
1444 type Token<'a> = <Self::Parameters<
1445 'a,
1446 > as alloy_sol_types::SolType>::Token<'a>;
1447 const SIGNATURE: &'static str = "TotalSharesExceedsMax()";
1448 const SELECTOR: [u8; 4] = [94u8, 41u8, 209u8, 70u8];
1449 #[inline]
1450 fn new<'a>(
1451 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1452 ) -> Self {
1453 tuple.into()
1454 }
1455 #[inline]
1456 fn tokenize(&self) -> Self::Token<'_> {
1457 ()
1458 }
1459 }
1460 };
1461 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1462 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1467 #[derive(Clone)]
1468 pub struct WithdrawalAmountExceedsTotalDeposits {}
1469 #[allow(
1470 non_camel_case_types,
1471 non_snake_case,
1472 clippy::pub_underscore_fields,
1473 clippy::style
1474 )]
1475 const _: () = {
1476 use alloy::sol_types as alloy_sol_types;
1477 #[doc(hidden)]
1478 type UnderlyingSolTuple<'a> = ();
1479 #[doc(hidden)]
1480 type UnderlyingRustTuple<'a> = ();
1481 #[cfg(test)]
1482 #[allow(dead_code, unreachable_patterns)]
1483 fn _type_assertion(
1484 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1485 ) {
1486 match _t {
1487 alloy_sol_types::private::AssertTypeEq::<
1488 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1489 >(_) => {}
1490 }
1491 }
1492 #[automatically_derived]
1493 #[doc(hidden)]
1494 impl ::core::convert::From<WithdrawalAmountExceedsTotalDeposits>
1495 for UnderlyingRustTuple<'_> {
1496 fn from(value: WithdrawalAmountExceedsTotalDeposits) -> Self {
1497 ()
1498 }
1499 }
1500 #[automatically_derived]
1501 #[doc(hidden)]
1502 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1503 for WithdrawalAmountExceedsTotalDeposits {
1504 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1505 Self {}
1506 }
1507 }
1508 #[automatically_derived]
1509 impl alloy_sol_types::SolError for WithdrawalAmountExceedsTotalDeposits {
1510 type Parameters<'a> = UnderlyingSolTuple<'a>;
1511 type Token<'a> = <Self::Parameters<
1512 'a,
1513 > as alloy_sol_types::SolType>::Token<'a>;
1514 const SIGNATURE: &'static str = "WithdrawalAmountExceedsTotalDeposits()";
1515 const SELECTOR: [u8; 4] = [180u8, 105u8, 223u8, 48u8];
1516 #[inline]
1517 fn new<'a>(
1518 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1519 ) -> Self {
1520 tuple.into()
1521 }
1522 #[inline]
1523 fn tokenize(&self) -> Self::Token<'_> {
1524 ()
1525 }
1526 }
1527 };
1528 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1529 #[allow(
1534 non_camel_case_types,
1535 non_snake_case,
1536 clippy::pub_underscore_fields,
1537 clippy::style
1538 )]
1539 #[derive(Clone)]
1540 pub struct ExchangeRateEmitted {
1541 #[allow(missing_docs)]
1542 pub rate: alloy::sol_types::private::primitives::aliases::U256,
1543 }
1544 #[allow(
1545 non_camel_case_types,
1546 non_snake_case,
1547 clippy::pub_underscore_fields,
1548 clippy::style
1549 )]
1550 const _: () = {
1551 use alloy::sol_types as alloy_sol_types;
1552 #[automatically_derived]
1553 impl alloy_sol_types::SolEvent for ExchangeRateEmitted {
1554 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1555 type DataToken<'a> = <Self::DataTuple<
1556 'a,
1557 > as alloy_sol_types::SolType>::Token<'a>;
1558 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1559 const SIGNATURE: &'static str = "ExchangeRateEmitted(uint256)";
1560 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1561 210u8, 73u8, 79u8, 52u8, 121u8, 229u8, 218u8, 73u8, 211u8, 134u8, 101u8,
1562 124u8, 41u8, 44u8, 97u8, 11u8, 91u8, 1u8, 223u8, 49u8, 61u8, 7u8, 198u8,
1563 46u8, 176u8, 207u8, 164u8, 153u8, 36u8, 163u8, 27u8, 232u8,
1564 ]);
1565 const ANONYMOUS: bool = false;
1566 #[allow(unused_variables)]
1567 #[inline]
1568 fn new(
1569 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1570 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1571 ) -> Self {
1572 Self { rate: data.0 }
1573 }
1574 #[inline]
1575 fn check_signature(
1576 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1577 ) -> alloy_sol_types::Result<()> {
1578 if topics.0 != Self::SIGNATURE_HASH {
1579 return Err(
1580 alloy_sol_types::Error::invalid_event_signature_hash(
1581 Self::SIGNATURE,
1582 topics.0,
1583 Self::SIGNATURE_HASH,
1584 ),
1585 );
1586 }
1587 Ok(())
1588 }
1589 #[inline]
1590 fn tokenize_body(&self) -> Self::DataToken<'_> {
1591 (
1592 <alloy::sol_types::sol_data::Uint<
1593 256,
1594 > as alloy_sol_types::SolType>::tokenize(&self.rate),
1595 )
1596 }
1597 #[inline]
1598 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1599 (Self::SIGNATURE_HASH.into(),)
1600 }
1601 #[inline]
1602 fn encode_topics_raw(
1603 &self,
1604 out: &mut [alloy_sol_types::abi::token::WordToken],
1605 ) -> alloy_sol_types::Result<()> {
1606 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1607 return Err(alloy_sol_types::Error::Overrun);
1608 }
1609 out[0usize] = alloy_sol_types::abi::token::WordToken(
1610 Self::SIGNATURE_HASH,
1611 );
1612 Ok(())
1613 }
1614 }
1615 #[automatically_derived]
1616 impl alloy_sol_types::private::IntoLogData for ExchangeRateEmitted {
1617 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1618 From::from(self)
1619 }
1620 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1621 From::from(&self)
1622 }
1623 }
1624 #[automatically_derived]
1625 impl From<&ExchangeRateEmitted> for alloy_sol_types::private::LogData {
1626 #[inline]
1627 fn from(this: &ExchangeRateEmitted) -> alloy_sol_types::private::LogData {
1628 alloy_sol_types::SolEvent::encode_log_data(this)
1629 }
1630 }
1631 };
1632 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1633 #[allow(
1638 non_camel_case_types,
1639 non_snake_case,
1640 clippy::pub_underscore_fields,
1641 clippy::style
1642 )]
1643 #[derive(Clone)]
1644 pub struct Initialized {
1645 #[allow(missing_docs)]
1646 pub version: u8,
1647 }
1648 #[allow(
1649 non_camel_case_types,
1650 non_snake_case,
1651 clippy::pub_underscore_fields,
1652 clippy::style
1653 )]
1654 const _: () = {
1655 use alloy::sol_types as alloy_sol_types;
1656 #[automatically_derived]
1657 impl alloy_sol_types::SolEvent for Initialized {
1658 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
1659 type DataToken<'a> = <Self::DataTuple<
1660 'a,
1661 > as alloy_sol_types::SolType>::Token<'a>;
1662 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1663 const SIGNATURE: &'static str = "Initialized(uint8)";
1664 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1665 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
1666 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
1667 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
1668 ]);
1669 const ANONYMOUS: bool = false;
1670 #[allow(unused_variables)]
1671 #[inline]
1672 fn new(
1673 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1674 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1675 ) -> Self {
1676 Self { version: data.0 }
1677 }
1678 #[inline]
1679 fn check_signature(
1680 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1681 ) -> alloy_sol_types::Result<()> {
1682 if topics.0 != Self::SIGNATURE_HASH {
1683 return Err(
1684 alloy_sol_types::Error::invalid_event_signature_hash(
1685 Self::SIGNATURE,
1686 topics.0,
1687 Self::SIGNATURE_HASH,
1688 ),
1689 );
1690 }
1691 Ok(())
1692 }
1693 #[inline]
1694 fn tokenize_body(&self) -> Self::DataToken<'_> {
1695 (
1696 <alloy::sol_types::sol_data::Uint<
1697 8,
1698 > as alloy_sol_types::SolType>::tokenize(&self.version),
1699 )
1700 }
1701 #[inline]
1702 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1703 (Self::SIGNATURE_HASH.into(),)
1704 }
1705 #[inline]
1706 fn encode_topics_raw(
1707 &self,
1708 out: &mut [alloy_sol_types::abi::token::WordToken],
1709 ) -> alloy_sol_types::Result<()> {
1710 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1711 return Err(alloy_sol_types::Error::Overrun);
1712 }
1713 out[0usize] = alloy_sol_types::abi::token::WordToken(
1714 Self::SIGNATURE_HASH,
1715 );
1716 Ok(())
1717 }
1718 }
1719 #[automatically_derived]
1720 impl alloy_sol_types::private::IntoLogData for Initialized {
1721 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1722 From::from(self)
1723 }
1724 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1725 From::from(&self)
1726 }
1727 }
1728 #[automatically_derived]
1729 impl From<&Initialized> for alloy_sol_types::private::LogData {
1730 #[inline]
1731 fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
1732 alloy_sol_types::SolEvent::encode_log_data(this)
1733 }
1734 }
1735 };
1736 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1737 #[allow(
1742 non_camel_case_types,
1743 non_snake_case,
1744 clippy::pub_underscore_fields,
1745 clippy::style
1746 )]
1747 #[derive(Clone)]
1748 pub struct Paused {
1749 #[allow(missing_docs)]
1750 pub account: alloy::sol_types::private::Address,
1751 #[allow(missing_docs)]
1752 pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
1753 }
1754 #[allow(
1755 non_camel_case_types,
1756 non_snake_case,
1757 clippy::pub_underscore_fields,
1758 clippy::style
1759 )]
1760 const _: () = {
1761 use alloy::sol_types as alloy_sol_types;
1762 #[automatically_derived]
1763 impl alloy_sol_types::SolEvent for Paused {
1764 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1765 type DataToken<'a> = <Self::DataTuple<
1766 'a,
1767 > as alloy_sol_types::SolType>::Token<'a>;
1768 type TopicList = (
1769 alloy_sol_types::sol_data::FixedBytes<32>,
1770 alloy::sol_types::sol_data::Address,
1771 );
1772 const SIGNATURE: &'static str = "Paused(address,uint256)";
1773 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1774 171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8,
1775 188u8, 152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8,
1776 11u8, 182u8, 224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
1777 ]);
1778 const ANONYMOUS: bool = false;
1779 #[allow(unused_variables)]
1780 #[inline]
1781 fn new(
1782 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1783 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1784 ) -> Self {
1785 Self {
1786 account: topics.1,
1787 newPausedStatus: data.0,
1788 }
1789 }
1790 #[inline]
1791 fn check_signature(
1792 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1793 ) -> alloy_sol_types::Result<()> {
1794 if topics.0 != Self::SIGNATURE_HASH {
1795 return Err(
1796 alloy_sol_types::Error::invalid_event_signature_hash(
1797 Self::SIGNATURE,
1798 topics.0,
1799 Self::SIGNATURE_HASH,
1800 ),
1801 );
1802 }
1803 Ok(())
1804 }
1805 #[inline]
1806 fn tokenize_body(&self) -> Self::DataToken<'_> {
1807 (
1808 <alloy::sol_types::sol_data::Uint<
1809 256,
1810 > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
1811 )
1812 }
1813 #[inline]
1814 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1815 (Self::SIGNATURE_HASH.into(), self.account.clone())
1816 }
1817 #[inline]
1818 fn encode_topics_raw(
1819 &self,
1820 out: &mut [alloy_sol_types::abi::token::WordToken],
1821 ) -> alloy_sol_types::Result<()> {
1822 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1823 return Err(alloy_sol_types::Error::Overrun);
1824 }
1825 out[0usize] = alloy_sol_types::abi::token::WordToken(
1826 Self::SIGNATURE_HASH,
1827 );
1828 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1829 &self.account,
1830 );
1831 Ok(())
1832 }
1833 }
1834 #[automatically_derived]
1835 impl alloy_sol_types::private::IntoLogData for Paused {
1836 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1837 From::from(self)
1838 }
1839 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1840 From::from(&self)
1841 }
1842 }
1843 #[automatically_derived]
1844 impl From<&Paused> for alloy_sol_types::private::LogData {
1845 #[inline]
1846 fn from(this: &Paused) -> alloy_sol_types::private::LogData {
1847 alloy_sol_types::SolEvent::encode_log_data(this)
1848 }
1849 }
1850 };
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 StrategyTokenSet {
1864 #[allow(missing_docs)]
1865 pub token: alloy::sol_types::private::Address,
1866 #[allow(missing_docs)]
1867 pub decimals: u8,
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 StrategyTokenSet {
1879 type DataTuple<'a> = (
1880 alloy::sol_types::sol_data::Address,
1881 alloy::sol_types::sol_data::Uint<8>,
1882 );
1883 type DataToken<'a> = <Self::DataTuple<
1884 'a,
1885 > as alloy_sol_types::SolType>::Token<'a>;
1886 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1887 const SIGNATURE: &'static str = "StrategyTokenSet(address,uint8)";
1888 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1889 28u8, 84u8, 7u8, 7u8, 176u8, 14u8, 181u8, 66u8, 123u8, 107u8, 119u8,
1890 79u8, 199u8, 153u8, 215u8, 86u8, 81u8, 106u8, 84u8, 174u8, 225u8, 8u8,
1891 182u8, 75u8, 50u8, 122u8, 204u8, 85u8, 175u8, 85u8, 117u8, 7u8,
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 token: data.0,
1902 decimals: data.1,
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::Address as alloy_sol_types::SolType>::tokenize(
1924 &self.token,
1925 ),
1926 <alloy::sol_types::sol_data::Uint<
1927 8,
1928 > as alloy_sol_types::SolType>::tokenize(&self.decimals),
1929 )
1930 }
1931 #[inline]
1932 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1933 (Self::SIGNATURE_HASH.into(),)
1934 }
1935 #[inline]
1936 fn encode_topics_raw(
1937 &self,
1938 out: &mut [alloy_sol_types::abi::token::WordToken],
1939 ) -> alloy_sol_types::Result<()> {
1940 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1941 return Err(alloy_sol_types::Error::Overrun);
1942 }
1943 out[0usize] = alloy_sol_types::abi::token::WordToken(
1944 Self::SIGNATURE_HASH,
1945 );
1946 Ok(())
1947 }
1948 }
1949 #[automatically_derived]
1950 impl alloy_sol_types::private::IntoLogData for StrategyTokenSet {
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<&StrategyTokenSet> for alloy_sol_types::private::LogData {
1960 #[inline]
1961 fn from(this: &StrategyTokenSet) -> alloy_sol_types::private::LogData {
1962 alloy_sol_types::SolEvent::encode_log_data(this)
1963 }
1964 }
1965 };
1966 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1967 #[allow(
1972 non_camel_case_types,
1973 non_snake_case,
1974 clippy::pub_underscore_fields,
1975 clippy::style
1976 )]
1977 #[derive(Clone)]
1978 pub struct Unpaused {
1979 #[allow(missing_docs)]
1980 pub account: alloy::sol_types::private::Address,
1981 #[allow(missing_docs)]
1982 pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
1983 }
1984 #[allow(
1985 non_camel_case_types,
1986 non_snake_case,
1987 clippy::pub_underscore_fields,
1988 clippy::style
1989 )]
1990 const _: () = {
1991 use alloy::sol_types as alloy_sol_types;
1992 #[automatically_derived]
1993 impl alloy_sol_types::SolEvent for Unpaused {
1994 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1995 type DataToken<'a> = <Self::DataTuple<
1996 'a,
1997 > as alloy_sol_types::SolType>::Token<'a>;
1998 type TopicList = (
1999 alloy_sol_types::sol_data::FixedBytes<32>,
2000 alloy::sol_types::sol_data::Address,
2001 );
2002 const SIGNATURE: &'static str = "Unpaused(address,uint256)";
2003 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2004 53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8,
2005 2u8, 188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8,
2006 228u8, 152u8, 107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
2007 ]);
2008 const ANONYMOUS: bool = false;
2009 #[allow(unused_variables)]
2010 #[inline]
2011 fn new(
2012 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2013 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2014 ) -> Self {
2015 Self {
2016 account: topics.1,
2017 newPausedStatus: data.0,
2018 }
2019 }
2020 #[inline]
2021 fn check_signature(
2022 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2023 ) -> alloy_sol_types::Result<()> {
2024 if topics.0 != Self::SIGNATURE_HASH {
2025 return Err(
2026 alloy_sol_types::Error::invalid_event_signature_hash(
2027 Self::SIGNATURE,
2028 topics.0,
2029 Self::SIGNATURE_HASH,
2030 ),
2031 );
2032 }
2033 Ok(())
2034 }
2035 #[inline]
2036 fn tokenize_body(&self) -> Self::DataToken<'_> {
2037 (
2038 <alloy::sol_types::sol_data::Uint<
2039 256,
2040 > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
2041 )
2042 }
2043 #[inline]
2044 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2045 (Self::SIGNATURE_HASH.into(), self.account.clone())
2046 }
2047 #[inline]
2048 fn encode_topics_raw(
2049 &self,
2050 out: &mut [alloy_sol_types::abi::token::WordToken],
2051 ) -> alloy_sol_types::Result<()> {
2052 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2053 return Err(alloy_sol_types::Error::Overrun);
2054 }
2055 out[0usize] = alloy_sol_types::abi::token::WordToken(
2056 Self::SIGNATURE_HASH,
2057 );
2058 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2059 &self.account,
2060 );
2061 Ok(())
2062 }
2063 }
2064 #[automatically_derived]
2065 impl alloy_sol_types::private::IntoLogData for Unpaused {
2066 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2067 From::from(self)
2068 }
2069 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2070 From::from(&self)
2071 }
2072 }
2073 #[automatically_derived]
2074 impl From<&Unpaused> for alloy_sol_types::private::LogData {
2075 #[inline]
2076 fn from(this: &Unpaused) -> alloy_sol_types::private::LogData {
2077 alloy_sol_types::SolEvent::encode_log_data(this)
2078 }
2079 }
2080 };
2081 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2086 #[derive(Clone)]
2087 pub struct constructorCall {
2088 #[allow(missing_docs)]
2089 pub _strategyManager: alloy::sol_types::private::Address,
2090 #[allow(missing_docs)]
2091 pub _pauserRegistry: alloy::sol_types::private::Address,
2092 #[allow(missing_docs)]
2093 pub _version: alloy::sol_types::private::String,
2094 }
2095 const _: () = {
2096 use alloy::sol_types as alloy_sol_types;
2097 {
2098 #[doc(hidden)]
2099 type UnderlyingSolTuple<'a> = (
2100 alloy::sol_types::sol_data::Address,
2101 alloy::sol_types::sol_data::Address,
2102 alloy::sol_types::sol_data::String,
2103 );
2104 #[doc(hidden)]
2105 type UnderlyingRustTuple<'a> = (
2106 alloy::sol_types::private::Address,
2107 alloy::sol_types::private::Address,
2108 alloy::sol_types::private::String,
2109 );
2110 #[cfg(test)]
2111 #[allow(dead_code, unreachable_patterns)]
2112 fn _type_assertion(
2113 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2114 ) {
2115 match _t {
2116 alloy_sol_types::private::AssertTypeEq::<
2117 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2118 >(_) => {}
2119 }
2120 }
2121 #[automatically_derived]
2122 #[doc(hidden)]
2123 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
2124 fn from(value: constructorCall) -> Self {
2125 (value._strategyManager, value._pauserRegistry, value._version)
2126 }
2127 }
2128 #[automatically_derived]
2129 #[doc(hidden)]
2130 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
2131 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2132 Self {
2133 _strategyManager: tuple.0,
2134 _pauserRegistry: tuple.1,
2135 _version: tuple.2,
2136 }
2137 }
2138 }
2139 }
2140 #[automatically_derived]
2141 impl alloy_sol_types::SolConstructor for constructorCall {
2142 type Parameters<'a> = (
2143 alloy::sol_types::sol_data::Address,
2144 alloy::sol_types::sol_data::Address,
2145 alloy::sol_types::sol_data::String,
2146 );
2147 type Token<'a> = <Self::Parameters<
2148 'a,
2149 > as alloy_sol_types::SolType>::Token<'a>;
2150 #[inline]
2151 fn new<'a>(
2152 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2153 ) -> Self {
2154 tuple.into()
2155 }
2156 #[inline]
2157 fn tokenize(&self) -> Self::Token<'_> {
2158 (
2159 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2160 &self._strategyManager,
2161 ),
2162 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2163 &self._pauserRegistry,
2164 ),
2165 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
2166 &self._version,
2167 ),
2168 )
2169 }
2170 }
2171 };
2172 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2173 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2178 #[derive(Clone)]
2179 pub struct depositCall {
2180 #[allow(missing_docs)]
2181 pub token: alloy::sol_types::private::Address,
2182 #[allow(missing_docs)]
2183 pub amount: alloy::sol_types::private::primitives::aliases::U256,
2184 }
2185 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2186 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2188 #[derive(Clone)]
2189 pub struct depositReturn {
2190 #[allow(missing_docs)]
2191 pub newShares: alloy::sol_types::private::primitives::aliases::U256,
2192 }
2193 #[allow(
2194 non_camel_case_types,
2195 non_snake_case,
2196 clippy::pub_underscore_fields,
2197 clippy::style
2198 )]
2199 const _: () = {
2200 use alloy::sol_types as alloy_sol_types;
2201 {
2202 #[doc(hidden)]
2203 type UnderlyingSolTuple<'a> = (
2204 alloy::sol_types::sol_data::Address,
2205 alloy::sol_types::sol_data::Uint<256>,
2206 );
2207 #[doc(hidden)]
2208 type UnderlyingRustTuple<'a> = (
2209 alloy::sol_types::private::Address,
2210 alloy::sol_types::private::primitives::aliases::U256,
2211 );
2212 #[cfg(test)]
2213 #[allow(dead_code, unreachable_patterns)]
2214 fn _type_assertion(
2215 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2216 ) {
2217 match _t {
2218 alloy_sol_types::private::AssertTypeEq::<
2219 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2220 >(_) => {}
2221 }
2222 }
2223 #[automatically_derived]
2224 #[doc(hidden)]
2225 impl ::core::convert::From<depositCall> for UnderlyingRustTuple<'_> {
2226 fn from(value: depositCall) -> Self {
2227 (value.token, value.amount)
2228 }
2229 }
2230 #[automatically_derived]
2231 #[doc(hidden)]
2232 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositCall {
2233 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2234 Self {
2235 token: tuple.0,
2236 amount: tuple.1,
2237 }
2238 }
2239 }
2240 }
2241 {
2242 #[doc(hidden)]
2243 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2244 #[doc(hidden)]
2245 type UnderlyingRustTuple<'a> = (
2246 alloy::sol_types::private::primitives::aliases::U256,
2247 );
2248 #[cfg(test)]
2249 #[allow(dead_code, unreachable_patterns)]
2250 fn _type_assertion(
2251 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2252 ) {
2253 match _t {
2254 alloy_sol_types::private::AssertTypeEq::<
2255 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2256 >(_) => {}
2257 }
2258 }
2259 #[automatically_derived]
2260 #[doc(hidden)]
2261 impl ::core::convert::From<depositReturn> for UnderlyingRustTuple<'_> {
2262 fn from(value: depositReturn) -> Self {
2263 (value.newShares,)
2264 }
2265 }
2266 #[automatically_derived]
2267 #[doc(hidden)]
2268 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositReturn {
2269 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2270 Self { newShares: tuple.0 }
2271 }
2272 }
2273 }
2274 #[automatically_derived]
2275 impl alloy_sol_types::SolCall for depositCall {
2276 type Parameters<'a> = (
2277 alloy::sol_types::sol_data::Address,
2278 alloy::sol_types::sol_data::Uint<256>,
2279 );
2280 type Token<'a> = <Self::Parameters<
2281 'a,
2282 > as alloy_sol_types::SolType>::Token<'a>;
2283 type Return = depositReturn;
2284 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2285 type ReturnToken<'a> = <Self::ReturnTuple<
2286 'a,
2287 > as alloy_sol_types::SolType>::Token<'a>;
2288 const SIGNATURE: &'static str = "deposit(address,uint256)";
2289 const SELECTOR: [u8; 4] = [71u8, 231u8, 239u8, 36u8];
2290 #[inline]
2291 fn new<'a>(
2292 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2293 ) -> Self {
2294 tuple.into()
2295 }
2296 #[inline]
2297 fn tokenize(&self) -> Self::Token<'_> {
2298 (
2299 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2300 &self.token,
2301 ),
2302 <alloy::sol_types::sol_data::Uint<
2303 256,
2304 > as alloy_sol_types::SolType>::tokenize(&self.amount),
2305 )
2306 }
2307 #[inline]
2308 fn abi_decode_returns(
2309 data: &[u8],
2310 validate: bool,
2311 ) -> alloy_sol_types::Result<Self::Return> {
2312 <Self::ReturnTuple<
2313 '_,
2314 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2315 .map(Into::into)
2316 }
2317 }
2318 };
2319 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2320 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2325 #[derive(Clone)]
2326 pub struct explanationCall {}
2327 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2328 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2330 #[derive(Clone)]
2331 pub struct explanationReturn {
2332 #[allow(missing_docs)]
2333 pub _0: alloy::sol_types::private::String,
2334 }
2335 #[allow(
2336 non_camel_case_types,
2337 non_snake_case,
2338 clippy::pub_underscore_fields,
2339 clippy::style
2340 )]
2341 const _: () = {
2342 use alloy::sol_types as alloy_sol_types;
2343 {
2344 #[doc(hidden)]
2345 type UnderlyingSolTuple<'a> = ();
2346 #[doc(hidden)]
2347 type UnderlyingRustTuple<'a> = ();
2348 #[cfg(test)]
2349 #[allow(dead_code, unreachable_patterns)]
2350 fn _type_assertion(
2351 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2352 ) {
2353 match _t {
2354 alloy_sol_types::private::AssertTypeEq::<
2355 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2356 >(_) => {}
2357 }
2358 }
2359 #[automatically_derived]
2360 #[doc(hidden)]
2361 impl ::core::convert::From<explanationCall> for UnderlyingRustTuple<'_> {
2362 fn from(value: explanationCall) -> Self {
2363 ()
2364 }
2365 }
2366 #[automatically_derived]
2367 #[doc(hidden)]
2368 impl ::core::convert::From<UnderlyingRustTuple<'_>> for explanationCall {
2369 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2370 Self {}
2371 }
2372 }
2373 }
2374 {
2375 #[doc(hidden)]
2376 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2377 #[doc(hidden)]
2378 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2379 #[cfg(test)]
2380 #[allow(dead_code, unreachable_patterns)]
2381 fn _type_assertion(
2382 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2383 ) {
2384 match _t {
2385 alloy_sol_types::private::AssertTypeEq::<
2386 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2387 >(_) => {}
2388 }
2389 }
2390 #[automatically_derived]
2391 #[doc(hidden)]
2392 impl ::core::convert::From<explanationReturn> for UnderlyingRustTuple<'_> {
2393 fn from(value: explanationReturn) -> Self {
2394 (value._0,)
2395 }
2396 }
2397 #[automatically_derived]
2398 #[doc(hidden)]
2399 impl ::core::convert::From<UnderlyingRustTuple<'_>> for explanationReturn {
2400 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2401 Self { _0: tuple.0 }
2402 }
2403 }
2404 }
2405 #[automatically_derived]
2406 impl alloy_sol_types::SolCall for explanationCall {
2407 type Parameters<'a> = ();
2408 type Token<'a> = <Self::Parameters<
2409 'a,
2410 > as alloy_sol_types::SolType>::Token<'a>;
2411 type Return = explanationReturn;
2412 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2413 type ReturnToken<'a> = <Self::ReturnTuple<
2414 'a,
2415 > as alloy_sol_types::SolType>::Token<'a>;
2416 const SIGNATURE: &'static str = "explanation()";
2417 const SELECTOR: [u8; 4] = [171u8, 89u8, 33u8, 225u8];
2418 #[inline]
2419 fn new<'a>(
2420 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2421 ) -> Self {
2422 tuple.into()
2423 }
2424 #[inline]
2425 fn tokenize(&self) -> Self::Token<'_> {
2426 ()
2427 }
2428 #[inline]
2429 fn abi_decode_returns(
2430 data: &[u8],
2431 validate: bool,
2432 ) -> alloy_sol_types::Result<Self::Return> {
2433 <Self::ReturnTuple<
2434 '_,
2435 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2436 .map(Into::into)
2437 }
2438 }
2439 };
2440 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2441 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2446 #[derive(Clone)]
2447 pub struct initializeCall {
2448 #[allow(missing_docs)]
2449 pub _underlyingToken: alloy::sol_types::private::Address,
2450 }
2451 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2453 #[derive(Clone)]
2454 pub struct initializeReturn {}
2455 #[allow(
2456 non_camel_case_types,
2457 non_snake_case,
2458 clippy::pub_underscore_fields,
2459 clippy::style
2460 )]
2461 const _: () = {
2462 use alloy::sol_types as alloy_sol_types;
2463 {
2464 #[doc(hidden)]
2465 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2466 #[doc(hidden)]
2467 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2468 #[cfg(test)]
2469 #[allow(dead_code, unreachable_patterns)]
2470 fn _type_assertion(
2471 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2472 ) {
2473 match _t {
2474 alloy_sol_types::private::AssertTypeEq::<
2475 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2476 >(_) => {}
2477 }
2478 }
2479 #[automatically_derived]
2480 #[doc(hidden)]
2481 impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
2482 fn from(value: initializeCall) -> Self {
2483 (value._underlyingToken,)
2484 }
2485 }
2486 #[automatically_derived]
2487 #[doc(hidden)]
2488 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
2489 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2490 Self { _underlyingToken: tuple.0 }
2491 }
2492 }
2493 }
2494 {
2495 #[doc(hidden)]
2496 type UnderlyingSolTuple<'a> = ();
2497 #[doc(hidden)]
2498 type UnderlyingRustTuple<'a> = ();
2499 #[cfg(test)]
2500 #[allow(dead_code, unreachable_patterns)]
2501 fn _type_assertion(
2502 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2503 ) {
2504 match _t {
2505 alloy_sol_types::private::AssertTypeEq::<
2506 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2507 >(_) => {}
2508 }
2509 }
2510 #[automatically_derived]
2511 #[doc(hidden)]
2512 impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
2513 fn from(value: initializeReturn) -> Self {
2514 ()
2515 }
2516 }
2517 #[automatically_derived]
2518 #[doc(hidden)]
2519 impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
2520 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2521 Self {}
2522 }
2523 }
2524 }
2525 #[automatically_derived]
2526 impl alloy_sol_types::SolCall for initializeCall {
2527 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2528 type Token<'a> = <Self::Parameters<
2529 'a,
2530 > as alloy_sol_types::SolType>::Token<'a>;
2531 type Return = initializeReturn;
2532 type ReturnTuple<'a> = ();
2533 type ReturnToken<'a> = <Self::ReturnTuple<
2534 'a,
2535 > as alloy_sol_types::SolType>::Token<'a>;
2536 const SIGNATURE: &'static str = "initialize(address)";
2537 const SELECTOR: [u8; 4] = [196u8, 214u8, 109u8, 232u8];
2538 #[inline]
2539 fn new<'a>(
2540 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2541 ) -> Self {
2542 tuple.into()
2543 }
2544 #[inline]
2545 fn tokenize(&self) -> Self::Token<'_> {
2546 (
2547 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2548 &self._underlyingToken,
2549 ),
2550 )
2551 }
2552 #[inline]
2553 fn abi_decode_returns(
2554 data: &[u8],
2555 validate: bool,
2556 ) -> alloy_sol_types::Result<Self::Return> {
2557 <Self::ReturnTuple<
2558 '_,
2559 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2560 .map(Into::into)
2561 }
2562 }
2563 };
2564 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2565 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2570 #[derive(Clone)]
2571 pub struct pauseCall {
2572 #[allow(missing_docs)]
2573 pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
2574 }
2575 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2577 #[derive(Clone)]
2578 pub struct pauseReturn {}
2579 #[allow(
2580 non_camel_case_types,
2581 non_snake_case,
2582 clippy::pub_underscore_fields,
2583 clippy::style
2584 )]
2585 const _: () = {
2586 use alloy::sol_types as alloy_sol_types;
2587 {
2588 #[doc(hidden)]
2589 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2590 #[doc(hidden)]
2591 type UnderlyingRustTuple<'a> = (
2592 alloy::sol_types::private::primitives::aliases::U256,
2593 );
2594 #[cfg(test)]
2595 #[allow(dead_code, unreachable_patterns)]
2596 fn _type_assertion(
2597 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2598 ) {
2599 match _t {
2600 alloy_sol_types::private::AssertTypeEq::<
2601 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2602 >(_) => {}
2603 }
2604 }
2605 #[automatically_derived]
2606 #[doc(hidden)]
2607 impl ::core::convert::From<pauseCall> for UnderlyingRustTuple<'_> {
2608 fn from(value: pauseCall) -> Self {
2609 (value.newPausedStatus,)
2610 }
2611 }
2612 #[automatically_derived]
2613 #[doc(hidden)]
2614 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseCall {
2615 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2616 Self { newPausedStatus: tuple.0 }
2617 }
2618 }
2619 }
2620 {
2621 #[doc(hidden)]
2622 type UnderlyingSolTuple<'a> = ();
2623 #[doc(hidden)]
2624 type UnderlyingRustTuple<'a> = ();
2625 #[cfg(test)]
2626 #[allow(dead_code, unreachable_patterns)]
2627 fn _type_assertion(
2628 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2629 ) {
2630 match _t {
2631 alloy_sol_types::private::AssertTypeEq::<
2632 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2633 >(_) => {}
2634 }
2635 }
2636 #[automatically_derived]
2637 #[doc(hidden)]
2638 impl ::core::convert::From<pauseReturn> for UnderlyingRustTuple<'_> {
2639 fn from(value: pauseReturn) -> Self {
2640 ()
2641 }
2642 }
2643 #[automatically_derived]
2644 #[doc(hidden)]
2645 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseReturn {
2646 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2647 Self {}
2648 }
2649 }
2650 }
2651 #[automatically_derived]
2652 impl alloy_sol_types::SolCall for pauseCall {
2653 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2654 type Token<'a> = <Self::Parameters<
2655 'a,
2656 > as alloy_sol_types::SolType>::Token<'a>;
2657 type Return = pauseReturn;
2658 type ReturnTuple<'a> = ();
2659 type ReturnToken<'a> = <Self::ReturnTuple<
2660 'a,
2661 > as alloy_sol_types::SolType>::Token<'a>;
2662 const SIGNATURE: &'static str = "pause(uint256)";
2663 const SELECTOR: [u8; 4] = [19u8, 100u8, 57u8, 221u8];
2664 #[inline]
2665 fn new<'a>(
2666 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2667 ) -> Self {
2668 tuple.into()
2669 }
2670 #[inline]
2671 fn tokenize(&self) -> Self::Token<'_> {
2672 (
2673 <alloy::sol_types::sol_data::Uint<
2674 256,
2675 > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
2676 )
2677 }
2678 #[inline]
2679 fn abi_decode_returns(
2680 data: &[u8],
2681 validate: bool,
2682 ) -> alloy_sol_types::Result<Self::Return> {
2683 <Self::ReturnTuple<
2684 '_,
2685 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2686 .map(Into::into)
2687 }
2688 }
2689 };
2690 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2691 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2696 #[derive(Clone)]
2697 pub struct pauseAllCall {}
2698 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2700 #[derive(Clone)]
2701 pub struct pauseAllReturn {}
2702 #[allow(
2703 non_camel_case_types,
2704 non_snake_case,
2705 clippy::pub_underscore_fields,
2706 clippy::style
2707 )]
2708 const _: () = {
2709 use alloy::sol_types as alloy_sol_types;
2710 {
2711 #[doc(hidden)]
2712 type UnderlyingSolTuple<'a> = ();
2713 #[doc(hidden)]
2714 type UnderlyingRustTuple<'a> = ();
2715 #[cfg(test)]
2716 #[allow(dead_code, unreachable_patterns)]
2717 fn _type_assertion(
2718 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2719 ) {
2720 match _t {
2721 alloy_sol_types::private::AssertTypeEq::<
2722 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2723 >(_) => {}
2724 }
2725 }
2726 #[automatically_derived]
2727 #[doc(hidden)]
2728 impl ::core::convert::From<pauseAllCall> for UnderlyingRustTuple<'_> {
2729 fn from(value: pauseAllCall) -> Self {
2730 ()
2731 }
2732 }
2733 #[automatically_derived]
2734 #[doc(hidden)]
2735 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllCall {
2736 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2737 Self {}
2738 }
2739 }
2740 }
2741 {
2742 #[doc(hidden)]
2743 type UnderlyingSolTuple<'a> = ();
2744 #[doc(hidden)]
2745 type UnderlyingRustTuple<'a> = ();
2746 #[cfg(test)]
2747 #[allow(dead_code, unreachable_patterns)]
2748 fn _type_assertion(
2749 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2750 ) {
2751 match _t {
2752 alloy_sol_types::private::AssertTypeEq::<
2753 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2754 >(_) => {}
2755 }
2756 }
2757 #[automatically_derived]
2758 #[doc(hidden)]
2759 impl ::core::convert::From<pauseAllReturn> for UnderlyingRustTuple<'_> {
2760 fn from(value: pauseAllReturn) -> Self {
2761 ()
2762 }
2763 }
2764 #[automatically_derived]
2765 #[doc(hidden)]
2766 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllReturn {
2767 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2768 Self {}
2769 }
2770 }
2771 }
2772 #[automatically_derived]
2773 impl alloy_sol_types::SolCall for pauseAllCall {
2774 type Parameters<'a> = ();
2775 type Token<'a> = <Self::Parameters<
2776 'a,
2777 > as alloy_sol_types::SolType>::Token<'a>;
2778 type Return = pauseAllReturn;
2779 type ReturnTuple<'a> = ();
2780 type ReturnToken<'a> = <Self::ReturnTuple<
2781 'a,
2782 > as alloy_sol_types::SolType>::Token<'a>;
2783 const SIGNATURE: &'static str = "pauseAll()";
2784 const SELECTOR: [u8; 4] = [89u8, 92u8, 106u8, 103u8];
2785 #[inline]
2786 fn new<'a>(
2787 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2788 ) -> Self {
2789 tuple.into()
2790 }
2791 #[inline]
2792 fn tokenize(&self) -> Self::Token<'_> {
2793 ()
2794 }
2795 #[inline]
2796 fn abi_decode_returns(
2797 data: &[u8],
2798 validate: bool,
2799 ) -> alloy_sol_types::Result<Self::Return> {
2800 <Self::ReturnTuple<
2801 '_,
2802 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2803 .map(Into::into)
2804 }
2805 }
2806 };
2807 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2808 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2813 #[derive(Clone)]
2814 pub struct paused_0Call {
2815 #[allow(missing_docs)]
2816 pub index: u8,
2817 }
2818 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2819 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2821 #[derive(Clone)]
2822 pub struct paused_0Return {
2823 #[allow(missing_docs)]
2824 pub _0: bool,
2825 }
2826 #[allow(
2827 non_camel_case_types,
2828 non_snake_case,
2829 clippy::pub_underscore_fields,
2830 clippy::style
2831 )]
2832 const _: () = {
2833 use alloy::sol_types as alloy_sol_types;
2834 {
2835 #[doc(hidden)]
2836 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
2837 #[doc(hidden)]
2838 type UnderlyingRustTuple<'a> = (u8,);
2839 #[cfg(test)]
2840 #[allow(dead_code, unreachable_patterns)]
2841 fn _type_assertion(
2842 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2843 ) {
2844 match _t {
2845 alloy_sol_types::private::AssertTypeEq::<
2846 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2847 >(_) => {}
2848 }
2849 }
2850 #[automatically_derived]
2851 #[doc(hidden)]
2852 impl ::core::convert::From<paused_0Call> for UnderlyingRustTuple<'_> {
2853 fn from(value: paused_0Call) -> Self {
2854 (value.index,)
2855 }
2856 }
2857 #[automatically_derived]
2858 #[doc(hidden)]
2859 impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Call {
2860 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2861 Self { index: tuple.0 }
2862 }
2863 }
2864 }
2865 {
2866 #[doc(hidden)]
2867 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2868 #[doc(hidden)]
2869 type UnderlyingRustTuple<'a> = (bool,);
2870 #[cfg(test)]
2871 #[allow(dead_code, unreachable_patterns)]
2872 fn _type_assertion(
2873 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2874 ) {
2875 match _t {
2876 alloy_sol_types::private::AssertTypeEq::<
2877 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2878 >(_) => {}
2879 }
2880 }
2881 #[automatically_derived]
2882 #[doc(hidden)]
2883 impl ::core::convert::From<paused_0Return> for UnderlyingRustTuple<'_> {
2884 fn from(value: paused_0Return) -> Self {
2885 (value._0,)
2886 }
2887 }
2888 #[automatically_derived]
2889 #[doc(hidden)]
2890 impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Return {
2891 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2892 Self { _0: tuple.0 }
2893 }
2894 }
2895 }
2896 #[automatically_derived]
2897 impl alloy_sol_types::SolCall for paused_0Call {
2898 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
2899 type Token<'a> = <Self::Parameters<
2900 'a,
2901 > as alloy_sol_types::SolType>::Token<'a>;
2902 type Return = paused_0Return;
2903 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2904 type ReturnToken<'a> = <Self::ReturnTuple<
2905 'a,
2906 > as alloy_sol_types::SolType>::Token<'a>;
2907 const SIGNATURE: &'static str = "paused(uint8)";
2908 const SELECTOR: [u8; 4] = [90u8, 200u8, 106u8, 183u8];
2909 #[inline]
2910 fn new<'a>(
2911 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2912 ) -> Self {
2913 tuple.into()
2914 }
2915 #[inline]
2916 fn tokenize(&self) -> Self::Token<'_> {
2917 (
2918 <alloy::sol_types::sol_data::Uint<
2919 8,
2920 > as alloy_sol_types::SolType>::tokenize(&self.index),
2921 )
2922 }
2923 #[inline]
2924 fn abi_decode_returns(
2925 data: &[u8],
2926 validate: bool,
2927 ) -> alloy_sol_types::Result<Self::Return> {
2928 <Self::ReturnTuple<
2929 '_,
2930 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2931 .map(Into::into)
2932 }
2933 }
2934 };
2935 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2936 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2941 #[derive(Clone)]
2942 pub struct paused_1Call {}
2943 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2944 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2946 #[derive(Clone)]
2947 pub struct paused_1Return {
2948 #[allow(missing_docs)]
2949 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2950 }
2951 #[allow(
2952 non_camel_case_types,
2953 non_snake_case,
2954 clippy::pub_underscore_fields,
2955 clippy::style
2956 )]
2957 const _: () = {
2958 use alloy::sol_types as alloy_sol_types;
2959 {
2960 #[doc(hidden)]
2961 type UnderlyingSolTuple<'a> = ();
2962 #[doc(hidden)]
2963 type UnderlyingRustTuple<'a> = ();
2964 #[cfg(test)]
2965 #[allow(dead_code, unreachable_patterns)]
2966 fn _type_assertion(
2967 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2968 ) {
2969 match _t {
2970 alloy_sol_types::private::AssertTypeEq::<
2971 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2972 >(_) => {}
2973 }
2974 }
2975 #[automatically_derived]
2976 #[doc(hidden)]
2977 impl ::core::convert::From<paused_1Call> for UnderlyingRustTuple<'_> {
2978 fn from(value: paused_1Call) -> Self {
2979 ()
2980 }
2981 }
2982 #[automatically_derived]
2983 #[doc(hidden)]
2984 impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Call {
2985 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2986 Self {}
2987 }
2988 }
2989 }
2990 {
2991 #[doc(hidden)]
2992 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2993 #[doc(hidden)]
2994 type UnderlyingRustTuple<'a> = (
2995 alloy::sol_types::private::primitives::aliases::U256,
2996 );
2997 #[cfg(test)]
2998 #[allow(dead_code, unreachable_patterns)]
2999 fn _type_assertion(
3000 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3001 ) {
3002 match _t {
3003 alloy_sol_types::private::AssertTypeEq::<
3004 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3005 >(_) => {}
3006 }
3007 }
3008 #[automatically_derived]
3009 #[doc(hidden)]
3010 impl ::core::convert::From<paused_1Return> for UnderlyingRustTuple<'_> {
3011 fn from(value: paused_1Return) -> Self {
3012 (value._0,)
3013 }
3014 }
3015 #[automatically_derived]
3016 #[doc(hidden)]
3017 impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Return {
3018 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3019 Self { _0: tuple.0 }
3020 }
3021 }
3022 }
3023 #[automatically_derived]
3024 impl alloy_sol_types::SolCall for paused_1Call {
3025 type Parameters<'a> = ();
3026 type Token<'a> = <Self::Parameters<
3027 'a,
3028 > as alloy_sol_types::SolType>::Token<'a>;
3029 type Return = paused_1Return;
3030 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3031 type ReturnToken<'a> = <Self::ReturnTuple<
3032 'a,
3033 > as alloy_sol_types::SolType>::Token<'a>;
3034 const SIGNATURE: &'static str = "paused()";
3035 const SELECTOR: [u8; 4] = [92u8, 151u8, 90u8, 187u8];
3036 #[inline]
3037 fn new<'a>(
3038 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3039 ) -> Self {
3040 tuple.into()
3041 }
3042 #[inline]
3043 fn tokenize(&self) -> Self::Token<'_> {
3044 ()
3045 }
3046 #[inline]
3047 fn abi_decode_returns(
3048 data: &[u8],
3049 validate: bool,
3050 ) -> alloy_sol_types::Result<Self::Return> {
3051 <Self::ReturnTuple<
3052 '_,
3053 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3054 .map(Into::into)
3055 }
3056 }
3057 };
3058 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3059 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3064 #[derive(Clone)]
3065 pub struct pauserRegistryCall {}
3066 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3067 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3069 #[derive(Clone)]
3070 pub struct pauserRegistryReturn {
3071 #[allow(missing_docs)]
3072 pub _0: alloy::sol_types::private::Address,
3073 }
3074 #[allow(
3075 non_camel_case_types,
3076 non_snake_case,
3077 clippy::pub_underscore_fields,
3078 clippy::style
3079 )]
3080 const _: () = {
3081 use alloy::sol_types as alloy_sol_types;
3082 {
3083 #[doc(hidden)]
3084 type UnderlyingSolTuple<'a> = ();
3085 #[doc(hidden)]
3086 type UnderlyingRustTuple<'a> = ();
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<pauserRegistryCall> for UnderlyingRustTuple<'_> {
3101 fn from(value: pauserRegistryCall) -> Self {
3102 ()
3103 }
3104 }
3105 #[automatically_derived]
3106 #[doc(hidden)]
3107 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauserRegistryCall {
3108 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3109 Self {}
3110 }
3111 }
3112 }
3113 {
3114 #[doc(hidden)]
3115 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3116 #[doc(hidden)]
3117 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3118 #[cfg(test)]
3119 #[allow(dead_code, unreachable_patterns)]
3120 fn _type_assertion(
3121 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3122 ) {
3123 match _t {
3124 alloy_sol_types::private::AssertTypeEq::<
3125 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3126 >(_) => {}
3127 }
3128 }
3129 #[automatically_derived]
3130 #[doc(hidden)]
3131 impl ::core::convert::From<pauserRegistryReturn>
3132 for UnderlyingRustTuple<'_> {
3133 fn from(value: pauserRegistryReturn) -> Self {
3134 (value._0,)
3135 }
3136 }
3137 #[automatically_derived]
3138 #[doc(hidden)]
3139 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3140 for pauserRegistryReturn {
3141 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3142 Self { _0: tuple.0 }
3143 }
3144 }
3145 }
3146 #[automatically_derived]
3147 impl alloy_sol_types::SolCall for pauserRegistryCall {
3148 type Parameters<'a> = ();
3149 type Token<'a> = <Self::Parameters<
3150 'a,
3151 > as alloy_sol_types::SolType>::Token<'a>;
3152 type Return = pauserRegistryReturn;
3153 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3154 type ReturnToken<'a> = <Self::ReturnTuple<
3155 'a,
3156 > as alloy_sol_types::SolType>::Token<'a>;
3157 const SIGNATURE: &'static str = "pauserRegistry()";
3158 const SELECTOR: [u8; 4] = [136u8, 111u8, 17u8, 149u8];
3159 #[inline]
3160 fn new<'a>(
3161 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3162 ) -> Self {
3163 tuple.into()
3164 }
3165 #[inline]
3166 fn tokenize(&self) -> Self::Token<'_> {
3167 ()
3168 }
3169 #[inline]
3170 fn abi_decode_returns(
3171 data: &[u8],
3172 validate: bool,
3173 ) -> alloy_sol_types::Result<Self::Return> {
3174 <Self::ReturnTuple<
3175 '_,
3176 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3177 .map(Into::into)
3178 }
3179 }
3180 };
3181 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3182 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3187 #[derive(Clone)]
3188 pub struct sharesCall {
3189 #[allow(missing_docs)]
3190 pub user: alloy::sol_types::private::Address,
3191 }
3192 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3193 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3195 #[derive(Clone)]
3196 pub struct sharesReturn {
3197 #[allow(missing_docs)]
3198 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3199 }
3200 #[allow(
3201 non_camel_case_types,
3202 non_snake_case,
3203 clippy::pub_underscore_fields,
3204 clippy::style
3205 )]
3206 const _: () = {
3207 use alloy::sol_types as alloy_sol_types;
3208 {
3209 #[doc(hidden)]
3210 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3211 #[doc(hidden)]
3212 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3213 #[cfg(test)]
3214 #[allow(dead_code, unreachable_patterns)]
3215 fn _type_assertion(
3216 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3217 ) {
3218 match _t {
3219 alloy_sol_types::private::AssertTypeEq::<
3220 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3221 >(_) => {}
3222 }
3223 }
3224 #[automatically_derived]
3225 #[doc(hidden)]
3226 impl ::core::convert::From<sharesCall> for UnderlyingRustTuple<'_> {
3227 fn from(value: sharesCall) -> Self {
3228 (value.user,)
3229 }
3230 }
3231 #[automatically_derived]
3232 #[doc(hidden)]
3233 impl ::core::convert::From<UnderlyingRustTuple<'_>> for sharesCall {
3234 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3235 Self { user: tuple.0 }
3236 }
3237 }
3238 }
3239 {
3240 #[doc(hidden)]
3241 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3242 #[doc(hidden)]
3243 type UnderlyingRustTuple<'a> = (
3244 alloy::sol_types::private::primitives::aliases::U256,
3245 );
3246 #[cfg(test)]
3247 #[allow(dead_code, unreachable_patterns)]
3248 fn _type_assertion(
3249 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3250 ) {
3251 match _t {
3252 alloy_sol_types::private::AssertTypeEq::<
3253 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3254 >(_) => {}
3255 }
3256 }
3257 #[automatically_derived]
3258 #[doc(hidden)]
3259 impl ::core::convert::From<sharesReturn> for UnderlyingRustTuple<'_> {
3260 fn from(value: sharesReturn) -> Self {
3261 (value._0,)
3262 }
3263 }
3264 #[automatically_derived]
3265 #[doc(hidden)]
3266 impl ::core::convert::From<UnderlyingRustTuple<'_>> for sharesReturn {
3267 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3268 Self { _0: tuple.0 }
3269 }
3270 }
3271 }
3272 #[automatically_derived]
3273 impl alloy_sol_types::SolCall for sharesCall {
3274 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3275 type Token<'a> = <Self::Parameters<
3276 'a,
3277 > as alloy_sol_types::SolType>::Token<'a>;
3278 type Return = sharesReturn;
3279 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3280 type ReturnToken<'a> = <Self::ReturnTuple<
3281 'a,
3282 > as alloy_sol_types::SolType>::Token<'a>;
3283 const SIGNATURE: &'static str = "shares(address)";
3284 const SELECTOR: [u8; 4] = [206u8, 124u8, 42u8, 194u8];
3285 #[inline]
3286 fn new<'a>(
3287 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3288 ) -> Self {
3289 tuple.into()
3290 }
3291 #[inline]
3292 fn tokenize(&self) -> Self::Token<'_> {
3293 (
3294 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3295 &self.user,
3296 ),
3297 )
3298 }
3299 #[inline]
3300 fn abi_decode_returns(
3301 data: &[u8],
3302 validate: bool,
3303 ) -> alloy_sol_types::Result<Self::Return> {
3304 <Self::ReturnTuple<
3305 '_,
3306 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3307 .map(Into::into)
3308 }
3309 }
3310 };
3311 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3312 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3317 #[derive(Clone)]
3318 pub struct sharesToUnderlyingCall {
3319 #[allow(missing_docs)]
3320 pub amountShares: alloy::sol_types::private::primitives::aliases::U256,
3321 }
3322 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3323 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3325 #[derive(Clone)]
3326 pub struct sharesToUnderlyingReturn {
3327 #[allow(missing_docs)]
3328 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3329 }
3330 #[allow(
3331 non_camel_case_types,
3332 non_snake_case,
3333 clippy::pub_underscore_fields,
3334 clippy::style
3335 )]
3336 const _: () = {
3337 use alloy::sol_types as alloy_sol_types;
3338 {
3339 #[doc(hidden)]
3340 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3341 #[doc(hidden)]
3342 type UnderlyingRustTuple<'a> = (
3343 alloy::sol_types::private::primitives::aliases::U256,
3344 );
3345 #[cfg(test)]
3346 #[allow(dead_code, unreachable_patterns)]
3347 fn _type_assertion(
3348 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3349 ) {
3350 match _t {
3351 alloy_sol_types::private::AssertTypeEq::<
3352 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3353 >(_) => {}
3354 }
3355 }
3356 #[automatically_derived]
3357 #[doc(hidden)]
3358 impl ::core::convert::From<sharesToUnderlyingCall>
3359 for UnderlyingRustTuple<'_> {
3360 fn from(value: sharesToUnderlyingCall) -> Self {
3361 (value.amountShares,)
3362 }
3363 }
3364 #[automatically_derived]
3365 #[doc(hidden)]
3366 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3367 for sharesToUnderlyingCall {
3368 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3369 Self { amountShares: tuple.0 }
3370 }
3371 }
3372 }
3373 {
3374 #[doc(hidden)]
3375 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3376 #[doc(hidden)]
3377 type UnderlyingRustTuple<'a> = (
3378 alloy::sol_types::private::primitives::aliases::U256,
3379 );
3380 #[cfg(test)]
3381 #[allow(dead_code, unreachable_patterns)]
3382 fn _type_assertion(
3383 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3384 ) {
3385 match _t {
3386 alloy_sol_types::private::AssertTypeEq::<
3387 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3388 >(_) => {}
3389 }
3390 }
3391 #[automatically_derived]
3392 #[doc(hidden)]
3393 impl ::core::convert::From<sharesToUnderlyingReturn>
3394 for UnderlyingRustTuple<'_> {
3395 fn from(value: sharesToUnderlyingReturn) -> Self {
3396 (value._0,)
3397 }
3398 }
3399 #[automatically_derived]
3400 #[doc(hidden)]
3401 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3402 for sharesToUnderlyingReturn {
3403 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3404 Self { _0: tuple.0 }
3405 }
3406 }
3407 }
3408 #[automatically_derived]
3409 impl alloy_sol_types::SolCall for sharesToUnderlyingCall {
3410 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3411 type Token<'a> = <Self::Parameters<
3412 'a,
3413 > as alloy_sol_types::SolType>::Token<'a>;
3414 type Return = sharesToUnderlyingReturn;
3415 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3416 type ReturnToken<'a> = <Self::ReturnTuple<
3417 'a,
3418 > as alloy_sol_types::SolType>::Token<'a>;
3419 const SIGNATURE: &'static str = "sharesToUnderlying(uint256)";
3420 const SELECTOR: [u8; 4] = [243u8, 231u8, 56u8, 117u8];
3421 #[inline]
3422 fn new<'a>(
3423 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3424 ) -> Self {
3425 tuple.into()
3426 }
3427 #[inline]
3428 fn tokenize(&self) -> Self::Token<'_> {
3429 (
3430 <alloy::sol_types::sol_data::Uint<
3431 256,
3432 > as alloy_sol_types::SolType>::tokenize(&self.amountShares),
3433 )
3434 }
3435 #[inline]
3436 fn abi_decode_returns(
3437 data: &[u8],
3438 validate: bool,
3439 ) -> alloy_sol_types::Result<Self::Return> {
3440 <Self::ReturnTuple<
3441 '_,
3442 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3443 .map(Into::into)
3444 }
3445 }
3446 };
3447 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3448 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3453 #[derive(Clone)]
3454 pub struct sharesToUnderlyingViewCall {
3455 #[allow(missing_docs)]
3456 pub amountShares: alloy::sol_types::private::primitives::aliases::U256,
3457 }
3458 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3459 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3461 #[derive(Clone)]
3462 pub struct sharesToUnderlyingViewReturn {
3463 #[allow(missing_docs)]
3464 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3465 }
3466 #[allow(
3467 non_camel_case_types,
3468 non_snake_case,
3469 clippy::pub_underscore_fields,
3470 clippy::style
3471 )]
3472 const _: () = {
3473 use alloy::sol_types as alloy_sol_types;
3474 {
3475 #[doc(hidden)]
3476 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3477 #[doc(hidden)]
3478 type UnderlyingRustTuple<'a> = (
3479 alloy::sol_types::private::primitives::aliases::U256,
3480 );
3481 #[cfg(test)]
3482 #[allow(dead_code, unreachable_patterns)]
3483 fn _type_assertion(
3484 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3485 ) {
3486 match _t {
3487 alloy_sol_types::private::AssertTypeEq::<
3488 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3489 >(_) => {}
3490 }
3491 }
3492 #[automatically_derived]
3493 #[doc(hidden)]
3494 impl ::core::convert::From<sharesToUnderlyingViewCall>
3495 for UnderlyingRustTuple<'_> {
3496 fn from(value: sharesToUnderlyingViewCall) -> Self {
3497 (value.amountShares,)
3498 }
3499 }
3500 #[automatically_derived]
3501 #[doc(hidden)]
3502 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3503 for sharesToUnderlyingViewCall {
3504 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3505 Self { amountShares: tuple.0 }
3506 }
3507 }
3508 }
3509 {
3510 #[doc(hidden)]
3511 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3512 #[doc(hidden)]
3513 type UnderlyingRustTuple<'a> = (
3514 alloy::sol_types::private::primitives::aliases::U256,
3515 );
3516 #[cfg(test)]
3517 #[allow(dead_code, unreachable_patterns)]
3518 fn _type_assertion(
3519 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3520 ) {
3521 match _t {
3522 alloy_sol_types::private::AssertTypeEq::<
3523 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3524 >(_) => {}
3525 }
3526 }
3527 #[automatically_derived]
3528 #[doc(hidden)]
3529 impl ::core::convert::From<sharesToUnderlyingViewReturn>
3530 for UnderlyingRustTuple<'_> {
3531 fn from(value: sharesToUnderlyingViewReturn) -> Self {
3532 (value._0,)
3533 }
3534 }
3535 #[automatically_derived]
3536 #[doc(hidden)]
3537 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3538 for sharesToUnderlyingViewReturn {
3539 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3540 Self { _0: tuple.0 }
3541 }
3542 }
3543 }
3544 #[automatically_derived]
3545 impl alloy_sol_types::SolCall for sharesToUnderlyingViewCall {
3546 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3547 type Token<'a> = <Self::Parameters<
3548 'a,
3549 > as alloy_sol_types::SolType>::Token<'a>;
3550 type Return = sharesToUnderlyingViewReturn;
3551 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3552 type ReturnToken<'a> = <Self::ReturnTuple<
3553 'a,
3554 > as alloy_sol_types::SolType>::Token<'a>;
3555 const SIGNATURE: &'static str = "sharesToUnderlyingView(uint256)";
3556 const SELECTOR: [u8; 4] = [122u8, 139u8, 38u8, 55u8];
3557 #[inline]
3558 fn new<'a>(
3559 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3560 ) -> Self {
3561 tuple.into()
3562 }
3563 #[inline]
3564 fn tokenize(&self) -> Self::Token<'_> {
3565 (
3566 <alloy::sol_types::sol_data::Uint<
3567 256,
3568 > as alloy_sol_types::SolType>::tokenize(&self.amountShares),
3569 )
3570 }
3571 #[inline]
3572 fn abi_decode_returns(
3573 data: &[u8],
3574 validate: bool,
3575 ) -> alloy_sol_types::Result<Self::Return> {
3576 <Self::ReturnTuple<
3577 '_,
3578 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3579 .map(Into::into)
3580 }
3581 }
3582 };
3583 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3584 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3589 #[derive(Clone)]
3590 pub struct strategyManagerCall {}
3591 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3592 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3594 #[derive(Clone)]
3595 pub struct strategyManagerReturn {
3596 #[allow(missing_docs)]
3597 pub _0: alloy::sol_types::private::Address,
3598 }
3599 #[allow(
3600 non_camel_case_types,
3601 non_snake_case,
3602 clippy::pub_underscore_fields,
3603 clippy::style
3604 )]
3605 const _: () = {
3606 use alloy::sol_types as alloy_sol_types;
3607 {
3608 #[doc(hidden)]
3609 type UnderlyingSolTuple<'a> = ();
3610 #[doc(hidden)]
3611 type UnderlyingRustTuple<'a> = ();
3612 #[cfg(test)]
3613 #[allow(dead_code, unreachable_patterns)]
3614 fn _type_assertion(
3615 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3616 ) {
3617 match _t {
3618 alloy_sol_types::private::AssertTypeEq::<
3619 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3620 >(_) => {}
3621 }
3622 }
3623 #[automatically_derived]
3624 #[doc(hidden)]
3625 impl ::core::convert::From<strategyManagerCall> for UnderlyingRustTuple<'_> {
3626 fn from(value: strategyManagerCall) -> Self {
3627 ()
3628 }
3629 }
3630 #[automatically_derived]
3631 #[doc(hidden)]
3632 impl ::core::convert::From<UnderlyingRustTuple<'_>> for strategyManagerCall {
3633 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3634 Self {}
3635 }
3636 }
3637 }
3638 {
3639 #[doc(hidden)]
3640 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3641 #[doc(hidden)]
3642 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3643 #[cfg(test)]
3644 #[allow(dead_code, unreachable_patterns)]
3645 fn _type_assertion(
3646 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3647 ) {
3648 match _t {
3649 alloy_sol_types::private::AssertTypeEq::<
3650 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3651 >(_) => {}
3652 }
3653 }
3654 #[automatically_derived]
3655 #[doc(hidden)]
3656 impl ::core::convert::From<strategyManagerReturn>
3657 for UnderlyingRustTuple<'_> {
3658 fn from(value: strategyManagerReturn) -> Self {
3659 (value._0,)
3660 }
3661 }
3662 #[automatically_derived]
3663 #[doc(hidden)]
3664 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3665 for strategyManagerReturn {
3666 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3667 Self { _0: tuple.0 }
3668 }
3669 }
3670 }
3671 #[automatically_derived]
3672 impl alloy_sol_types::SolCall for strategyManagerCall {
3673 type Parameters<'a> = ();
3674 type Token<'a> = <Self::Parameters<
3675 'a,
3676 > as alloy_sol_types::SolType>::Token<'a>;
3677 type Return = strategyManagerReturn;
3678 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3679 type ReturnToken<'a> = <Self::ReturnTuple<
3680 'a,
3681 > as alloy_sol_types::SolType>::Token<'a>;
3682 const SIGNATURE: &'static str = "strategyManager()";
3683 const SELECTOR: [u8; 4] = [57u8, 183u8, 14u8, 56u8];
3684 #[inline]
3685 fn new<'a>(
3686 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3687 ) -> Self {
3688 tuple.into()
3689 }
3690 #[inline]
3691 fn tokenize(&self) -> Self::Token<'_> {
3692 ()
3693 }
3694 #[inline]
3695 fn abi_decode_returns(
3696 data: &[u8],
3697 validate: bool,
3698 ) -> alloy_sol_types::Result<Self::Return> {
3699 <Self::ReturnTuple<
3700 '_,
3701 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3702 .map(Into::into)
3703 }
3704 }
3705 };
3706 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3707 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3712 #[derive(Clone)]
3713 pub struct totalSharesCall {}
3714 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3715 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3717 #[derive(Clone)]
3718 pub struct totalSharesReturn {
3719 #[allow(missing_docs)]
3720 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3721 }
3722 #[allow(
3723 non_camel_case_types,
3724 non_snake_case,
3725 clippy::pub_underscore_fields,
3726 clippy::style
3727 )]
3728 const _: () = {
3729 use alloy::sol_types as alloy_sol_types;
3730 {
3731 #[doc(hidden)]
3732 type UnderlyingSolTuple<'a> = ();
3733 #[doc(hidden)]
3734 type UnderlyingRustTuple<'a> = ();
3735 #[cfg(test)]
3736 #[allow(dead_code, unreachable_patterns)]
3737 fn _type_assertion(
3738 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3739 ) {
3740 match _t {
3741 alloy_sol_types::private::AssertTypeEq::<
3742 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3743 >(_) => {}
3744 }
3745 }
3746 #[automatically_derived]
3747 #[doc(hidden)]
3748 impl ::core::convert::From<totalSharesCall> for UnderlyingRustTuple<'_> {
3749 fn from(value: totalSharesCall) -> Self {
3750 ()
3751 }
3752 }
3753 #[automatically_derived]
3754 #[doc(hidden)]
3755 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSharesCall {
3756 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3757 Self {}
3758 }
3759 }
3760 }
3761 {
3762 #[doc(hidden)]
3763 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3764 #[doc(hidden)]
3765 type UnderlyingRustTuple<'a> = (
3766 alloy::sol_types::private::primitives::aliases::U256,
3767 );
3768 #[cfg(test)]
3769 #[allow(dead_code, unreachable_patterns)]
3770 fn _type_assertion(
3771 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3772 ) {
3773 match _t {
3774 alloy_sol_types::private::AssertTypeEq::<
3775 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3776 >(_) => {}
3777 }
3778 }
3779 #[automatically_derived]
3780 #[doc(hidden)]
3781 impl ::core::convert::From<totalSharesReturn> for UnderlyingRustTuple<'_> {
3782 fn from(value: totalSharesReturn) -> Self {
3783 (value._0,)
3784 }
3785 }
3786 #[automatically_derived]
3787 #[doc(hidden)]
3788 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSharesReturn {
3789 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3790 Self { _0: tuple.0 }
3791 }
3792 }
3793 }
3794 #[automatically_derived]
3795 impl alloy_sol_types::SolCall for totalSharesCall {
3796 type Parameters<'a> = ();
3797 type Token<'a> = <Self::Parameters<
3798 'a,
3799 > as alloy_sol_types::SolType>::Token<'a>;
3800 type Return = totalSharesReturn;
3801 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3802 type ReturnToken<'a> = <Self::ReturnTuple<
3803 'a,
3804 > as alloy_sol_types::SolType>::Token<'a>;
3805 const SIGNATURE: &'static str = "totalShares()";
3806 const SELECTOR: [u8; 4] = [58u8, 152u8, 239u8, 57u8];
3807 #[inline]
3808 fn new<'a>(
3809 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3810 ) -> Self {
3811 tuple.into()
3812 }
3813 #[inline]
3814 fn tokenize(&self) -> Self::Token<'_> {
3815 ()
3816 }
3817 #[inline]
3818 fn abi_decode_returns(
3819 data: &[u8],
3820 validate: bool,
3821 ) -> alloy_sol_types::Result<Self::Return> {
3822 <Self::ReturnTuple<
3823 '_,
3824 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3825 .map(Into::into)
3826 }
3827 }
3828 };
3829 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3830 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3835 #[derive(Clone)]
3836 pub struct underlyingToSharesCall {
3837 #[allow(missing_docs)]
3838 pub amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
3839 }
3840 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3841 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3843 #[derive(Clone)]
3844 pub struct underlyingToSharesReturn {
3845 #[allow(missing_docs)]
3846 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3847 }
3848 #[allow(
3849 non_camel_case_types,
3850 non_snake_case,
3851 clippy::pub_underscore_fields,
3852 clippy::style
3853 )]
3854 const _: () = {
3855 use alloy::sol_types as alloy_sol_types;
3856 {
3857 #[doc(hidden)]
3858 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3859 #[doc(hidden)]
3860 type UnderlyingRustTuple<'a> = (
3861 alloy::sol_types::private::primitives::aliases::U256,
3862 );
3863 #[cfg(test)]
3864 #[allow(dead_code, unreachable_patterns)]
3865 fn _type_assertion(
3866 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3867 ) {
3868 match _t {
3869 alloy_sol_types::private::AssertTypeEq::<
3870 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3871 >(_) => {}
3872 }
3873 }
3874 #[automatically_derived]
3875 #[doc(hidden)]
3876 impl ::core::convert::From<underlyingToSharesCall>
3877 for UnderlyingRustTuple<'_> {
3878 fn from(value: underlyingToSharesCall) -> Self {
3879 (value.amountUnderlying,)
3880 }
3881 }
3882 #[automatically_derived]
3883 #[doc(hidden)]
3884 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3885 for underlyingToSharesCall {
3886 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3887 Self { amountUnderlying: tuple.0 }
3888 }
3889 }
3890 }
3891 {
3892 #[doc(hidden)]
3893 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3894 #[doc(hidden)]
3895 type UnderlyingRustTuple<'a> = (
3896 alloy::sol_types::private::primitives::aliases::U256,
3897 );
3898 #[cfg(test)]
3899 #[allow(dead_code, unreachable_patterns)]
3900 fn _type_assertion(
3901 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3902 ) {
3903 match _t {
3904 alloy_sol_types::private::AssertTypeEq::<
3905 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3906 >(_) => {}
3907 }
3908 }
3909 #[automatically_derived]
3910 #[doc(hidden)]
3911 impl ::core::convert::From<underlyingToSharesReturn>
3912 for UnderlyingRustTuple<'_> {
3913 fn from(value: underlyingToSharesReturn) -> Self {
3914 (value._0,)
3915 }
3916 }
3917 #[automatically_derived]
3918 #[doc(hidden)]
3919 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3920 for underlyingToSharesReturn {
3921 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3922 Self { _0: tuple.0 }
3923 }
3924 }
3925 }
3926 #[automatically_derived]
3927 impl alloy_sol_types::SolCall for underlyingToSharesCall {
3928 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3929 type Token<'a> = <Self::Parameters<
3930 'a,
3931 > as alloy_sol_types::SolType>::Token<'a>;
3932 type Return = underlyingToSharesReturn;
3933 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3934 type ReturnToken<'a> = <Self::ReturnTuple<
3935 'a,
3936 > as alloy_sol_types::SolType>::Token<'a>;
3937 const SIGNATURE: &'static str = "underlyingToShares(uint256)";
3938 const SELECTOR: [u8; 4] = [140u8, 135u8, 16u8, 25u8];
3939 #[inline]
3940 fn new<'a>(
3941 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3942 ) -> Self {
3943 tuple.into()
3944 }
3945 #[inline]
3946 fn tokenize(&self) -> Self::Token<'_> {
3947 (
3948 <alloy::sol_types::sol_data::Uint<
3949 256,
3950 > as alloy_sol_types::SolType>::tokenize(&self.amountUnderlying),
3951 )
3952 }
3953 #[inline]
3954 fn abi_decode_returns(
3955 data: &[u8],
3956 validate: bool,
3957 ) -> alloy_sol_types::Result<Self::Return> {
3958 <Self::ReturnTuple<
3959 '_,
3960 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3961 .map(Into::into)
3962 }
3963 }
3964 };
3965 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3966 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3971 #[derive(Clone)]
3972 pub struct underlyingToSharesViewCall {
3973 #[allow(missing_docs)]
3974 pub amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
3975 }
3976 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3977 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3979 #[derive(Clone)]
3980 pub struct underlyingToSharesViewReturn {
3981 #[allow(missing_docs)]
3982 pub _0: alloy::sol_types::private::primitives::aliases::U256,
3983 }
3984 #[allow(
3985 non_camel_case_types,
3986 non_snake_case,
3987 clippy::pub_underscore_fields,
3988 clippy::style
3989 )]
3990 const _: () = {
3991 use alloy::sol_types as alloy_sol_types;
3992 {
3993 #[doc(hidden)]
3994 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3995 #[doc(hidden)]
3996 type UnderlyingRustTuple<'a> = (
3997 alloy::sol_types::private::primitives::aliases::U256,
3998 );
3999 #[cfg(test)]
4000 #[allow(dead_code, unreachable_patterns)]
4001 fn _type_assertion(
4002 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4003 ) {
4004 match _t {
4005 alloy_sol_types::private::AssertTypeEq::<
4006 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4007 >(_) => {}
4008 }
4009 }
4010 #[automatically_derived]
4011 #[doc(hidden)]
4012 impl ::core::convert::From<underlyingToSharesViewCall>
4013 for UnderlyingRustTuple<'_> {
4014 fn from(value: underlyingToSharesViewCall) -> Self {
4015 (value.amountUnderlying,)
4016 }
4017 }
4018 #[automatically_derived]
4019 #[doc(hidden)]
4020 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4021 for underlyingToSharesViewCall {
4022 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4023 Self { amountUnderlying: tuple.0 }
4024 }
4025 }
4026 }
4027 {
4028 #[doc(hidden)]
4029 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4030 #[doc(hidden)]
4031 type UnderlyingRustTuple<'a> = (
4032 alloy::sol_types::private::primitives::aliases::U256,
4033 );
4034 #[cfg(test)]
4035 #[allow(dead_code, unreachable_patterns)]
4036 fn _type_assertion(
4037 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4038 ) {
4039 match _t {
4040 alloy_sol_types::private::AssertTypeEq::<
4041 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4042 >(_) => {}
4043 }
4044 }
4045 #[automatically_derived]
4046 #[doc(hidden)]
4047 impl ::core::convert::From<underlyingToSharesViewReturn>
4048 for UnderlyingRustTuple<'_> {
4049 fn from(value: underlyingToSharesViewReturn) -> Self {
4050 (value._0,)
4051 }
4052 }
4053 #[automatically_derived]
4054 #[doc(hidden)]
4055 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4056 for underlyingToSharesViewReturn {
4057 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4058 Self { _0: tuple.0 }
4059 }
4060 }
4061 }
4062 #[automatically_derived]
4063 impl alloy_sol_types::SolCall for underlyingToSharesViewCall {
4064 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4065 type Token<'a> = <Self::Parameters<
4066 'a,
4067 > as alloy_sol_types::SolType>::Token<'a>;
4068 type Return = underlyingToSharesViewReturn;
4069 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4070 type ReturnToken<'a> = <Self::ReturnTuple<
4071 'a,
4072 > as alloy_sol_types::SolType>::Token<'a>;
4073 const SIGNATURE: &'static str = "underlyingToSharesView(uint256)";
4074 const SELECTOR: [u8; 4] = [227u8, 218u8, 229u8, 28u8];
4075 #[inline]
4076 fn new<'a>(
4077 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4078 ) -> Self {
4079 tuple.into()
4080 }
4081 #[inline]
4082 fn tokenize(&self) -> Self::Token<'_> {
4083 (
4084 <alloy::sol_types::sol_data::Uint<
4085 256,
4086 > as alloy_sol_types::SolType>::tokenize(&self.amountUnderlying),
4087 )
4088 }
4089 #[inline]
4090 fn abi_decode_returns(
4091 data: &[u8],
4092 validate: bool,
4093 ) -> alloy_sol_types::Result<Self::Return> {
4094 <Self::ReturnTuple<
4095 '_,
4096 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4097 .map(Into::into)
4098 }
4099 }
4100 };
4101 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4102 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4107 #[derive(Clone)]
4108 pub struct underlyingTokenCall {}
4109 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4110 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4112 #[derive(Clone)]
4113 pub struct underlyingTokenReturn {
4114 #[allow(missing_docs)]
4115 pub _0: alloy::sol_types::private::Address,
4116 }
4117 #[allow(
4118 non_camel_case_types,
4119 non_snake_case,
4120 clippy::pub_underscore_fields,
4121 clippy::style
4122 )]
4123 const _: () = {
4124 use alloy::sol_types as alloy_sol_types;
4125 {
4126 #[doc(hidden)]
4127 type UnderlyingSolTuple<'a> = ();
4128 #[doc(hidden)]
4129 type UnderlyingRustTuple<'a> = ();
4130 #[cfg(test)]
4131 #[allow(dead_code, unreachable_patterns)]
4132 fn _type_assertion(
4133 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4134 ) {
4135 match _t {
4136 alloy_sol_types::private::AssertTypeEq::<
4137 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4138 >(_) => {}
4139 }
4140 }
4141 #[automatically_derived]
4142 #[doc(hidden)]
4143 impl ::core::convert::From<underlyingTokenCall> for UnderlyingRustTuple<'_> {
4144 fn from(value: underlyingTokenCall) -> Self {
4145 ()
4146 }
4147 }
4148 #[automatically_derived]
4149 #[doc(hidden)]
4150 impl ::core::convert::From<UnderlyingRustTuple<'_>> for underlyingTokenCall {
4151 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4152 Self {}
4153 }
4154 }
4155 }
4156 {
4157 #[doc(hidden)]
4158 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4159 #[doc(hidden)]
4160 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4161 #[cfg(test)]
4162 #[allow(dead_code, unreachable_patterns)]
4163 fn _type_assertion(
4164 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4165 ) {
4166 match _t {
4167 alloy_sol_types::private::AssertTypeEq::<
4168 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4169 >(_) => {}
4170 }
4171 }
4172 #[automatically_derived]
4173 #[doc(hidden)]
4174 impl ::core::convert::From<underlyingTokenReturn>
4175 for UnderlyingRustTuple<'_> {
4176 fn from(value: underlyingTokenReturn) -> Self {
4177 (value._0,)
4178 }
4179 }
4180 #[automatically_derived]
4181 #[doc(hidden)]
4182 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4183 for underlyingTokenReturn {
4184 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4185 Self { _0: tuple.0 }
4186 }
4187 }
4188 }
4189 #[automatically_derived]
4190 impl alloy_sol_types::SolCall for underlyingTokenCall {
4191 type Parameters<'a> = ();
4192 type Token<'a> = <Self::Parameters<
4193 'a,
4194 > as alloy_sol_types::SolType>::Token<'a>;
4195 type Return = underlyingTokenReturn;
4196 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
4197 type ReturnToken<'a> = <Self::ReturnTuple<
4198 'a,
4199 > as alloy_sol_types::SolType>::Token<'a>;
4200 const SIGNATURE: &'static str = "underlyingToken()";
4201 const SELECTOR: [u8; 4] = [36u8, 149u8, 165u8, 153u8];
4202 #[inline]
4203 fn new<'a>(
4204 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4205 ) -> Self {
4206 tuple.into()
4207 }
4208 #[inline]
4209 fn tokenize(&self) -> Self::Token<'_> {
4210 ()
4211 }
4212 #[inline]
4213 fn abi_decode_returns(
4214 data: &[u8],
4215 validate: bool,
4216 ) -> alloy_sol_types::Result<Self::Return> {
4217 <Self::ReturnTuple<
4218 '_,
4219 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4220 .map(Into::into)
4221 }
4222 }
4223 };
4224 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4225 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4230 #[derive(Clone)]
4231 pub struct unpauseCall {
4232 #[allow(missing_docs)]
4233 pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
4234 }
4235 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4237 #[derive(Clone)]
4238 pub struct unpauseReturn {}
4239 #[allow(
4240 non_camel_case_types,
4241 non_snake_case,
4242 clippy::pub_underscore_fields,
4243 clippy::style
4244 )]
4245 const _: () = {
4246 use alloy::sol_types as alloy_sol_types;
4247 {
4248 #[doc(hidden)]
4249 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4250 #[doc(hidden)]
4251 type UnderlyingRustTuple<'a> = (
4252 alloy::sol_types::private::primitives::aliases::U256,
4253 );
4254 #[cfg(test)]
4255 #[allow(dead_code, unreachable_patterns)]
4256 fn _type_assertion(
4257 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4258 ) {
4259 match _t {
4260 alloy_sol_types::private::AssertTypeEq::<
4261 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4262 >(_) => {}
4263 }
4264 }
4265 #[automatically_derived]
4266 #[doc(hidden)]
4267 impl ::core::convert::From<unpauseCall> for UnderlyingRustTuple<'_> {
4268 fn from(value: unpauseCall) -> Self {
4269 (value.newPausedStatus,)
4270 }
4271 }
4272 #[automatically_derived]
4273 #[doc(hidden)]
4274 impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseCall {
4275 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4276 Self { newPausedStatus: tuple.0 }
4277 }
4278 }
4279 }
4280 {
4281 #[doc(hidden)]
4282 type UnderlyingSolTuple<'a> = ();
4283 #[doc(hidden)]
4284 type UnderlyingRustTuple<'a> = ();
4285 #[cfg(test)]
4286 #[allow(dead_code, unreachable_patterns)]
4287 fn _type_assertion(
4288 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4289 ) {
4290 match _t {
4291 alloy_sol_types::private::AssertTypeEq::<
4292 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4293 >(_) => {}
4294 }
4295 }
4296 #[automatically_derived]
4297 #[doc(hidden)]
4298 impl ::core::convert::From<unpauseReturn> for UnderlyingRustTuple<'_> {
4299 fn from(value: unpauseReturn) -> Self {
4300 ()
4301 }
4302 }
4303 #[automatically_derived]
4304 #[doc(hidden)]
4305 impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseReturn {
4306 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4307 Self {}
4308 }
4309 }
4310 }
4311 #[automatically_derived]
4312 impl alloy_sol_types::SolCall for unpauseCall {
4313 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4314 type Token<'a> = <Self::Parameters<
4315 'a,
4316 > as alloy_sol_types::SolType>::Token<'a>;
4317 type Return = unpauseReturn;
4318 type ReturnTuple<'a> = ();
4319 type ReturnToken<'a> = <Self::ReturnTuple<
4320 'a,
4321 > as alloy_sol_types::SolType>::Token<'a>;
4322 const SIGNATURE: &'static str = "unpause(uint256)";
4323 const SELECTOR: [u8; 4] = [250u8, 188u8, 28u8, 188u8];
4324 #[inline]
4325 fn new<'a>(
4326 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4327 ) -> Self {
4328 tuple.into()
4329 }
4330 #[inline]
4331 fn tokenize(&self) -> Self::Token<'_> {
4332 (
4333 <alloy::sol_types::sol_data::Uint<
4334 256,
4335 > as alloy_sol_types::SolType>::tokenize(&self.newPausedStatus),
4336 )
4337 }
4338 #[inline]
4339 fn abi_decode_returns(
4340 data: &[u8],
4341 validate: bool,
4342 ) -> alloy_sol_types::Result<Self::Return> {
4343 <Self::ReturnTuple<
4344 '_,
4345 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4346 .map(Into::into)
4347 }
4348 }
4349 };
4350 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4351 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4356 #[derive(Clone)]
4357 pub struct userUnderlyingCall {
4358 #[allow(missing_docs)]
4359 pub user: alloy::sol_types::private::Address,
4360 }
4361 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4362 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4364 #[derive(Clone)]
4365 pub struct userUnderlyingReturn {
4366 #[allow(missing_docs)]
4367 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4368 }
4369 #[allow(
4370 non_camel_case_types,
4371 non_snake_case,
4372 clippy::pub_underscore_fields,
4373 clippy::style
4374 )]
4375 const _: () = {
4376 use alloy::sol_types as alloy_sol_types;
4377 {
4378 #[doc(hidden)]
4379 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4380 #[doc(hidden)]
4381 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4382 #[cfg(test)]
4383 #[allow(dead_code, unreachable_patterns)]
4384 fn _type_assertion(
4385 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4386 ) {
4387 match _t {
4388 alloy_sol_types::private::AssertTypeEq::<
4389 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4390 >(_) => {}
4391 }
4392 }
4393 #[automatically_derived]
4394 #[doc(hidden)]
4395 impl ::core::convert::From<userUnderlyingCall> for UnderlyingRustTuple<'_> {
4396 fn from(value: userUnderlyingCall) -> Self {
4397 (value.user,)
4398 }
4399 }
4400 #[automatically_derived]
4401 #[doc(hidden)]
4402 impl ::core::convert::From<UnderlyingRustTuple<'_>> for userUnderlyingCall {
4403 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4404 Self { user: tuple.0 }
4405 }
4406 }
4407 }
4408 {
4409 #[doc(hidden)]
4410 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4411 #[doc(hidden)]
4412 type UnderlyingRustTuple<'a> = (
4413 alloy::sol_types::private::primitives::aliases::U256,
4414 );
4415 #[cfg(test)]
4416 #[allow(dead_code, unreachable_patterns)]
4417 fn _type_assertion(
4418 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4419 ) {
4420 match _t {
4421 alloy_sol_types::private::AssertTypeEq::<
4422 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4423 >(_) => {}
4424 }
4425 }
4426 #[automatically_derived]
4427 #[doc(hidden)]
4428 impl ::core::convert::From<userUnderlyingReturn>
4429 for UnderlyingRustTuple<'_> {
4430 fn from(value: userUnderlyingReturn) -> Self {
4431 (value._0,)
4432 }
4433 }
4434 #[automatically_derived]
4435 #[doc(hidden)]
4436 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4437 for userUnderlyingReturn {
4438 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4439 Self { _0: tuple.0 }
4440 }
4441 }
4442 }
4443 #[automatically_derived]
4444 impl alloy_sol_types::SolCall for userUnderlyingCall {
4445 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4446 type Token<'a> = <Self::Parameters<
4447 'a,
4448 > as alloy_sol_types::SolType>::Token<'a>;
4449 type Return = userUnderlyingReturn;
4450 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4451 type ReturnToken<'a> = <Self::ReturnTuple<
4452 'a,
4453 > as alloy_sol_types::SolType>::Token<'a>;
4454 const SIGNATURE: &'static str = "userUnderlying(address)";
4455 const SELECTOR: [u8; 4] = [143u8, 106u8, 98u8, 64u8];
4456 #[inline]
4457 fn new<'a>(
4458 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4459 ) -> Self {
4460 tuple.into()
4461 }
4462 #[inline]
4463 fn tokenize(&self) -> Self::Token<'_> {
4464 (
4465 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4466 &self.user,
4467 ),
4468 )
4469 }
4470 #[inline]
4471 fn abi_decode_returns(
4472 data: &[u8],
4473 validate: bool,
4474 ) -> alloy_sol_types::Result<Self::Return> {
4475 <Self::ReturnTuple<
4476 '_,
4477 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4478 .map(Into::into)
4479 }
4480 }
4481 };
4482 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4483 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4488 #[derive(Clone)]
4489 pub struct userUnderlyingViewCall {
4490 #[allow(missing_docs)]
4491 pub user: alloy::sol_types::private::Address,
4492 }
4493 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4494 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4496 #[derive(Clone)]
4497 pub struct userUnderlyingViewReturn {
4498 #[allow(missing_docs)]
4499 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4500 }
4501 #[allow(
4502 non_camel_case_types,
4503 non_snake_case,
4504 clippy::pub_underscore_fields,
4505 clippy::style
4506 )]
4507 const _: () = {
4508 use alloy::sol_types as alloy_sol_types;
4509 {
4510 #[doc(hidden)]
4511 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4512 #[doc(hidden)]
4513 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4514 #[cfg(test)]
4515 #[allow(dead_code, unreachable_patterns)]
4516 fn _type_assertion(
4517 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4518 ) {
4519 match _t {
4520 alloy_sol_types::private::AssertTypeEq::<
4521 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4522 >(_) => {}
4523 }
4524 }
4525 #[automatically_derived]
4526 #[doc(hidden)]
4527 impl ::core::convert::From<userUnderlyingViewCall>
4528 for UnderlyingRustTuple<'_> {
4529 fn from(value: userUnderlyingViewCall) -> Self {
4530 (value.user,)
4531 }
4532 }
4533 #[automatically_derived]
4534 #[doc(hidden)]
4535 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4536 for userUnderlyingViewCall {
4537 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4538 Self { user: tuple.0 }
4539 }
4540 }
4541 }
4542 {
4543 #[doc(hidden)]
4544 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4545 #[doc(hidden)]
4546 type UnderlyingRustTuple<'a> = (
4547 alloy::sol_types::private::primitives::aliases::U256,
4548 );
4549 #[cfg(test)]
4550 #[allow(dead_code, unreachable_patterns)]
4551 fn _type_assertion(
4552 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4553 ) {
4554 match _t {
4555 alloy_sol_types::private::AssertTypeEq::<
4556 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4557 >(_) => {}
4558 }
4559 }
4560 #[automatically_derived]
4561 #[doc(hidden)]
4562 impl ::core::convert::From<userUnderlyingViewReturn>
4563 for UnderlyingRustTuple<'_> {
4564 fn from(value: userUnderlyingViewReturn) -> Self {
4565 (value._0,)
4566 }
4567 }
4568 #[automatically_derived]
4569 #[doc(hidden)]
4570 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4571 for userUnderlyingViewReturn {
4572 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4573 Self { _0: tuple.0 }
4574 }
4575 }
4576 }
4577 #[automatically_derived]
4578 impl alloy_sol_types::SolCall for userUnderlyingViewCall {
4579 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4580 type Token<'a> = <Self::Parameters<
4581 'a,
4582 > as alloy_sol_types::SolType>::Token<'a>;
4583 type Return = userUnderlyingViewReturn;
4584 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4585 type ReturnToken<'a> = <Self::ReturnTuple<
4586 'a,
4587 > as alloy_sol_types::SolType>::Token<'a>;
4588 const SIGNATURE: &'static str = "userUnderlyingView(address)";
4589 const SELECTOR: [u8; 4] = [85u8, 60u8, 165u8, 248u8];
4590 #[inline]
4591 fn new<'a>(
4592 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4593 ) -> Self {
4594 tuple.into()
4595 }
4596 #[inline]
4597 fn tokenize(&self) -> Self::Token<'_> {
4598 (
4599 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4600 &self.user,
4601 ),
4602 )
4603 }
4604 #[inline]
4605 fn abi_decode_returns(
4606 data: &[u8],
4607 validate: bool,
4608 ) -> alloy_sol_types::Result<Self::Return> {
4609 <Self::ReturnTuple<
4610 '_,
4611 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4612 .map(Into::into)
4613 }
4614 }
4615 };
4616 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4617 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4622 #[derive(Clone)]
4623 pub struct versionCall {}
4624 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4625 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4627 #[derive(Clone)]
4628 pub struct versionReturn {
4629 #[allow(missing_docs)]
4630 pub _0: alloy::sol_types::private::String,
4631 }
4632 #[allow(
4633 non_camel_case_types,
4634 non_snake_case,
4635 clippy::pub_underscore_fields,
4636 clippy::style
4637 )]
4638 const _: () = {
4639 use alloy::sol_types as alloy_sol_types;
4640 {
4641 #[doc(hidden)]
4642 type UnderlyingSolTuple<'a> = ();
4643 #[doc(hidden)]
4644 type UnderlyingRustTuple<'a> = ();
4645 #[cfg(test)]
4646 #[allow(dead_code, unreachable_patterns)]
4647 fn _type_assertion(
4648 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4649 ) {
4650 match _t {
4651 alloy_sol_types::private::AssertTypeEq::<
4652 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4653 >(_) => {}
4654 }
4655 }
4656 #[automatically_derived]
4657 #[doc(hidden)]
4658 impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
4659 fn from(value: versionCall) -> Self {
4660 ()
4661 }
4662 }
4663 #[automatically_derived]
4664 #[doc(hidden)]
4665 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
4666 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4667 Self {}
4668 }
4669 }
4670 }
4671 {
4672 #[doc(hidden)]
4673 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
4674 #[doc(hidden)]
4675 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
4676 #[cfg(test)]
4677 #[allow(dead_code, unreachable_patterns)]
4678 fn _type_assertion(
4679 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4680 ) {
4681 match _t {
4682 alloy_sol_types::private::AssertTypeEq::<
4683 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4684 >(_) => {}
4685 }
4686 }
4687 #[automatically_derived]
4688 #[doc(hidden)]
4689 impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
4690 fn from(value: versionReturn) -> Self {
4691 (value._0,)
4692 }
4693 }
4694 #[automatically_derived]
4695 #[doc(hidden)]
4696 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
4697 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4698 Self { _0: tuple.0 }
4699 }
4700 }
4701 }
4702 #[automatically_derived]
4703 impl alloy_sol_types::SolCall for versionCall {
4704 type Parameters<'a> = ();
4705 type Token<'a> = <Self::Parameters<
4706 'a,
4707 > as alloy_sol_types::SolType>::Token<'a>;
4708 type Return = versionReturn;
4709 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
4710 type ReturnToken<'a> = <Self::ReturnTuple<
4711 'a,
4712 > as alloy_sol_types::SolType>::Token<'a>;
4713 const SIGNATURE: &'static str = "version()";
4714 const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
4715 #[inline]
4716 fn new<'a>(
4717 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4718 ) -> Self {
4719 tuple.into()
4720 }
4721 #[inline]
4722 fn tokenize(&self) -> Self::Token<'_> {
4723 ()
4724 }
4725 #[inline]
4726 fn abi_decode_returns(
4727 data: &[u8],
4728 validate: bool,
4729 ) -> alloy_sol_types::Result<Self::Return> {
4730 <Self::ReturnTuple<
4731 '_,
4732 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4733 .map(Into::into)
4734 }
4735 }
4736 };
4737 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4738 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4743 #[derive(Clone)]
4744 pub struct withdrawCall {
4745 #[allow(missing_docs)]
4746 pub recipient: alloy::sol_types::private::Address,
4747 #[allow(missing_docs)]
4748 pub token: alloy::sol_types::private::Address,
4749 #[allow(missing_docs)]
4750 pub amountShares: alloy::sol_types::private::primitives::aliases::U256,
4751 }
4752 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4754 #[derive(Clone)]
4755 pub struct withdrawReturn {}
4756 #[allow(
4757 non_camel_case_types,
4758 non_snake_case,
4759 clippy::pub_underscore_fields,
4760 clippy::style
4761 )]
4762 const _: () = {
4763 use alloy::sol_types as alloy_sol_types;
4764 {
4765 #[doc(hidden)]
4766 type UnderlyingSolTuple<'a> = (
4767 alloy::sol_types::sol_data::Address,
4768 alloy::sol_types::sol_data::Address,
4769 alloy::sol_types::sol_data::Uint<256>,
4770 );
4771 #[doc(hidden)]
4772 type UnderlyingRustTuple<'a> = (
4773 alloy::sol_types::private::Address,
4774 alloy::sol_types::private::Address,
4775 alloy::sol_types::private::primitives::aliases::U256,
4776 );
4777 #[cfg(test)]
4778 #[allow(dead_code, unreachable_patterns)]
4779 fn _type_assertion(
4780 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4781 ) {
4782 match _t {
4783 alloy_sol_types::private::AssertTypeEq::<
4784 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4785 >(_) => {}
4786 }
4787 }
4788 #[automatically_derived]
4789 #[doc(hidden)]
4790 impl ::core::convert::From<withdrawCall> for UnderlyingRustTuple<'_> {
4791 fn from(value: withdrawCall) -> Self {
4792 (value.recipient, value.token, value.amountShares)
4793 }
4794 }
4795 #[automatically_derived]
4796 #[doc(hidden)]
4797 impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawCall {
4798 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4799 Self {
4800 recipient: tuple.0,
4801 token: tuple.1,
4802 amountShares: tuple.2,
4803 }
4804 }
4805 }
4806 }
4807 {
4808 #[doc(hidden)]
4809 type UnderlyingSolTuple<'a> = ();
4810 #[doc(hidden)]
4811 type UnderlyingRustTuple<'a> = ();
4812 #[cfg(test)]
4813 #[allow(dead_code, unreachable_patterns)]
4814 fn _type_assertion(
4815 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4816 ) {
4817 match _t {
4818 alloy_sol_types::private::AssertTypeEq::<
4819 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4820 >(_) => {}
4821 }
4822 }
4823 #[automatically_derived]
4824 #[doc(hidden)]
4825 impl ::core::convert::From<withdrawReturn> for UnderlyingRustTuple<'_> {
4826 fn from(value: withdrawReturn) -> Self {
4827 ()
4828 }
4829 }
4830 #[automatically_derived]
4831 #[doc(hidden)]
4832 impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawReturn {
4833 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4834 Self {}
4835 }
4836 }
4837 }
4838 #[automatically_derived]
4839 impl alloy_sol_types::SolCall for withdrawCall {
4840 type Parameters<'a> = (
4841 alloy::sol_types::sol_data::Address,
4842 alloy::sol_types::sol_data::Address,
4843 alloy::sol_types::sol_data::Uint<256>,
4844 );
4845 type Token<'a> = <Self::Parameters<
4846 'a,
4847 > as alloy_sol_types::SolType>::Token<'a>;
4848 type Return = withdrawReturn;
4849 type ReturnTuple<'a> = ();
4850 type ReturnToken<'a> = <Self::ReturnTuple<
4851 'a,
4852 > as alloy_sol_types::SolType>::Token<'a>;
4853 const SIGNATURE: &'static str = "withdraw(address,address,uint256)";
4854 const SELECTOR: [u8; 4] = [217u8, 202u8, 237u8, 18u8];
4855 #[inline]
4856 fn new<'a>(
4857 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4858 ) -> Self {
4859 tuple.into()
4860 }
4861 #[inline]
4862 fn tokenize(&self) -> Self::Token<'_> {
4863 (
4864 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4865 &self.recipient,
4866 ),
4867 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4868 &self.token,
4869 ),
4870 <alloy::sol_types::sol_data::Uint<
4871 256,
4872 > as alloy_sol_types::SolType>::tokenize(&self.amountShares),
4873 )
4874 }
4875 #[inline]
4876 fn abi_decode_returns(
4877 data: &[u8],
4878 validate: bool,
4879 ) -> alloy_sol_types::Result<Self::Return> {
4880 <Self::ReturnTuple<
4881 '_,
4882 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4883 .map(Into::into)
4884 }
4885 }
4886 };
4887 #[derive()]
4889 pub enum StrategyBaseCalls {
4890 #[allow(missing_docs)]
4891 deposit(depositCall),
4892 #[allow(missing_docs)]
4893 explanation(explanationCall),
4894 #[allow(missing_docs)]
4895 initialize(initializeCall),
4896 #[allow(missing_docs)]
4897 pause(pauseCall),
4898 #[allow(missing_docs)]
4899 pauseAll(pauseAllCall),
4900 #[allow(missing_docs)]
4901 paused_0(paused_0Call),
4902 #[allow(missing_docs)]
4903 paused_1(paused_1Call),
4904 #[allow(missing_docs)]
4905 pauserRegistry(pauserRegistryCall),
4906 #[allow(missing_docs)]
4907 shares(sharesCall),
4908 #[allow(missing_docs)]
4909 sharesToUnderlying(sharesToUnderlyingCall),
4910 #[allow(missing_docs)]
4911 sharesToUnderlyingView(sharesToUnderlyingViewCall),
4912 #[allow(missing_docs)]
4913 strategyManager(strategyManagerCall),
4914 #[allow(missing_docs)]
4915 totalShares(totalSharesCall),
4916 #[allow(missing_docs)]
4917 underlyingToShares(underlyingToSharesCall),
4918 #[allow(missing_docs)]
4919 underlyingToSharesView(underlyingToSharesViewCall),
4920 #[allow(missing_docs)]
4921 underlyingToken(underlyingTokenCall),
4922 #[allow(missing_docs)]
4923 unpause(unpauseCall),
4924 #[allow(missing_docs)]
4925 userUnderlying(userUnderlyingCall),
4926 #[allow(missing_docs)]
4927 userUnderlyingView(userUnderlyingViewCall),
4928 #[allow(missing_docs)]
4929 version(versionCall),
4930 #[allow(missing_docs)]
4931 withdraw(withdrawCall),
4932 }
4933 #[automatically_derived]
4934 impl StrategyBaseCalls {
4935 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4942 [19u8, 100u8, 57u8, 221u8],
4943 [36u8, 149u8, 165u8, 153u8],
4944 [57u8, 183u8, 14u8, 56u8],
4945 [58u8, 152u8, 239u8, 57u8],
4946 [71u8, 231u8, 239u8, 36u8],
4947 [84u8, 253u8, 77u8, 80u8],
4948 [85u8, 60u8, 165u8, 248u8],
4949 [89u8, 92u8, 106u8, 103u8],
4950 [90u8, 200u8, 106u8, 183u8],
4951 [92u8, 151u8, 90u8, 187u8],
4952 [122u8, 139u8, 38u8, 55u8],
4953 [136u8, 111u8, 17u8, 149u8],
4954 [140u8, 135u8, 16u8, 25u8],
4955 [143u8, 106u8, 98u8, 64u8],
4956 [171u8, 89u8, 33u8, 225u8],
4957 [196u8, 214u8, 109u8, 232u8],
4958 [206u8, 124u8, 42u8, 194u8],
4959 [217u8, 202u8, 237u8, 18u8],
4960 [227u8, 218u8, 229u8, 28u8],
4961 [243u8, 231u8, 56u8, 117u8],
4962 [250u8, 188u8, 28u8, 188u8],
4963 ];
4964 }
4965 #[automatically_derived]
4966 impl alloy_sol_types::SolInterface for StrategyBaseCalls {
4967 const NAME: &'static str = "StrategyBaseCalls";
4968 const MIN_DATA_LENGTH: usize = 0usize;
4969 const COUNT: usize = 21usize;
4970 #[inline]
4971 fn selector(&self) -> [u8; 4] {
4972 match self {
4973 Self::deposit(_) => <depositCall as alloy_sol_types::SolCall>::SELECTOR,
4974 Self::explanation(_) => {
4975 <explanationCall as alloy_sol_types::SolCall>::SELECTOR
4976 }
4977 Self::initialize(_) => {
4978 <initializeCall as alloy_sol_types::SolCall>::SELECTOR
4979 }
4980 Self::pause(_) => <pauseCall as alloy_sol_types::SolCall>::SELECTOR,
4981 Self::pauseAll(_) => <pauseAllCall as alloy_sol_types::SolCall>::SELECTOR,
4982 Self::paused_0(_) => <paused_0Call as alloy_sol_types::SolCall>::SELECTOR,
4983 Self::paused_1(_) => <paused_1Call as alloy_sol_types::SolCall>::SELECTOR,
4984 Self::pauserRegistry(_) => {
4985 <pauserRegistryCall as alloy_sol_types::SolCall>::SELECTOR
4986 }
4987 Self::shares(_) => <sharesCall as alloy_sol_types::SolCall>::SELECTOR,
4988 Self::sharesToUnderlying(_) => {
4989 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::SELECTOR
4990 }
4991 Self::sharesToUnderlyingView(_) => {
4992 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::SELECTOR
4993 }
4994 Self::strategyManager(_) => {
4995 <strategyManagerCall as alloy_sol_types::SolCall>::SELECTOR
4996 }
4997 Self::totalShares(_) => {
4998 <totalSharesCall as alloy_sol_types::SolCall>::SELECTOR
4999 }
5000 Self::underlyingToShares(_) => {
5001 <underlyingToSharesCall as alloy_sol_types::SolCall>::SELECTOR
5002 }
5003 Self::underlyingToSharesView(_) => {
5004 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::SELECTOR
5005 }
5006 Self::underlyingToken(_) => {
5007 <underlyingTokenCall as alloy_sol_types::SolCall>::SELECTOR
5008 }
5009 Self::unpause(_) => <unpauseCall as alloy_sol_types::SolCall>::SELECTOR,
5010 Self::userUnderlying(_) => {
5011 <userUnderlyingCall as alloy_sol_types::SolCall>::SELECTOR
5012 }
5013 Self::userUnderlyingView(_) => {
5014 <userUnderlyingViewCall as alloy_sol_types::SolCall>::SELECTOR
5015 }
5016 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
5017 Self::withdraw(_) => <withdrawCall as alloy_sol_types::SolCall>::SELECTOR,
5018 }
5019 }
5020 #[inline]
5021 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5022 Self::SELECTORS.get(i).copied()
5023 }
5024 #[inline]
5025 fn valid_selector(selector: [u8; 4]) -> bool {
5026 Self::SELECTORS.binary_search(&selector).is_ok()
5027 }
5028 #[inline]
5029 #[allow(non_snake_case)]
5030 fn abi_decode_raw(
5031 selector: [u8; 4],
5032 data: &[u8],
5033 validate: bool,
5034 ) -> alloy_sol_types::Result<Self> {
5035 static DECODE_SHIMS: &[fn(
5036 &[u8],
5037 bool,
5038 ) -> alloy_sol_types::Result<StrategyBaseCalls>] = &[
5039 {
5040 fn pause(
5041 data: &[u8],
5042 validate: bool,
5043 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5044 <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw(
5045 data,
5046 validate,
5047 )
5048 .map(StrategyBaseCalls::pause)
5049 }
5050 pause
5051 },
5052 {
5053 fn underlyingToken(
5054 data: &[u8],
5055 validate: bool,
5056 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5057 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
5058 data,
5059 validate,
5060 )
5061 .map(StrategyBaseCalls::underlyingToken)
5062 }
5063 underlyingToken
5064 },
5065 {
5066 fn strategyManager(
5067 data: &[u8],
5068 validate: bool,
5069 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5070 <strategyManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
5071 data,
5072 validate,
5073 )
5074 .map(StrategyBaseCalls::strategyManager)
5075 }
5076 strategyManager
5077 },
5078 {
5079 fn totalShares(
5080 data: &[u8],
5081 validate: bool,
5082 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5083 <totalSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
5084 data,
5085 validate,
5086 )
5087 .map(StrategyBaseCalls::totalShares)
5088 }
5089 totalShares
5090 },
5091 {
5092 fn deposit(
5093 data: &[u8],
5094 validate: bool,
5095 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5096 <depositCall as alloy_sol_types::SolCall>::abi_decode_raw(
5097 data,
5098 validate,
5099 )
5100 .map(StrategyBaseCalls::deposit)
5101 }
5102 deposit
5103 },
5104 {
5105 fn version(
5106 data: &[u8],
5107 validate: bool,
5108 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5109 <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(
5110 data,
5111 validate,
5112 )
5113 .map(StrategyBaseCalls::version)
5114 }
5115 version
5116 },
5117 {
5118 fn userUnderlyingView(
5119 data: &[u8],
5120 validate: bool,
5121 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5122 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_decode_raw(
5123 data,
5124 validate,
5125 )
5126 .map(StrategyBaseCalls::userUnderlyingView)
5127 }
5128 userUnderlyingView
5129 },
5130 {
5131 fn pauseAll(
5132 data: &[u8],
5133 validate: bool,
5134 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5135 <pauseAllCall as alloy_sol_types::SolCall>::abi_decode_raw(
5136 data,
5137 validate,
5138 )
5139 .map(StrategyBaseCalls::pauseAll)
5140 }
5141 pauseAll
5142 },
5143 {
5144 fn paused_0(
5145 data: &[u8],
5146 validate: bool,
5147 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5148 <paused_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
5149 data,
5150 validate,
5151 )
5152 .map(StrategyBaseCalls::paused_0)
5153 }
5154 paused_0
5155 },
5156 {
5157 fn paused_1(
5158 data: &[u8],
5159 validate: bool,
5160 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5161 <paused_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
5162 data,
5163 validate,
5164 )
5165 .map(StrategyBaseCalls::paused_1)
5166 }
5167 paused_1
5168 },
5169 {
5170 fn sharesToUnderlyingView(
5171 data: &[u8],
5172 validate: bool,
5173 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5174 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_decode_raw(
5175 data,
5176 validate,
5177 )
5178 .map(StrategyBaseCalls::sharesToUnderlyingView)
5179 }
5180 sharesToUnderlyingView
5181 },
5182 {
5183 fn pauserRegistry(
5184 data: &[u8],
5185 validate: bool,
5186 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5187 <pauserRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
5188 data,
5189 validate,
5190 )
5191 .map(StrategyBaseCalls::pauserRegistry)
5192 }
5193 pauserRegistry
5194 },
5195 {
5196 fn underlyingToShares(
5197 data: &[u8],
5198 validate: bool,
5199 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5200 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
5201 data,
5202 validate,
5203 )
5204 .map(StrategyBaseCalls::underlyingToShares)
5205 }
5206 underlyingToShares
5207 },
5208 {
5209 fn userUnderlying(
5210 data: &[u8],
5211 validate: bool,
5212 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5213 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_decode_raw(
5214 data,
5215 validate,
5216 )
5217 .map(StrategyBaseCalls::userUnderlying)
5218 }
5219 userUnderlying
5220 },
5221 {
5222 fn explanation(
5223 data: &[u8],
5224 validate: bool,
5225 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5226 <explanationCall as alloy_sol_types::SolCall>::abi_decode_raw(
5227 data,
5228 validate,
5229 )
5230 .map(StrategyBaseCalls::explanation)
5231 }
5232 explanation
5233 },
5234 {
5235 fn initialize(
5236 data: &[u8],
5237 validate: bool,
5238 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5239 <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
5240 data,
5241 validate,
5242 )
5243 .map(StrategyBaseCalls::initialize)
5244 }
5245 initialize
5246 },
5247 {
5248 fn shares(
5249 data: &[u8],
5250 validate: bool,
5251 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5252 <sharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
5253 data,
5254 validate,
5255 )
5256 .map(StrategyBaseCalls::shares)
5257 }
5258 shares
5259 },
5260 {
5261 fn withdraw(
5262 data: &[u8],
5263 validate: bool,
5264 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5265 <withdrawCall as alloy_sol_types::SolCall>::abi_decode_raw(
5266 data,
5267 validate,
5268 )
5269 .map(StrategyBaseCalls::withdraw)
5270 }
5271 withdraw
5272 },
5273 {
5274 fn underlyingToSharesView(
5275 data: &[u8],
5276 validate: bool,
5277 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5278 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_decode_raw(
5279 data,
5280 validate,
5281 )
5282 .map(StrategyBaseCalls::underlyingToSharesView)
5283 }
5284 underlyingToSharesView
5285 },
5286 {
5287 fn sharesToUnderlying(
5288 data: &[u8],
5289 validate: bool,
5290 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5291 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_decode_raw(
5292 data,
5293 validate,
5294 )
5295 .map(StrategyBaseCalls::sharesToUnderlying)
5296 }
5297 sharesToUnderlying
5298 },
5299 {
5300 fn unpause(
5301 data: &[u8],
5302 validate: bool,
5303 ) -> alloy_sol_types::Result<StrategyBaseCalls> {
5304 <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw(
5305 data,
5306 validate,
5307 )
5308 .map(StrategyBaseCalls::unpause)
5309 }
5310 unpause
5311 },
5312 ];
5313 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5314 return Err(
5315 alloy_sol_types::Error::unknown_selector(
5316 <Self as alloy_sol_types::SolInterface>::NAME,
5317 selector,
5318 ),
5319 );
5320 };
5321 DECODE_SHIMS[idx](data, validate)
5322 }
5323 #[inline]
5324 fn abi_encoded_size(&self) -> usize {
5325 match self {
5326 Self::deposit(inner) => {
5327 <depositCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5328 }
5329 Self::explanation(inner) => {
5330 <explanationCall as alloy_sol_types::SolCall>::abi_encoded_size(
5331 inner,
5332 )
5333 }
5334 Self::initialize(inner) => {
5335 <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5336 }
5337 Self::pause(inner) => {
5338 <pauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5339 }
5340 Self::pauseAll(inner) => {
5341 <pauseAllCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5342 }
5343 Self::paused_0(inner) => {
5344 <paused_0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5345 }
5346 Self::paused_1(inner) => {
5347 <paused_1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5348 }
5349 Self::pauserRegistry(inner) => {
5350 <pauserRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
5351 inner,
5352 )
5353 }
5354 Self::shares(inner) => {
5355 <sharesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5356 }
5357 Self::sharesToUnderlying(inner) => {
5358 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_encoded_size(
5359 inner,
5360 )
5361 }
5362 Self::sharesToUnderlyingView(inner) => {
5363 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encoded_size(
5364 inner,
5365 )
5366 }
5367 Self::strategyManager(inner) => {
5368 <strategyManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
5369 inner,
5370 )
5371 }
5372 Self::totalShares(inner) => {
5373 <totalSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
5374 inner,
5375 )
5376 }
5377 Self::underlyingToShares(inner) => {
5378 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
5379 inner,
5380 )
5381 }
5382 Self::underlyingToSharesView(inner) => {
5383 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_encoded_size(
5384 inner,
5385 )
5386 }
5387 Self::underlyingToken(inner) => {
5388 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
5389 inner,
5390 )
5391 }
5392 Self::unpause(inner) => {
5393 <unpauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5394 }
5395 Self::userUnderlying(inner) => {
5396 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_encoded_size(
5397 inner,
5398 )
5399 }
5400 Self::userUnderlyingView(inner) => {
5401 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encoded_size(
5402 inner,
5403 )
5404 }
5405 Self::version(inner) => {
5406 <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5407 }
5408 Self::withdraw(inner) => {
5409 <withdrawCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5410 }
5411 }
5412 }
5413 #[inline]
5414 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5415 match self {
5416 Self::deposit(inner) => {
5417 <depositCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5418 }
5419 Self::explanation(inner) => {
5420 <explanationCall as alloy_sol_types::SolCall>::abi_encode_raw(
5421 inner,
5422 out,
5423 )
5424 }
5425 Self::initialize(inner) => {
5426 <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
5427 inner,
5428 out,
5429 )
5430 }
5431 Self::pause(inner) => {
5432 <pauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5433 }
5434 Self::pauseAll(inner) => {
5435 <pauseAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
5436 inner,
5437 out,
5438 )
5439 }
5440 Self::paused_0(inner) => {
5441 <paused_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
5442 inner,
5443 out,
5444 )
5445 }
5446 Self::paused_1(inner) => {
5447 <paused_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
5448 inner,
5449 out,
5450 )
5451 }
5452 Self::pauserRegistry(inner) => {
5453 <pauserRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
5454 inner,
5455 out,
5456 )
5457 }
5458 Self::shares(inner) => {
5459 <sharesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5460 }
5461 Self::sharesToUnderlying(inner) => {
5462 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_encode_raw(
5463 inner,
5464 out,
5465 )
5466 }
5467 Self::sharesToUnderlyingView(inner) => {
5468 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encode_raw(
5469 inner,
5470 out,
5471 )
5472 }
5473 Self::strategyManager(inner) => {
5474 <strategyManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
5475 inner,
5476 out,
5477 )
5478 }
5479 Self::totalShares(inner) => {
5480 <totalSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
5481 inner,
5482 out,
5483 )
5484 }
5485 Self::underlyingToShares(inner) => {
5486 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
5487 inner,
5488 out,
5489 )
5490 }
5491 Self::underlyingToSharesView(inner) => {
5492 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_encode_raw(
5493 inner,
5494 out,
5495 )
5496 }
5497 Self::underlyingToken(inner) => {
5498 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
5499 inner,
5500 out,
5501 )
5502 }
5503 Self::unpause(inner) => {
5504 <unpauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5505 }
5506 Self::userUnderlying(inner) => {
5507 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_encode_raw(
5508 inner,
5509 out,
5510 )
5511 }
5512 Self::userUnderlyingView(inner) => {
5513 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encode_raw(
5514 inner,
5515 out,
5516 )
5517 }
5518 Self::version(inner) => {
5519 <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5520 }
5521 Self::withdraw(inner) => {
5522 <withdrawCall as alloy_sol_types::SolCall>::abi_encode_raw(
5523 inner,
5524 out,
5525 )
5526 }
5527 }
5528 }
5529 }
5530 #[derive(Debug, PartialEq, Eq, Hash)]
5532 pub enum StrategyBaseErrors {
5533 #[allow(missing_docs)]
5534 BalanceExceedsMaxTotalDeposits(BalanceExceedsMaxTotalDeposits),
5535 #[allow(missing_docs)]
5536 CurrentlyPaused(CurrentlyPaused),
5537 #[allow(missing_docs)]
5538 InputAddressZero(InputAddressZero),
5539 #[allow(missing_docs)]
5540 InvalidNewPausedStatus(InvalidNewPausedStatus),
5541 #[allow(missing_docs)]
5542 InvalidShortString(InvalidShortString),
5543 #[allow(missing_docs)]
5544 MaxPerDepositExceedsMax(MaxPerDepositExceedsMax),
5545 #[allow(missing_docs)]
5546 NewSharesZero(NewSharesZero),
5547 #[allow(missing_docs)]
5548 OnlyPauser(OnlyPauser),
5549 #[allow(missing_docs)]
5550 OnlyStrategyManager(OnlyStrategyManager),
5551 #[allow(missing_docs)]
5552 OnlyUnderlyingToken(OnlyUnderlyingToken),
5553 #[allow(missing_docs)]
5554 OnlyUnpauser(OnlyUnpauser),
5555 #[allow(missing_docs)]
5556 StringTooLong(StringTooLong),
5557 #[allow(missing_docs)]
5558 TotalSharesExceedsMax(TotalSharesExceedsMax),
5559 #[allow(missing_docs)]
5560 WithdrawalAmountExceedsTotalDeposits(WithdrawalAmountExceedsTotalDeposits),
5561 }
5562 #[automatically_derived]
5563 impl StrategyBaseErrors {
5564 pub const SELECTORS: &'static [[u8; 4usize]] = &[
5571 [20u8, 172u8, 30u8, 220u8],
5572 [24u8, 114u8, 93u8, 166u8],
5573 [48u8, 90u8, 39u8, 169u8],
5574 [72u8, 218u8, 113u8, 79u8],
5575 [94u8, 41u8, 209u8, 70u8],
5576 [115u8, 99u8, 33u8, 118u8],
5577 [117u8, 223u8, 81u8, 220u8],
5578 [121u8, 72u8, 33u8, 255u8],
5579 [132u8, 10u8, 72u8, 213u8],
5580 [179u8, 81u8, 43u8, 12u8],
5581 [180u8, 105u8, 223u8, 48u8],
5582 [196u8, 170u8, 247u8, 64u8],
5583 [198u8, 29u8, 202u8, 93u8],
5584 [216u8, 107u8, 174u8, 103u8],
5585 ];
5586 }
5587 #[automatically_derived]
5588 impl alloy_sol_types::SolInterface for StrategyBaseErrors {
5589 const NAME: &'static str = "StrategyBaseErrors";
5590 const MIN_DATA_LENGTH: usize = 0usize;
5591 const COUNT: usize = 14usize;
5592 #[inline]
5593 fn selector(&self) -> [u8; 4] {
5594 match self {
5595 Self::BalanceExceedsMaxTotalDeposits(_) => {
5596 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::SELECTOR
5597 }
5598 Self::CurrentlyPaused(_) => {
5599 <CurrentlyPaused as alloy_sol_types::SolError>::SELECTOR
5600 }
5601 Self::InputAddressZero(_) => {
5602 <InputAddressZero as alloy_sol_types::SolError>::SELECTOR
5603 }
5604 Self::InvalidNewPausedStatus(_) => {
5605 <InvalidNewPausedStatus as alloy_sol_types::SolError>::SELECTOR
5606 }
5607 Self::InvalidShortString(_) => {
5608 <InvalidShortString as alloy_sol_types::SolError>::SELECTOR
5609 }
5610 Self::MaxPerDepositExceedsMax(_) => {
5611 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::SELECTOR
5612 }
5613 Self::NewSharesZero(_) => {
5614 <NewSharesZero as alloy_sol_types::SolError>::SELECTOR
5615 }
5616 Self::OnlyPauser(_) => {
5617 <OnlyPauser as alloy_sol_types::SolError>::SELECTOR
5618 }
5619 Self::OnlyStrategyManager(_) => {
5620 <OnlyStrategyManager as alloy_sol_types::SolError>::SELECTOR
5621 }
5622 Self::OnlyUnderlyingToken(_) => {
5623 <OnlyUnderlyingToken as alloy_sol_types::SolError>::SELECTOR
5624 }
5625 Self::OnlyUnpauser(_) => {
5626 <OnlyUnpauser as alloy_sol_types::SolError>::SELECTOR
5627 }
5628 Self::StringTooLong(_) => {
5629 <StringTooLong as alloy_sol_types::SolError>::SELECTOR
5630 }
5631 Self::TotalSharesExceedsMax(_) => {
5632 <TotalSharesExceedsMax as alloy_sol_types::SolError>::SELECTOR
5633 }
5634 Self::WithdrawalAmountExceedsTotalDeposits(_) => {
5635 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::SELECTOR
5636 }
5637 }
5638 }
5639 #[inline]
5640 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5641 Self::SELECTORS.get(i).copied()
5642 }
5643 #[inline]
5644 fn valid_selector(selector: [u8; 4]) -> bool {
5645 Self::SELECTORS.binary_search(&selector).is_ok()
5646 }
5647 #[inline]
5648 #[allow(non_snake_case)]
5649 fn abi_decode_raw(
5650 selector: [u8; 4],
5651 data: &[u8],
5652 validate: bool,
5653 ) -> alloy_sol_types::Result<Self> {
5654 static DECODE_SHIMS: &[fn(
5655 &[u8],
5656 bool,
5657 ) -> alloy_sol_types::Result<StrategyBaseErrors>] = &[
5658 {
5659 fn MaxPerDepositExceedsMax(
5660 data: &[u8],
5661 validate: bool,
5662 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5663 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_decode_raw(
5664 data,
5665 validate,
5666 )
5667 .map(StrategyBaseErrors::MaxPerDepositExceedsMax)
5668 }
5669 MaxPerDepositExceedsMax
5670 },
5671 {
5672 fn NewSharesZero(
5673 data: &[u8],
5674 validate: bool,
5675 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5676 <NewSharesZero as alloy_sol_types::SolError>::abi_decode_raw(
5677 data,
5678 validate,
5679 )
5680 .map(StrategyBaseErrors::NewSharesZero)
5681 }
5682 NewSharesZero
5683 },
5684 {
5685 fn StringTooLong(
5686 data: &[u8],
5687 validate: bool,
5688 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5689 <StringTooLong as alloy_sol_types::SolError>::abi_decode_raw(
5690 data,
5691 validate,
5692 )
5693 .map(StrategyBaseErrors::StringTooLong)
5694 }
5695 StringTooLong
5696 },
5697 {
5698 fn OnlyStrategyManager(
5699 data: &[u8],
5700 validate: bool,
5701 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5702 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_decode_raw(
5703 data,
5704 validate,
5705 )
5706 .map(StrategyBaseErrors::OnlyStrategyManager)
5707 }
5708 OnlyStrategyManager
5709 },
5710 {
5711 fn TotalSharesExceedsMax(
5712 data: &[u8],
5713 validate: bool,
5714 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5715 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_decode_raw(
5716 data,
5717 validate,
5718 )
5719 .map(StrategyBaseErrors::TotalSharesExceedsMax)
5720 }
5721 TotalSharesExceedsMax
5722 },
5723 {
5724 fn InputAddressZero(
5725 data: &[u8],
5726 validate: bool,
5727 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5728 <InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw(
5729 data,
5730 validate,
5731 )
5732 .map(StrategyBaseErrors::InputAddressZero)
5733 }
5734 InputAddressZero
5735 },
5736 {
5737 fn OnlyPauser(
5738 data: &[u8],
5739 validate: bool,
5740 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5741 <OnlyPauser as alloy_sol_types::SolError>::abi_decode_raw(
5742 data,
5743 validate,
5744 )
5745 .map(StrategyBaseErrors::OnlyPauser)
5746 }
5747 OnlyPauser
5748 },
5749 {
5750 fn OnlyUnpauser(
5751 data: &[u8],
5752 validate: bool,
5753 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5754 <OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw(
5755 data,
5756 validate,
5757 )
5758 .map(StrategyBaseErrors::OnlyUnpauser)
5759 }
5760 OnlyUnpauser
5761 },
5762 {
5763 fn CurrentlyPaused(
5764 data: &[u8],
5765 validate: bool,
5766 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5767 <CurrentlyPaused as alloy_sol_types::SolError>::abi_decode_raw(
5768 data,
5769 validate,
5770 )
5771 .map(StrategyBaseErrors::CurrentlyPaused)
5772 }
5773 CurrentlyPaused
5774 },
5775 {
5776 fn InvalidShortString(
5777 data: &[u8],
5778 validate: bool,
5779 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5780 <InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw(
5781 data,
5782 validate,
5783 )
5784 .map(StrategyBaseErrors::InvalidShortString)
5785 }
5786 InvalidShortString
5787 },
5788 {
5789 fn WithdrawalAmountExceedsTotalDeposits(
5790 data: &[u8],
5791 validate: bool,
5792 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5793 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_decode_raw(
5794 data,
5795 validate,
5796 )
5797 .map(
5798 StrategyBaseErrors::WithdrawalAmountExceedsTotalDeposits,
5799 )
5800 }
5801 WithdrawalAmountExceedsTotalDeposits
5802 },
5803 {
5804 fn OnlyUnderlyingToken(
5805 data: &[u8],
5806 validate: bool,
5807 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5808 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_decode_raw(
5809 data,
5810 validate,
5811 )
5812 .map(StrategyBaseErrors::OnlyUnderlyingToken)
5813 }
5814 OnlyUnderlyingToken
5815 },
5816 {
5817 fn InvalidNewPausedStatus(
5818 data: &[u8],
5819 validate: bool,
5820 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5821 <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_decode_raw(
5822 data,
5823 validate,
5824 )
5825 .map(StrategyBaseErrors::InvalidNewPausedStatus)
5826 }
5827 InvalidNewPausedStatus
5828 },
5829 {
5830 fn BalanceExceedsMaxTotalDeposits(
5831 data: &[u8],
5832 validate: bool,
5833 ) -> alloy_sol_types::Result<StrategyBaseErrors> {
5834 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_decode_raw(
5835 data,
5836 validate,
5837 )
5838 .map(StrategyBaseErrors::BalanceExceedsMaxTotalDeposits)
5839 }
5840 BalanceExceedsMaxTotalDeposits
5841 },
5842 ];
5843 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5844 return Err(
5845 alloy_sol_types::Error::unknown_selector(
5846 <Self as alloy_sol_types::SolInterface>::NAME,
5847 selector,
5848 ),
5849 );
5850 };
5851 DECODE_SHIMS[idx](data, validate)
5852 }
5853 #[inline]
5854 fn abi_encoded_size(&self) -> usize {
5855 match self {
5856 Self::BalanceExceedsMaxTotalDeposits(inner) => {
5857 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_encoded_size(
5858 inner,
5859 )
5860 }
5861 Self::CurrentlyPaused(inner) => {
5862 <CurrentlyPaused as alloy_sol_types::SolError>::abi_encoded_size(
5863 inner,
5864 )
5865 }
5866 Self::InputAddressZero(inner) => {
5867 <InputAddressZero as alloy_sol_types::SolError>::abi_encoded_size(
5868 inner,
5869 )
5870 }
5871 Self::InvalidNewPausedStatus(inner) => {
5872 <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encoded_size(
5873 inner,
5874 )
5875 }
5876 Self::InvalidShortString(inner) => {
5877 <InvalidShortString as alloy_sol_types::SolError>::abi_encoded_size(
5878 inner,
5879 )
5880 }
5881 Self::MaxPerDepositExceedsMax(inner) => {
5882 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_encoded_size(
5883 inner,
5884 )
5885 }
5886 Self::NewSharesZero(inner) => {
5887 <NewSharesZero as alloy_sol_types::SolError>::abi_encoded_size(inner)
5888 }
5889 Self::OnlyPauser(inner) => {
5890 <OnlyPauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
5891 }
5892 Self::OnlyStrategyManager(inner) => {
5893 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_encoded_size(
5894 inner,
5895 )
5896 }
5897 Self::OnlyUnderlyingToken(inner) => {
5898 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_encoded_size(
5899 inner,
5900 )
5901 }
5902 Self::OnlyUnpauser(inner) => {
5903 <OnlyUnpauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
5904 }
5905 Self::StringTooLong(inner) => {
5906 <StringTooLong as alloy_sol_types::SolError>::abi_encoded_size(inner)
5907 }
5908 Self::TotalSharesExceedsMax(inner) => {
5909 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_encoded_size(
5910 inner,
5911 )
5912 }
5913 Self::WithdrawalAmountExceedsTotalDeposits(inner) => {
5914 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_encoded_size(
5915 inner,
5916 )
5917 }
5918 }
5919 }
5920 #[inline]
5921 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5922 match self {
5923 Self::BalanceExceedsMaxTotalDeposits(inner) => {
5924 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_encode_raw(
5925 inner,
5926 out,
5927 )
5928 }
5929 Self::CurrentlyPaused(inner) => {
5930 <CurrentlyPaused as alloy_sol_types::SolError>::abi_encode_raw(
5931 inner,
5932 out,
5933 )
5934 }
5935 Self::InputAddressZero(inner) => {
5936 <InputAddressZero as alloy_sol_types::SolError>::abi_encode_raw(
5937 inner,
5938 out,
5939 )
5940 }
5941 Self::InvalidNewPausedStatus(inner) => {
5942 <InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encode_raw(
5943 inner,
5944 out,
5945 )
5946 }
5947 Self::InvalidShortString(inner) => {
5948 <InvalidShortString as alloy_sol_types::SolError>::abi_encode_raw(
5949 inner,
5950 out,
5951 )
5952 }
5953 Self::MaxPerDepositExceedsMax(inner) => {
5954 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_encode_raw(
5955 inner,
5956 out,
5957 )
5958 }
5959 Self::NewSharesZero(inner) => {
5960 <NewSharesZero as alloy_sol_types::SolError>::abi_encode_raw(
5961 inner,
5962 out,
5963 )
5964 }
5965 Self::OnlyPauser(inner) => {
5966 <OnlyPauser as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5967 }
5968 Self::OnlyStrategyManager(inner) => {
5969 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_encode_raw(
5970 inner,
5971 out,
5972 )
5973 }
5974 Self::OnlyUnderlyingToken(inner) => {
5975 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_encode_raw(
5976 inner,
5977 out,
5978 )
5979 }
5980 Self::OnlyUnpauser(inner) => {
5981 <OnlyUnpauser as alloy_sol_types::SolError>::abi_encode_raw(
5982 inner,
5983 out,
5984 )
5985 }
5986 Self::StringTooLong(inner) => {
5987 <StringTooLong as alloy_sol_types::SolError>::abi_encode_raw(
5988 inner,
5989 out,
5990 )
5991 }
5992 Self::TotalSharesExceedsMax(inner) => {
5993 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_encode_raw(
5994 inner,
5995 out,
5996 )
5997 }
5998 Self::WithdrawalAmountExceedsTotalDeposits(inner) => {
5999 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_encode_raw(
6000 inner,
6001 out,
6002 )
6003 }
6004 }
6005 }
6006 }
6007 #[derive(Debug, PartialEq, Eq, Hash)]
6009 pub enum StrategyBaseEvents {
6010 #[allow(missing_docs)]
6011 ExchangeRateEmitted(ExchangeRateEmitted),
6012 #[allow(missing_docs)]
6013 Initialized(Initialized),
6014 #[allow(missing_docs)]
6015 Paused(Paused),
6016 #[allow(missing_docs)]
6017 StrategyTokenSet(StrategyTokenSet),
6018 #[allow(missing_docs)]
6019 Unpaused(Unpaused),
6020 }
6021 #[automatically_derived]
6022 impl StrategyBaseEvents {
6023 pub const SELECTORS: &'static [[u8; 32usize]] = &[
6030 [
6031 28u8, 84u8, 7u8, 7u8, 176u8, 14u8, 181u8, 66u8, 123u8, 107u8, 119u8,
6032 79u8, 199u8, 153u8, 215u8, 86u8, 81u8, 106u8, 84u8, 174u8, 225u8, 8u8,
6033 182u8, 75u8, 50u8, 122u8, 204u8, 85u8, 175u8, 85u8, 117u8, 7u8,
6034 ],
6035 [
6036 53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8,
6037 2u8, 188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8,
6038 228u8, 152u8, 107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
6039 ],
6040 [
6041 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
6042 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
6043 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
6044 ],
6045 [
6046 171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8,
6047 188u8, 152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8,
6048 11u8, 182u8, 224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
6049 ],
6050 [
6051 210u8, 73u8, 79u8, 52u8, 121u8, 229u8, 218u8, 73u8, 211u8, 134u8, 101u8,
6052 124u8, 41u8, 44u8, 97u8, 11u8, 91u8, 1u8, 223u8, 49u8, 61u8, 7u8, 198u8,
6053 46u8, 176u8, 207u8, 164u8, 153u8, 36u8, 163u8, 27u8, 232u8,
6054 ],
6055 ];
6056 }
6057 #[automatically_derived]
6058 impl alloy_sol_types::SolEventInterface for StrategyBaseEvents {
6059 const NAME: &'static str = "StrategyBaseEvents";
6060 const COUNT: usize = 5usize;
6061 fn decode_raw_log(
6062 topics: &[alloy_sol_types::Word],
6063 data: &[u8],
6064 validate: bool,
6065 ) -> alloy_sol_types::Result<Self> {
6066 match topics.first().copied() {
6067 Some(
6068 <ExchangeRateEmitted as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
6069 ) => {
6070 <ExchangeRateEmitted as alloy_sol_types::SolEvent>::decode_raw_log(
6071 topics,
6072 data,
6073 validate,
6074 )
6075 .map(Self::ExchangeRateEmitted)
6076 }
6077 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6078 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
6079 topics,
6080 data,
6081 validate,
6082 )
6083 .map(Self::Initialized)
6084 }
6085 Some(<Paused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6086 <Paused as alloy_sol_types::SolEvent>::decode_raw_log(
6087 topics,
6088 data,
6089 validate,
6090 )
6091 .map(Self::Paused)
6092 }
6093 Some(<StrategyTokenSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6094 <StrategyTokenSet as alloy_sol_types::SolEvent>::decode_raw_log(
6095 topics,
6096 data,
6097 validate,
6098 )
6099 .map(Self::StrategyTokenSet)
6100 }
6101 Some(<Unpaused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6102 <Unpaused as alloy_sol_types::SolEvent>::decode_raw_log(
6103 topics,
6104 data,
6105 validate,
6106 )
6107 .map(Self::Unpaused)
6108 }
6109 _ => {
6110 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
6111 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
6112 log: alloy_sol_types::private::Box::new(
6113 alloy_sol_types::private::LogData::new_unchecked(
6114 topics.to_vec(),
6115 data.to_vec().into(),
6116 ),
6117 ),
6118 })
6119 }
6120 }
6121 }
6122 }
6123 #[automatically_derived]
6124 impl alloy_sol_types::private::IntoLogData for StrategyBaseEvents {
6125 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6126 match self {
6127 Self::ExchangeRateEmitted(inner) => {
6128 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6129 }
6130 Self::Initialized(inner) => {
6131 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6132 }
6133 Self::Paused(inner) => {
6134 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6135 }
6136 Self::StrategyTokenSet(inner) => {
6137 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6138 }
6139 Self::Unpaused(inner) => {
6140 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6141 }
6142 }
6143 }
6144 fn into_log_data(self) -> alloy_sol_types::private::LogData {
6145 match self {
6146 Self::ExchangeRateEmitted(inner) => {
6147 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6148 }
6149 Self::Initialized(inner) => {
6150 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6151 }
6152 Self::Paused(inner) => {
6153 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6154 }
6155 Self::StrategyTokenSet(inner) => {
6156 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6157 }
6158 Self::Unpaused(inner) => {
6159 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6160 }
6161 }
6162 }
6163 }
6164 use alloy::contract as alloy_contract;
6165 #[inline]
6169 pub const fn new<
6170 T: alloy_contract::private::Transport + ::core::clone::Clone,
6171 P: alloy_contract::private::Provider<T, N>,
6172 N: alloy_contract::private::Network,
6173 >(
6174 address: alloy_sol_types::private::Address,
6175 provider: P,
6176 ) -> StrategyBaseInstance<T, P, N> {
6177 StrategyBaseInstance::<T, P, N>::new(address, provider)
6178 }
6179 #[inline]
6185 pub fn deploy<
6186 T: alloy_contract::private::Transport + ::core::clone::Clone,
6187 P: alloy_contract::private::Provider<T, N>,
6188 N: alloy_contract::private::Network,
6189 >(
6190 provider: P,
6191 _strategyManager: alloy::sol_types::private::Address,
6192 _pauserRegistry: alloy::sol_types::private::Address,
6193 _version: alloy::sol_types::private::String,
6194 ) -> impl ::core::future::Future<
6195 Output = alloy_contract::Result<StrategyBaseInstance<T, P, N>>,
6196 > {
6197 StrategyBaseInstance::<
6198 T,
6199 P,
6200 N,
6201 >::deploy(provider, _strategyManager, _pauserRegistry, _version)
6202 }
6203 #[inline]
6209 pub fn deploy_builder<
6210 T: alloy_contract::private::Transport + ::core::clone::Clone,
6211 P: alloy_contract::private::Provider<T, N>,
6212 N: alloy_contract::private::Network,
6213 >(
6214 provider: P,
6215 _strategyManager: alloy::sol_types::private::Address,
6216 _pauserRegistry: alloy::sol_types::private::Address,
6217 _version: alloy::sol_types::private::String,
6218 ) -> alloy_contract::RawCallBuilder<T, P, N> {
6219 StrategyBaseInstance::<
6220 T,
6221 P,
6222 N,
6223 >::deploy_builder(provider, _strategyManager, _pauserRegistry, _version)
6224 }
6225 #[derive(Clone)]
6237 pub struct StrategyBaseInstance<T, P, N = alloy_contract::private::Ethereum> {
6238 address: alloy_sol_types::private::Address,
6239 provider: P,
6240 _network_transport: ::core::marker::PhantomData<(N, T)>,
6241 }
6242 #[automatically_derived]
6243 impl<T, P, N> ::core::fmt::Debug for StrategyBaseInstance<T, P, N> {
6244 #[inline]
6245 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6246 f.debug_tuple("StrategyBaseInstance").field(&self.address).finish()
6247 }
6248 }
6249 #[automatically_derived]
6251 impl<
6252 T: alloy_contract::private::Transport + ::core::clone::Clone,
6253 P: alloy_contract::private::Provider<T, N>,
6254 N: alloy_contract::private::Network,
6255 > StrategyBaseInstance<T, P, N> {
6256 #[inline]
6260 pub const fn new(
6261 address: alloy_sol_types::private::Address,
6262 provider: P,
6263 ) -> Self {
6264 Self {
6265 address,
6266 provider,
6267 _network_transport: ::core::marker::PhantomData,
6268 }
6269 }
6270 #[inline]
6276 pub async fn deploy(
6277 provider: P,
6278 _strategyManager: alloy::sol_types::private::Address,
6279 _pauserRegistry: alloy::sol_types::private::Address,
6280 _version: alloy::sol_types::private::String,
6281 ) -> alloy_contract::Result<StrategyBaseInstance<T, P, N>> {
6282 let call_builder = Self::deploy_builder(
6283 provider,
6284 _strategyManager,
6285 _pauserRegistry,
6286 _version,
6287 );
6288 let contract_address = call_builder.deploy().await?;
6289 Ok(Self::new(contract_address, call_builder.provider))
6290 }
6291 #[inline]
6297 pub fn deploy_builder(
6298 provider: P,
6299 _strategyManager: alloy::sol_types::private::Address,
6300 _pauserRegistry: alloy::sol_types::private::Address,
6301 _version: alloy::sol_types::private::String,
6302 ) -> alloy_contract::RawCallBuilder<T, P, N> {
6303 alloy_contract::RawCallBuilder::new_raw_deploy(
6304 provider,
6305 [
6306 &BYTECODE[..],
6307 &alloy_sol_types::SolConstructor::abi_encode(
6308 &constructorCall {
6309 _strategyManager,
6310 _pauserRegistry,
6311 _version,
6312 },
6313 )[..],
6314 ]
6315 .concat()
6316 .into(),
6317 )
6318 }
6319 #[inline]
6321 pub const fn address(&self) -> &alloy_sol_types::private::Address {
6322 &self.address
6323 }
6324 #[inline]
6326 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
6327 self.address = address;
6328 }
6329 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
6331 self.set_address(address);
6332 self
6333 }
6334 #[inline]
6336 pub const fn provider(&self) -> &P {
6337 &self.provider
6338 }
6339 }
6340 impl<T, P: ::core::clone::Clone, N> StrategyBaseInstance<T, &P, N> {
6341 #[inline]
6343 pub fn with_cloned_provider(self) -> StrategyBaseInstance<T, P, N> {
6344 StrategyBaseInstance {
6345 address: self.address,
6346 provider: ::core::clone::Clone::clone(&self.provider),
6347 _network_transport: ::core::marker::PhantomData,
6348 }
6349 }
6350 }
6351 #[automatically_derived]
6353 impl<
6354 T: alloy_contract::private::Transport + ::core::clone::Clone,
6355 P: alloy_contract::private::Provider<T, N>,
6356 N: alloy_contract::private::Network,
6357 > StrategyBaseInstance<T, P, N> {
6358 pub fn call_builder<C: alloy_sol_types::SolCall>(
6363 &self,
6364 call: &C,
6365 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
6366 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
6367 }
6368 pub fn deposit(
6370 &self,
6371 token: alloy::sol_types::private::Address,
6372 amount: alloy::sol_types::private::primitives::aliases::U256,
6373 ) -> alloy_contract::SolCallBuilder<T, &P, depositCall, N> {
6374 self.call_builder(&depositCall { token, amount })
6375 }
6376 pub fn explanation(
6378 &self,
6379 ) -> alloy_contract::SolCallBuilder<T, &P, explanationCall, N> {
6380 self.call_builder(&explanationCall {})
6381 }
6382 pub fn initialize(
6384 &self,
6385 _underlyingToken: alloy::sol_types::private::Address,
6386 ) -> alloy_contract::SolCallBuilder<T, &P, initializeCall, N> {
6387 self.call_builder(&initializeCall { _underlyingToken })
6388 }
6389 pub fn pause(
6391 &self,
6392 newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
6393 ) -> alloy_contract::SolCallBuilder<T, &P, pauseCall, N> {
6394 self.call_builder(&pauseCall { newPausedStatus })
6395 }
6396 pub fn pauseAll(
6398 &self,
6399 ) -> alloy_contract::SolCallBuilder<T, &P, pauseAllCall, N> {
6400 self.call_builder(&pauseAllCall {})
6401 }
6402 pub fn paused_0(
6404 &self,
6405 index: u8,
6406 ) -> alloy_contract::SolCallBuilder<T, &P, paused_0Call, N> {
6407 self.call_builder(&paused_0Call { index })
6408 }
6409 pub fn paused_1(
6411 &self,
6412 ) -> alloy_contract::SolCallBuilder<T, &P, paused_1Call, N> {
6413 self.call_builder(&paused_1Call {})
6414 }
6415 pub fn pauserRegistry(
6417 &self,
6418 ) -> alloy_contract::SolCallBuilder<T, &P, pauserRegistryCall, N> {
6419 self.call_builder(&pauserRegistryCall {})
6420 }
6421 pub fn shares(
6423 &self,
6424 user: alloy::sol_types::private::Address,
6425 ) -> alloy_contract::SolCallBuilder<T, &P, sharesCall, N> {
6426 self.call_builder(&sharesCall { user })
6427 }
6428 pub fn sharesToUnderlying(
6430 &self,
6431 amountShares: alloy::sol_types::private::primitives::aliases::U256,
6432 ) -> alloy_contract::SolCallBuilder<T, &P, sharesToUnderlyingCall, N> {
6433 self.call_builder(
6434 &sharesToUnderlyingCall {
6435 amountShares,
6436 },
6437 )
6438 }
6439 pub fn sharesToUnderlyingView(
6441 &self,
6442 amountShares: alloy::sol_types::private::primitives::aliases::U256,
6443 ) -> alloy_contract::SolCallBuilder<T, &P, sharesToUnderlyingViewCall, N> {
6444 self.call_builder(
6445 &sharesToUnderlyingViewCall {
6446 amountShares,
6447 },
6448 )
6449 }
6450 pub fn strategyManager(
6452 &self,
6453 ) -> alloy_contract::SolCallBuilder<T, &P, strategyManagerCall, N> {
6454 self.call_builder(&strategyManagerCall {})
6455 }
6456 pub fn totalShares(
6458 &self,
6459 ) -> alloy_contract::SolCallBuilder<T, &P, totalSharesCall, N> {
6460 self.call_builder(&totalSharesCall {})
6461 }
6462 pub fn underlyingToShares(
6464 &self,
6465 amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
6466 ) -> alloy_contract::SolCallBuilder<T, &P, underlyingToSharesCall, N> {
6467 self.call_builder(
6468 &underlyingToSharesCall {
6469 amountUnderlying,
6470 },
6471 )
6472 }
6473 pub fn underlyingToSharesView(
6475 &self,
6476 amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
6477 ) -> alloy_contract::SolCallBuilder<T, &P, underlyingToSharesViewCall, N> {
6478 self.call_builder(
6479 &underlyingToSharesViewCall {
6480 amountUnderlying,
6481 },
6482 )
6483 }
6484 pub fn underlyingToken(
6486 &self,
6487 ) -> alloy_contract::SolCallBuilder<T, &P, underlyingTokenCall, N> {
6488 self.call_builder(&underlyingTokenCall {})
6489 }
6490 pub fn unpause(
6492 &self,
6493 newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
6494 ) -> alloy_contract::SolCallBuilder<T, &P, unpauseCall, N> {
6495 self.call_builder(&unpauseCall { newPausedStatus })
6496 }
6497 pub fn userUnderlying(
6499 &self,
6500 user: alloy::sol_types::private::Address,
6501 ) -> alloy_contract::SolCallBuilder<T, &P, userUnderlyingCall, N> {
6502 self.call_builder(&userUnderlyingCall { user })
6503 }
6504 pub fn userUnderlyingView(
6506 &self,
6507 user: alloy::sol_types::private::Address,
6508 ) -> alloy_contract::SolCallBuilder<T, &P, userUnderlyingViewCall, N> {
6509 self.call_builder(&userUnderlyingViewCall { user })
6510 }
6511 pub fn version(&self) -> alloy_contract::SolCallBuilder<T, &P, versionCall, N> {
6513 self.call_builder(&versionCall {})
6514 }
6515 pub fn withdraw(
6517 &self,
6518 recipient: alloy::sol_types::private::Address,
6519 token: alloy::sol_types::private::Address,
6520 amountShares: alloy::sol_types::private::primitives::aliases::U256,
6521 ) -> alloy_contract::SolCallBuilder<T, &P, withdrawCall, N> {
6522 self.call_builder(
6523 &withdrawCall {
6524 recipient,
6525 token,
6526 amountShares,
6527 },
6528 )
6529 }
6530 }
6531 #[automatically_derived]
6533 impl<
6534 T: alloy_contract::private::Transport + ::core::clone::Clone,
6535 P: alloy_contract::private::Provider<T, N>,
6536 N: alloy_contract::private::Network,
6537 > StrategyBaseInstance<T, P, N> {
6538 pub fn event_filter<E: alloy_sol_types::SolEvent>(
6543 &self,
6544 ) -> alloy_contract::Event<T, &P, E, N> {
6545 alloy_contract::Event::new_sol(&self.provider, &self.address)
6546 }
6547 pub fn ExchangeRateEmitted_filter(
6549 &self,
6550 ) -> alloy_contract::Event<T, &P, ExchangeRateEmitted, N> {
6551 self.event_filter::<ExchangeRateEmitted>()
6552 }
6553 pub fn Initialized_filter(
6555 &self,
6556 ) -> alloy_contract::Event<T, &P, Initialized, N> {
6557 self.event_filter::<Initialized>()
6558 }
6559 pub fn Paused_filter(&self) -> alloy_contract::Event<T, &P, Paused, N> {
6561 self.event_filter::<Paused>()
6562 }
6563 pub fn StrategyTokenSet_filter(
6565 &self,
6566 ) -> alloy_contract::Event<T, &P, StrategyTokenSet, N> {
6567 self.event_filter::<StrategyTokenSet>()
6568 }
6569 pub fn Unpaused_filter(&self) -> alloy_contract::Event<T, &P, Unpaused, N> {
6571 self.event_filter::<Unpaused>()
6572 }
6573 }
6574}