1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use ProxyAdmin::*;
3
4#[allow(
177 non_camel_case_types,
178 non_snake_case,
179 clippy::pub_underscore_fields,
180 clippy::style,
181 clippy::empty_structs_with_brackets
182)]
183pub mod ProxyAdmin {
184 use super::*;
185 use alloy::sol_types as alloy_sol_types;
186 #[rustfmt::skip]
192 #[allow(clippy::all)]
193 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
194 b"`\x80`@R4\x80\x15`\x0EW__\xFD[P`\x163`\x1AV[`iV[_\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[a\x06h\x80a\0v_9_\xF3\xFE`\x80`@R`\x046\x10a\0yW_5`\xE0\x1C\x80c\x96#`\x9D\x11a\0LW\x80c\x96#`\x9D\x14a\x01\tW\x80c\x99\xA8\x8E\xC4\x14a\x01\x1CW\x80c\xF2\xFD\xE3\x8B\x14a\x01;W\x80c\xF3\xB7\xDE\xAD\x14a\x01ZW__\xFD[\x80c N\x1Cz\x14a\0}W\x80cqP\x18\xA6\x14a\0\xB8W\x80c~\xFF'^\x14a\0\xCEW\x80c\x8D\xA5\xCB[\x14a\0\xEDW[__\xFD[4\x80\x15a\0\x88W__\xFD[Pa\0\x9Ca\0\x976`\x04a\x04yV[a\x01yV[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\0\xC3W__\xFD[Pa\0\xCCa\x02\x04V[\0[4\x80\x15a\0\xD9W__\xFD[Pa\0\xCCa\0\xE86`\x04a\x04\x9BV[a\x02\x17V[4\x80\x15a\0\xF8W__\xFD[P_T`\x01`\x01`\xA0\x1B\x03\x16a\0\x9CV[a\0\xCCa\x01\x176`\x04a\x04\xE6V[a\x02zV[4\x80\x15a\x01'W__\xFD[Pa\0\xCCa\x0166`\x04a\x04\x9BV[a\x02\xE5V[4\x80\x15a\x01FW__\xFD[Pa\0\xCCa\x01U6`\x04a\x04yV[a\x03\x1BV[4\x80\x15a\x01eW__\xFD[Pa\0\x9Ca\x01t6`\x04a\x04yV[a\x03\x99V[___\x83`\x01`\x01`\xA0\x1B\x03\x16`@Qa\x01\x9D\x90c\\`\xDA\x1B`\xE0\x1B\x81R`\x04\x01\x90V[_`@Q\x80\x83\x03\x81\x85Z\xFA\x91PP=\x80_\x81\x14a\x01\xD5W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01\xDAV[``\x91P[P\x91P\x91P\x81a\x01\xE8W__\xFD[\x80\x80` \x01\x90Q\x81\x01\x90a\x01\xFC\x91\x90a\x05\xBDV[\x94\x93PPPPV[a\x02\x0Ca\x03\xBDV[a\x02\x15_a\x04\x16V[V[a\x02\x1Fa\x03\xBDV[`@Qc\x08\xF2\x83\x97`\xE4\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\x04\x83\x01R\x83\x16\x90c\x8F(9p\x90`$\x01[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02`W__\xFD[PZ\xF1\x15\x80\x15a\x02rW=__>=_\xFD[PPPPPPV[a\x02\x82a\x03\xBDV[`@Qc'\x8FyC`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16\x90cO\x1E\xF2\x86\x904\x90a\x02\xB2\x90\x86\x90\x86\x90`\x04\x01a\x05\xD8V[_`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x02\xC9W__\xFD[PZ\xF1\x15\x80\x15a\x02\xDBW=__>=_\xFD[PPPPPPPPV[a\x02\xEDa\x03\xBDV[`@Qc\x1B,\xE7\xF3`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\x04\x83\x01R\x83\x16\x90c6Y\xCF\xE6\x90`$\x01a\x02IV[a\x03#a\x03\xBDV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x03\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01Reddress`\xD0\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x96\x81a\x04\x16V[PV[___\x83`\x01`\x01`\xA0\x1B\x03\x16`@Qa\x01\x9D\x90c\x03\xE1F\x91`\xE6\x1B\x81R`\x04\x01\x90V[_T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x02\x15W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\x84V[_\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x03\x96W__\xFD[_` \x82\x84\x03\x12\x15a\x04\x89W__\xFD[\x815a\x04\x94\x81a\x04eV[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x04\xACW__\xFD[\x825a\x04\xB7\x81a\x04eV[\x91P` \x83\x015a\x04\xC7\x81a\x04eV[\x80\x91PP\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x04\xF8W__\xFD[\x835a\x05\x03\x81a\x04eV[\x92P` \x84\x015a\x05\x13\x81a\x04eV[\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05.W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x05>W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05XWa\x05Xa\x04\xD2V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x05\x87Wa\x05\x87a\x04\xD2V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x05\x9EW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\xCDW__\xFD[\x81Qa\x04\x94\x81a\x04eV[`\x01\x80`\xA0\x1B\x03\x83\x16\x81R`@` \x82\x01R_\x82Q\x80`@\x84\x01R_[\x81\x81\x10\x15a\x06\x12W` \x81\x86\x01\x81\x01Q``\x86\x84\x01\x01R\x01a\x05\xF5V[P_``\x82\x85\x01\x01R```\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \xA1\xB4.\xA5\xCD[c\xA7#\xDA\xAFp\xDA\xAB>p\x1C\xE3C\x17\x15\xB2\xDC-\xBEM\xA0\x96\\\xCA\x19GdsolcC\0\x08\x1B\x003",
195 );
196 #[rustfmt::skip]
202 #[allow(clippy::all)]
203 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
204 b"`\x80`@R`\x046\x10a\0yW_5`\xE0\x1C\x80c\x96#`\x9D\x11a\0LW\x80c\x96#`\x9D\x14a\x01\tW\x80c\x99\xA8\x8E\xC4\x14a\x01\x1CW\x80c\xF2\xFD\xE3\x8B\x14a\x01;W\x80c\xF3\xB7\xDE\xAD\x14a\x01ZW__\xFD[\x80c N\x1Cz\x14a\0}W\x80cqP\x18\xA6\x14a\0\xB8W\x80c~\xFF'^\x14a\0\xCEW\x80c\x8D\xA5\xCB[\x14a\0\xEDW[__\xFD[4\x80\x15a\0\x88W__\xFD[Pa\0\x9Ca\0\x976`\x04a\x04yV[a\x01yV[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\0\xC3W__\xFD[Pa\0\xCCa\x02\x04V[\0[4\x80\x15a\0\xD9W__\xFD[Pa\0\xCCa\0\xE86`\x04a\x04\x9BV[a\x02\x17V[4\x80\x15a\0\xF8W__\xFD[P_T`\x01`\x01`\xA0\x1B\x03\x16a\0\x9CV[a\0\xCCa\x01\x176`\x04a\x04\xE6V[a\x02zV[4\x80\x15a\x01'W__\xFD[Pa\0\xCCa\x0166`\x04a\x04\x9BV[a\x02\xE5V[4\x80\x15a\x01FW__\xFD[Pa\0\xCCa\x01U6`\x04a\x04yV[a\x03\x1BV[4\x80\x15a\x01eW__\xFD[Pa\0\x9Ca\x01t6`\x04a\x04yV[a\x03\x99V[___\x83`\x01`\x01`\xA0\x1B\x03\x16`@Qa\x01\x9D\x90c\\`\xDA\x1B`\xE0\x1B\x81R`\x04\x01\x90V[_`@Q\x80\x83\x03\x81\x85Z\xFA\x91PP=\x80_\x81\x14a\x01\xD5W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01\xDAV[``\x91P[P\x91P\x91P\x81a\x01\xE8W__\xFD[\x80\x80` \x01\x90Q\x81\x01\x90a\x01\xFC\x91\x90a\x05\xBDV[\x94\x93PPPPV[a\x02\x0Ca\x03\xBDV[a\x02\x15_a\x04\x16V[V[a\x02\x1Fa\x03\xBDV[`@Qc\x08\xF2\x83\x97`\xE4\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\x04\x83\x01R\x83\x16\x90c\x8F(9p\x90`$\x01[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02`W__\xFD[PZ\xF1\x15\x80\x15a\x02rW=__>=_\xFD[PPPPPPV[a\x02\x82a\x03\xBDV[`@Qc'\x8FyC`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16\x90cO\x1E\xF2\x86\x904\x90a\x02\xB2\x90\x86\x90\x86\x90`\x04\x01a\x05\xD8V[_`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x02\xC9W__\xFD[PZ\xF1\x15\x80\x15a\x02\xDBW=__>=_\xFD[PPPPPPPPV[a\x02\xEDa\x03\xBDV[`@Qc\x1B,\xE7\xF3`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x81\x16`\x04\x83\x01R\x83\x16\x90c6Y\xCF\xE6\x90`$\x01a\x02IV[a\x03#a\x03\xBDV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x03\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01Reddress`\xD0\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x96\x81a\x04\x16V[PV[___\x83`\x01`\x01`\xA0\x1B\x03\x16`@Qa\x01\x9D\x90c\x03\xE1F\x91`\xE6\x1B\x81R`\x04\x01\x90V[_T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x02\x15W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\x84V[_\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x03\x96W__\xFD[_` \x82\x84\x03\x12\x15a\x04\x89W__\xFD[\x815a\x04\x94\x81a\x04eV[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x04\xACW__\xFD[\x825a\x04\xB7\x81a\x04eV[\x91P` \x83\x015a\x04\xC7\x81a\x04eV[\x80\x91PP\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x04\xF8W__\xFD[\x835a\x05\x03\x81a\x04eV[\x92P` \x84\x015a\x05\x13\x81a\x04eV[\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05.W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x05>W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05XWa\x05Xa\x04\xD2V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x05\x87Wa\x05\x87a\x04\xD2V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x05\x9EW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\xCDW__\xFD[\x81Qa\x04\x94\x81a\x04eV[`\x01\x80`\xA0\x1B\x03\x83\x16\x81R`@` \x82\x01R_\x82Q\x80`@\x84\x01R_[\x81\x81\x10\x15a\x06\x12W` \x81\x86\x01\x81\x01Q``\x86\x84\x01\x01R\x01a\x05\xF5V[P_``\x82\x85\x01\x01R```\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \xA1\xB4.\xA5\xCD[c\xA7#\xDA\xAFp\xDA\xAB>p\x1C\xE3C\x17\x15\xB2\xDC-\xBEM\xA0\x96\\\xCA\x19GdsolcC\0\x08\x1B\x003",
205 );
206 #[derive(serde::Serialize, serde::Deserialize)]
207 #[derive(Default, Debug, PartialEq, Eq, Hash)]
208 #[allow(
213 non_camel_case_types,
214 non_snake_case,
215 clippy::pub_underscore_fields,
216 clippy::style
217 )]
218 #[derive(Clone)]
219 pub struct OwnershipTransferred {
220 #[allow(missing_docs)]
221 pub previousOwner: alloy::sol_types::private::Address,
222 #[allow(missing_docs)]
223 pub newOwner: alloy::sol_types::private::Address,
224 }
225 #[allow(
226 non_camel_case_types,
227 non_snake_case,
228 clippy::pub_underscore_fields,
229 clippy::style
230 )]
231 const _: () = {
232 use alloy::sol_types as alloy_sol_types;
233 #[automatically_derived]
234 impl alloy_sol_types::SolEvent for OwnershipTransferred {
235 type DataTuple<'a> = ();
236 type DataToken<'a> = <Self::DataTuple<
237 'a,
238 > as alloy_sol_types::SolType>::Token<'a>;
239 type TopicList = (
240 alloy_sol_types::sol_data::FixedBytes<32>,
241 alloy::sol_types::sol_data::Address,
242 alloy::sol_types::sol_data::Address,
243 );
244 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
245 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
246 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
247 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
248 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
249 ]);
250 const ANONYMOUS: bool = false;
251 #[allow(unused_variables)]
252 #[inline]
253 fn new(
254 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
255 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
256 ) -> Self {
257 Self {
258 previousOwner: topics.1,
259 newOwner: topics.2,
260 }
261 }
262 #[inline]
263 fn check_signature(
264 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
265 ) -> alloy_sol_types::Result<()> {
266 if topics.0 != Self::SIGNATURE_HASH {
267 return Err(
268 alloy_sol_types::Error::invalid_event_signature_hash(
269 Self::SIGNATURE,
270 topics.0,
271 Self::SIGNATURE_HASH,
272 ),
273 );
274 }
275 Ok(())
276 }
277 #[inline]
278 fn tokenize_body(&self) -> Self::DataToken<'_> {
279 ()
280 }
281 #[inline]
282 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
283 (
284 Self::SIGNATURE_HASH.into(),
285 self.previousOwner.clone(),
286 self.newOwner.clone(),
287 )
288 }
289 #[inline]
290 fn encode_topics_raw(
291 &self,
292 out: &mut [alloy_sol_types::abi::token::WordToken],
293 ) -> alloy_sol_types::Result<()> {
294 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
295 return Err(alloy_sol_types::Error::Overrun);
296 }
297 out[0usize] = alloy_sol_types::abi::token::WordToken(
298 Self::SIGNATURE_HASH,
299 );
300 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
301 &self.previousOwner,
302 );
303 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
304 &self.newOwner,
305 );
306 Ok(())
307 }
308 }
309 #[automatically_derived]
310 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
311 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
312 From::from(self)
313 }
314 fn into_log_data(self) -> alloy_sol_types::private::LogData {
315 From::from(&self)
316 }
317 }
318 #[automatically_derived]
319 impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
320 #[inline]
321 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
322 alloy_sol_types::SolEvent::encode_log_data(this)
323 }
324 }
325 };
326 #[derive(serde::Serialize, serde::Deserialize)]
327 #[derive(Default, Debug, PartialEq, Eq, Hash)]
328 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
333 #[derive(Clone)]
334 pub struct changeProxyAdminCall {
335 #[allow(missing_docs)]
336 pub proxy: alloy::sol_types::private::Address,
337 #[allow(missing_docs)]
338 pub newAdmin: alloy::sol_types::private::Address,
339 }
340 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
342 #[derive(Clone)]
343 pub struct changeProxyAdminReturn {}
344 #[allow(
345 non_camel_case_types,
346 non_snake_case,
347 clippy::pub_underscore_fields,
348 clippy::style
349 )]
350 const _: () = {
351 use alloy::sol_types as alloy_sol_types;
352 {
353 #[doc(hidden)]
354 type UnderlyingSolTuple<'a> = (
355 alloy::sol_types::sol_data::Address,
356 alloy::sol_types::sol_data::Address,
357 );
358 #[doc(hidden)]
359 type UnderlyingRustTuple<'a> = (
360 alloy::sol_types::private::Address,
361 alloy::sol_types::private::Address,
362 );
363 #[cfg(test)]
364 #[allow(dead_code, unreachable_patterns)]
365 fn _type_assertion(
366 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
367 ) {
368 match _t {
369 alloy_sol_types::private::AssertTypeEq::<
370 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
371 >(_) => {}
372 }
373 }
374 #[automatically_derived]
375 #[doc(hidden)]
376 impl ::core::convert::From<changeProxyAdminCall>
377 for UnderlyingRustTuple<'_> {
378 fn from(value: changeProxyAdminCall) -> Self {
379 (value.proxy, value.newAdmin)
380 }
381 }
382 #[automatically_derived]
383 #[doc(hidden)]
384 impl ::core::convert::From<UnderlyingRustTuple<'_>>
385 for changeProxyAdminCall {
386 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
387 Self {
388 proxy: tuple.0,
389 newAdmin: tuple.1,
390 }
391 }
392 }
393 }
394 {
395 #[doc(hidden)]
396 type UnderlyingSolTuple<'a> = ();
397 #[doc(hidden)]
398 type UnderlyingRustTuple<'a> = ();
399 #[cfg(test)]
400 #[allow(dead_code, unreachable_patterns)]
401 fn _type_assertion(
402 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
403 ) {
404 match _t {
405 alloy_sol_types::private::AssertTypeEq::<
406 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
407 >(_) => {}
408 }
409 }
410 #[automatically_derived]
411 #[doc(hidden)]
412 impl ::core::convert::From<changeProxyAdminReturn>
413 for UnderlyingRustTuple<'_> {
414 fn from(value: changeProxyAdminReturn) -> Self {
415 ()
416 }
417 }
418 #[automatically_derived]
419 #[doc(hidden)]
420 impl ::core::convert::From<UnderlyingRustTuple<'_>>
421 for changeProxyAdminReturn {
422 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
423 Self {}
424 }
425 }
426 }
427 impl changeProxyAdminReturn {
428 fn _tokenize(
429 &self,
430 ) -> <changeProxyAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
431 ()
432 }
433 }
434 #[automatically_derived]
435 impl alloy_sol_types::SolCall for changeProxyAdminCall {
436 type Parameters<'a> = (
437 alloy::sol_types::sol_data::Address,
438 alloy::sol_types::sol_data::Address,
439 );
440 type Token<'a> = <Self::Parameters<
441 'a,
442 > as alloy_sol_types::SolType>::Token<'a>;
443 type Return = changeProxyAdminReturn;
444 type ReturnTuple<'a> = ();
445 type ReturnToken<'a> = <Self::ReturnTuple<
446 'a,
447 > as alloy_sol_types::SolType>::Token<'a>;
448 const SIGNATURE: &'static str = "changeProxyAdmin(address,address)";
449 const SELECTOR: [u8; 4] = [126u8, 255u8, 39u8, 94u8];
450 #[inline]
451 fn new<'a>(
452 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
453 ) -> Self {
454 tuple.into()
455 }
456 #[inline]
457 fn tokenize(&self) -> Self::Token<'_> {
458 (
459 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
460 &self.proxy,
461 ),
462 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
463 &self.newAdmin,
464 ),
465 )
466 }
467 #[inline]
468 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
469 changeProxyAdminReturn::_tokenize(ret)
470 }
471 #[inline]
472 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
473 <Self::ReturnTuple<
474 '_,
475 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
476 .map(Into::into)
477 }
478 #[inline]
479 fn abi_decode_returns_validate(
480 data: &[u8],
481 ) -> alloy_sol_types::Result<Self::Return> {
482 <Self::ReturnTuple<
483 '_,
484 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
485 .map(Into::into)
486 }
487 }
488 };
489 #[derive(serde::Serialize, serde::Deserialize)]
490 #[derive(Default, Debug, PartialEq, Eq, Hash)]
491 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
496 #[derive(Clone)]
497 pub struct getProxyAdminCall {
498 #[allow(missing_docs)]
499 pub proxy: alloy::sol_types::private::Address,
500 }
501 #[derive(serde::Serialize, serde::Deserialize)]
502 #[derive(Default, Debug, PartialEq, Eq, Hash)]
503 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
505 #[derive(Clone)]
506 pub struct getProxyAdminReturn {
507 #[allow(missing_docs)]
508 pub _0: alloy::sol_types::private::Address,
509 }
510 #[allow(
511 non_camel_case_types,
512 non_snake_case,
513 clippy::pub_underscore_fields,
514 clippy::style
515 )]
516 const _: () = {
517 use alloy::sol_types as alloy_sol_types;
518 {
519 #[doc(hidden)]
520 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
521 #[doc(hidden)]
522 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
523 #[cfg(test)]
524 #[allow(dead_code, unreachable_patterns)]
525 fn _type_assertion(
526 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
527 ) {
528 match _t {
529 alloy_sol_types::private::AssertTypeEq::<
530 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
531 >(_) => {}
532 }
533 }
534 #[automatically_derived]
535 #[doc(hidden)]
536 impl ::core::convert::From<getProxyAdminCall> for UnderlyingRustTuple<'_> {
537 fn from(value: getProxyAdminCall) -> Self {
538 (value.proxy,)
539 }
540 }
541 #[automatically_derived]
542 #[doc(hidden)]
543 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProxyAdminCall {
544 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
545 Self { proxy: tuple.0 }
546 }
547 }
548 }
549 {
550 #[doc(hidden)]
551 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
552 #[doc(hidden)]
553 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
554 #[cfg(test)]
555 #[allow(dead_code, unreachable_patterns)]
556 fn _type_assertion(
557 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
558 ) {
559 match _t {
560 alloy_sol_types::private::AssertTypeEq::<
561 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
562 >(_) => {}
563 }
564 }
565 #[automatically_derived]
566 #[doc(hidden)]
567 impl ::core::convert::From<getProxyAdminReturn> for UnderlyingRustTuple<'_> {
568 fn from(value: getProxyAdminReturn) -> Self {
569 (value._0,)
570 }
571 }
572 #[automatically_derived]
573 #[doc(hidden)]
574 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProxyAdminReturn {
575 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
576 Self { _0: tuple.0 }
577 }
578 }
579 }
580 #[automatically_derived]
581 impl alloy_sol_types::SolCall for getProxyAdminCall {
582 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
583 type Token<'a> = <Self::Parameters<
584 'a,
585 > as alloy_sol_types::SolType>::Token<'a>;
586 type Return = alloy::sol_types::private::Address;
587 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
588 type ReturnToken<'a> = <Self::ReturnTuple<
589 'a,
590 > as alloy_sol_types::SolType>::Token<'a>;
591 const SIGNATURE: &'static str = "getProxyAdmin(address)";
592 const SELECTOR: [u8; 4] = [243u8, 183u8, 222u8, 173u8];
593 #[inline]
594 fn new<'a>(
595 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
596 ) -> Self {
597 tuple.into()
598 }
599 #[inline]
600 fn tokenize(&self) -> Self::Token<'_> {
601 (
602 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
603 &self.proxy,
604 ),
605 )
606 }
607 #[inline]
608 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
609 (
610 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
611 ret,
612 ),
613 )
614 }
615 #[inline]
616 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
617 <Self::ReturnTuple<
618 '_,
619 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
620 .map(|r| {
621 let r: getProxyAdminReturn = r.into();
622 r._0
623 })
624 }
625 #[inline]
626 fn abi_decode_returns_validate(
627 data: &[u8],
628 ) -> alloy_sol_types::Result<Self::Return> {
629 <Self::ReturnTuple<
630 '_,
631 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
632 .map(|r| {
633 let r: getProxyAdminReturn = r.into();
634 r._0
635 })
636 }
637 }
638 };
639 #[derive(serde::Serialize, serde::Deserialize)]
640 #[derive(Default, Debug, PartialEq, Eq, Hash)]
641 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
646 #[derive(Clone)]
647 pub struct getProxyImplementationCall {
648 #[allow(missing_docs)]
649 pub proxy: alloy::sol_types::private::Address,
650 }
651 #[derive(serde::Serialize, serde::Deserialize)]
652 #[derive(Default, Debug, PartialEq, Eq, Hash)]
653 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
655 #[derive(Clone)]
656 pub struct getProxyImplementationReturn {
657 #[allow(missing_docs)]
658 pub _0: alloy::sol_types::private::Address,
659 }
660 #[allow(
661 non_camel_case_types,
662 non_snake_case,
663 clippy::pub_underscore_fields,
664 clippy::style
665 )]
666 const _: () = {
667 use alloy::sol_types as alloy_sol_types;
668 {
669 #[doc(hidden)]
670 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
671 #[doc(hidden)]
672 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
673 #[cfg(test)]
674 #[allow(dead_code, unreachable_patterns)]
675 fn _type_assertion(
676 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
677 ) {
678 match _t {
679 alloy_sol_types::private::AssertTypeEq::<
680 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
681 >(_) => {}
682 }
683 }
684 #[automatically_derived]
685 #[doc(hidden)]
686 impl ::core::convert::From<getProxyImplementationCall>
687 for UnderlyingRustTuple<'_> {
688 fn from(value: getProxyImplementationCall) -> Self {
689 (value.proxy,)
690 }
691 }
692 #[automatically_derived]
693 #[doc(hidden)]
694 impl ::core::convert::From<UnderlyingRustTuple<'_>>
695 for getProxyImplementationCall {
696 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
697 Self { proxy: tuple.0 }
698 }
699 }
700 }
701 {
702 #[doc(hidden)]
703 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
704 #[doc(hidden)]
705 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
706 #[cfg(test)]
707 #[allow(dead_code, unreachable_patterns)]
708 fn _type_assertion(
709 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
710 ) {
711 match _t {
712 alloy_sol_types::private::AssertTypeEq::<
713 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
714 >(_) => {}
715 }
716 }
717 #[automatically_derived]
718 #[doc(hidden)]
719 impl ::core::convert::From<getProxyImplementationReturn>
720 for UnderlyingRustTuple<'_> {
721 fn from(value: getProxyImplementationReturn) -> Self {
722 (value._0,)
723 }
724 }
725 #[automatically_derived]
726 #[doc(hidden)]
727 impl ::core::convert::From<UnderlyingRustTuple<'_>>
728 for getProxyImplementationReturn {
729 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
730 Self { _0: tuple.0 }
731 }
732 }
733 }
734 #[automatically_derived]
735 impl alloy_sol_types::SolCall for getProxyImplementationCall {
736 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
737 type Token<'a> = <Self::Parameters<
738 'a,
739 > as alloy_sol_types::SolType>::Token<'a>;
740 type Return = alloy::sol_types::private::Address;
741 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
742 type ReturnToken<'a> = <Self::ReturnTuple<
743 'a,
744 > as alloy_sol_types::SolType>::Token<'a>;
745 const SIGNATURE: &'static str = "getProxyImplementation(address)";
746 const SELECTOR: [u8; 4] = [32u8, 78u8, 28u8, 122u8];
747 #[inline]
748 fn new<'a>(
749 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
750 ) -> Self {
751 tuple.into()
752 }
753 #[inline]
754 fn tokenize(&self) -> Self::Token<'_> {
755 (
756 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
757 &self.proxy,
758 ),
759 )
760 }
761 #[inline]
762 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
763 (
764 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
765 ret,
766 ),
767 )
768 }
769 #[inline]
770 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
771 <Self::ReturnTuple<
772 '_,
773 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
774 .map(|r| {
775 let r: getProxyImplementationReturn = r.into();
776 r._0
777 })
778 }
779 #[inline]
780 fn abi_decode_returns_validate(
781 data: &[u8],
782 ) -> alloy_sol_types::Result<Self::Return> {
783 <Self::ReturnTuple<
784 '_,
785 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
786 .map(|r| {
787 let r: getProxyImplementationReturn = r.into();
788 r._0
789 })
790 }
791 }
792 };
793 #[derive(serde::Serialize, serde::Deserialize)]
794 #[derive(Default, Debug, PartialEq, Eq, Hash)]
795 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
800 #[derive(Clone)]
801 pub struct ownerCall;
802 #[derive(serde::Serialize, serde::Deserialize)]
803 #[derive(Default, Debug, PartialEq, Eq, Hash)]
804 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
806 #[derive(Clone)]
807 pub struct ownerReturn {
808 #[allow(missing_docs)]
809 pub _0: alloy::sol_types::private::Address,
810 }
811 #[allow(
812 non_camel_case_types,
813 non_snake_case,
814 clippy::pub_underscore_fields,
815 clippy::style
816 )]
817 const _: () = {
818 use alloy::sol_types as alloy_sol_types;
819 {
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<ownerCall> for UnderlyingRustTuple<'_> {
838 fn from(value: ownerCall) -> Self {
839 ()
840 }
841 }
842 #[automatically_derived]
843 #[doc(hidden)]
844 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
845 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
846 Self
847 }
848 }
849 }
850 {
851 #[doc(hidden)]
852 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
853 #[doc(hidden)]
854 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
855 #[cfg(test)]
856 #[allow(dead_code, unreachable_patterns)]
857 fn _type_assertion(
858 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
859 ) {
860 match _t {
861 alloy_sol_types::private::AssertTypeEq::<
862 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
863 >(_) => {}
864 }
865 }
866 #[automatically_derived]
867 #[doc(hidden)]
868 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
869 fn from(value: ownerReturn) -> Self {
870 (value._0,)
871 }
872 }
873 #[automatically_derived]
874 #[doc(hidden)]
875 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
876 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
877 Self { _0: tuple.0 }
878 }
879 }
880 }
881 #[automatically_derived]
882 impl alloy_sol_types::SolCall for ownerCall {
883 type Parameters<'a> = ();
884 type Token<'a> = <Self::Parameters<
885 'a,
886 > as alloy_sol_types::SolType>::Token<'a>;
887 type Return = alloy::sol_types::private::Address;
888 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
889 type ReturnToken<'a> = <Self::ReturnTuple<
890 'a,
891 > as alloy_sol_types::SolType>::Token<'a>;
892 const SIGNATURE: &'static str = "owner()";
893 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
894 #[inline]
895 fn new<'a>(
896 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
897 ) -> Self {
898 tuple.into()
899 }
900 #[inline]
901 fn tokenize(&self) -> Self::Token<'_> {
902 ()
903 }
904 #[inline]
905 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
906 (
907 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
908 ret,
909 ),
910 )
911 }
912 #[inline]
913 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
914 <Self::ReturnTuple<
915 '_,
916 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
917 .map(|r| {
918 let r: ownerReturn = r.into();
919 r._0
920 })
921 }
922 #[inline]
923 fn abi_decode_returns_validate(
924 data: &[u8],
925 ) -> alloy_sol_types::Result<Self::Return> {
926 <Self::ReturnTuple<
927 '_,
928 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
929 .map(|r| {
930 let r: ownerReturn = r.into();
931 r._0
932 })
933 }
934 }
935 };
936 #[derive(serde::Serialize, serde::Deserialize)]
937 #[derive(Default, Debug, PartialEq, Eq, Hash)]
938 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
943 #[derive(Clone)]
944 pub struct renounceOwnershipCall;
945 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
947 #[derive(Clone)]
948 pub struct renounceOwnershipReturn {}
949 #[allow(
950 non_camel_case_types,
951 non_snake_case,
952 clippy::pub_underscore_fields,
953 clippy::style
954 )]
955 const _: () = {
956 use alloy::sol_types as alloy_sol_types;
957 {
958 #[doc(hidden)]
959 type UnderlyingSolTuple<'a> = ();
960 #[doc(hidden)]
961 type UnderlyingRustTuple<'a> = ();
962 #[cfg(test)]
963 #[allow(dead_code, unreachable_patterns)]
964 fn _type_assertion(
965 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
966 ) {
967 match _t {
968 alloy_sol_types::private::AssertTypeEq::<
969 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
970 >(_) => {}
971 }
972 }
973 #[automatically_derived]
974 #[doc(hidden)]
975 impl ::core::convert::From<renounceOwnershipCall>
976 for UnderlyingRustTuple<'_> {
977 fn from(value: renounceOwnershipCall) -> Self {
978 ()
979 }
980 }
981 #[automatically_derived]
982 #[doc(hidden)]
983 impl ::core::convert::From<UnderlyingRustTuple<'_>>
984 for renounceOwnershipCall {
985 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
986 Self
987 }
988 }
989 }
990 {
991 #[doc(hidden)]
992 type UnderlyingSolTuple<'a> = ();
993 #[doc(hidden)]
994 type UnderlyingRustTuple<'a> = ();
995 #[cfg(test)]
996 #[allow(dead_code, unreachable_patterns)]
997 fn _type_assertion(
998 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
999 ) {
1000 match _t {
1001 alloy_sol_types::private::AssertTypeEq::<
1002 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1003 >(_) => {}
1004 }
1005 }
1006 #[automatically_derived]
1007 #[doc(hidden)]
1008 impl ::core::convert::From<renounceOwnershipReturn>
1009 for UnderlyingRustTuple<'_> {
1010 fn from(value: renounceOwnershipReturn) -> Self {
1011 ()
1012 }
1013 }
1014 #[automatically_derived]
1015 #[doc(hidden)]
1016 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1017 for renounceOwnershipReturn {
1018 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1019 Self {}
1020 }
1021 }
1022 }
1023 impl renounceOwnershipReturn {
1024 fn _tokenize(
1025 &self,
1026 ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1027 ()
1028 }
1029 }
1030 #[automatically_derived]
1031 impl alloy_sol_types::SolCall for renounceOwnershipCall {
1032 type Parameters<'a> = ();
1033 type Token<'a> = <Self::Parameters<
1034 'a,
1035 > as alloy_sol_types::SolType>::Token<'a>;
1036 type Return = renounceOwnershipReturn;
1037 type ReturnTuple<'a> = ();
1038 type ReturnToken<'a> = <Self::ReturnTuple<
1039 'a,
1040 > as alloy_sol_types::SolType>::Token<'a>;
1041 const SIGNATURE: &'static str = "renounceOwnership()";
1042 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
1043 #[inline]
1044 fn new<'a>(
1045 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1046 ) -> Self {
1047 tuple.into()
1048 }
1049 #[inline]
1050 fn tokenize(&self) -> Self::Token<'_> {
1051 ()
1052 }
1053 #[inline]
1054 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1055 renounceOwnershipReturn::_tokenize(ret)
1056 }
1057 #[inline]
1058 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1059 <Self::ReturnTuple<
1060 '_,
1061 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1062 .map(Into::into)
1063 }
1064 #[inline]
1065 fn abi_decode_returns_validate(
1066 data: &[u8],
1067 ) -> alloy_sol_types::Result<Self::Return> {
1068 <Self::ReturnTuple<
1069 '_,
1070 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1071 .map(Into::into)
1072 }
1073 }
1074 };
1075 #[derive(serde::Serialize, serde::Deserialize)]
1076 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1077 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1082 #[derive(Clone)]
1083 pub struct transferOwnershipCall {
1084 #[allow(missing_docs)]
1085 pub newOwner: alloy::sol_types::private::Address,
1086 }
1087 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1089 #[derive(Clone)]
1090 pub struct transferOwnershipReturn {}
1091 #[allow(
1092 non_camel_case_types,
1093 non_snake_case,
1094 clippy::pub_underscore_fields,
1095 clippy::style
1096 )]
1097 const _: () = {
1098 use alloy::sol_types as alloy_sol_types;
1099 {
1100 #[doc(hidden)]
1101 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1102 #[doc(hidden)]
1103 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1104 #[cfg(test)]
1105 #[allow(dead_code, unreachable_patterns)]
1106 fn _type_assertion(
1107 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1108 ) {
1109 match _t {
1110 alloy_sol_types::private::AssertTypeEq::<
1111 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1112 >(_) => {}
1113 }
1114 }
1115 #[automatically_derived]
1116 #[doc(hidden)]
1117 impl ::core::convert::From<transferOwnershipCall>
1118 for UnderlyingRustTuple<'_> {
1119 fn from(value: transferOwnershipCall) -> Self {
1120 (value.newOwner,)
1121 }
1122 }
1123 #[automatically_derived]
1124 #[doc(hidden)]
1125 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1126 for transferOwnershipCall {
1127 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1128 Self { newOwner: tuple.0 }
1129 }
1130 }
1131 }
1132 {
1133 #[doc(hidden)]
1134 type UnderlyingSolTuple<'a> = ();
1135 #[doc(hidden)]
1136 type UnderlyingRustTuple<'a> = ();
1137 #[cfg(test)]
1138 #[allow(dead_code, unreachable_patterns)]
1139 fn _type_assertion(
1140 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1141 ) {
1142 match _t {
1143 alloy_sol_types::private::AssertTypeEq::<
1144 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1145 >(_) => {}
1146 }
1147 }
1148 #[automatically_derived]
1149 #[doc(hidden)]
1150 impl ::core::convert::From<transferOwnershipReturn>
1151 for UnderlyingRustTuple<'_> {
1152 fn from(value: transferOwnershipReturn) -> Self {
1153 ()
1154 }
1155 }
1156 #[automatically_derived]
1157 #[doc(hidden)]
1158 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1159 for transferOwnershipReturn {
1160 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1161 Self {}
1162 }
1163 }
1164 }
1165 impl transferOwnershipReturn {
1166 fn _tokenize(
1167 &self,
1168 ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1169 ()
1170 }
1171 }
1172 #[automatically_derived]
1173 impl alloy_sol_types::SolCall for transferOwnershipCall {
1174 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1175 type Token<'a> = <Self::Parameters<
1176 'a,
1177 > as alloy_sol_types::SolType>::Token<'a>;
1178 type Return = transferOwnershipReturn;
1179 type ReturnTuple<'a> = ();
1180 type ReturnToken<'a> = <Self::ReturnTuple<
1181 'a,
1182 > as alloy_sol_types::SolType>::Token<'a>;
1183 const SIGNATURE: &'static str = "transferOwnership(address)";
1184 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
1185 #[inline]
1186 fn new<'a>(
1187 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1188 ) -> Self {
1189 tuple.into()
1190 }
1191 #[inline]
1192 fn tokenize(&self) -> Self::Token<'_> {
1193 (
1194 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1195 &self.newOwner,
1196 ),
1197 )
1198 }
1199 #[inline]
1200 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1201 transferOwnershipReturn::_tokenize(ret)
1202 }
1203 #[inline]
1204 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1205 <Self::ReturnTuple<
1206 '_,
1207 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1208 .map(Into::into)
1209 }
1210 #[inline]
1211 fn abi_decode_returns_validate(
1212 data: &[u8],
1213 ) -> alloy_sol_types::Result<Self::Return> {
1214 <Self::ReturnTuple<
1215 '_,
1216 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1217 .map(Into::into)
1218 }
1219 }
1220 };
1221 #[derive(serde::Serialize, serde::Deserialize)]
1222 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1223 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1228 #[derive(Clone)]
1229 pub struct upgradeCall {
1230 #[allow(missing_docs)]
1231 pub proxy: alloy::sol_types::private::Address,
1232 #[allow(missing_docs)]
1233 pub implementation: alloy::sol_types::private::Address,
1234 }
1235 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1237 #[derive(Clone)]
1238 pub struct upgradeReturn {}
1239 #[allow(
1240 non_camel_case_types,
1241 non_snake_case,
1242 clippy::pub_underscore_fields,
1243 clippy::style
1244 )]
1245 const _: () = {
1246 use alloy::sol_types as alloy_sol_types;
1247 {
1248 #[doc(hidden)]
1249 type UnderlyingSolTuple<'a> = (
1250 alloy::sol_types::sol_data::Address,
1251 alloy::sol_types::sol_data::Address,
1252 );
1253 #[doc(hidden)]
1254 type UnderlyingRustTuple<'a> = (
1255 alloy::sol_types::private::Address,
1256 alloy::sol_types::private::Address,
1257 );
1258 #[cfg(test)]
1259 #[allow(dead_code, unreachable_patterns)]
1260 fn _type_assertion(
1261 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1262 ) {
1263 match _t {
1264 alloy_sol_types::private::AssertTypeEq::<
1265 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1266 >(_) => {}
1267 }
1268 }
1269 #[automatically_derived]
1270 #[doc(hidden)]
1271 impl ::core::convert::From<upgradeCall> for UnderlyingRustTuple<'_> {
1272 fn from(value: upgradeCall) -> Self {
1273 (value.proxy, value.implementation)
1274 }
1275 }
1276 #[automatically_derived]
1277 #[doc(hidden)]
1278 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeCall {
1279 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1280 Self {
1281 proxy: tuple.0,
1282 implementation: tuple.1,
1283 }
1284 }
1285 }
1286 }
1287 {
1288 #[doc(hidden)]
1289 type UnderlyingSolTuple<'a> = ();
1290 #[doc(hidden)]
1291 type UnderlyingRustTuple<'a> = ();
1292 #[cfg(test)]
1293 #[allow(dead_code, unreachable_patterns)]
1294 fn _type_assertion(
1295 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1296 ) {
1297 match _t {
1298 alloy_sol_types::private::AssertTypeEq::<
1299 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1300 >(_) => {}
1301 }
1302 }
1303 #[automatically_derived]
1304 #[doc(hidden)]
1305 impl ::core::convert::From<upgradeReturn> for UnderlyingRustTuple<'_> {
1306 fn from(value: upgradeReturn) -> Self {
1307 ()
1308 }
1309 }
1310 #[automatically_derived]
1311 #[doc(hidden)]
1312 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeReturn {
1313 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1314 Self {}
1315 }
1316 }
1317 }
1318 impl upgradeReturn {
1319 fn _tokenize(
1320 &self,
1321 ) -> <upgradeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1322 ()
1323 }
1324 }
1325 #[automatically_derived]
1326 impl alloy_sol_types::SolCall for upgradeCall {
1327 type Parameters<'a> = (
1328 alloy::sol_types::sol_data::Address,
1329 alloy::sol_types::sol_data::Address,
1330 );
1331 type Token<'a> = <Self::Parameters<
1332 'a,
1333 > as alloy_sol_types::SolType>::Token<'a>;
1334 type Return = upgradeReturn;
1335 type ReturnTuple<'a> = ();
1336 type ReturnToken<'a> = <Self::ReturnTuple<
1337 'a,
1338 > as alloy_sol_types::SolType>::Token<'a>;
1339 const SIGNATURE: &'static str = "upgrade(address,address)";
1340 const SELECTOR: [u8; 4] = [153u8, 168u8, 142u8, 196u8];
1341 #[inline]
1342 fn new<'a>(
1343 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1344 ) -> Self {
1345 tuple.into()
1346 }
1347 #[inline]
1348 fn tokenize(&self) -> Self::Token<'_> {
1349 (
1350 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1351 &self.proxy,
1352 ),
1353 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1354 &self.implementation,
1355 ),
1356 )
1357 }
1358 #[inline]
1359 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1360 upgradeReturn::_tokenize(ret)
1361 }
1362 #[inline]
1363 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1364 <Self::ReturnTuple<
1365 '_,
1366 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1367 .map(Into::into)
1368 }
1369 #[inline]
1370 fn abi_decode_returns_validate(
1371 data: &[u8],
1372 ) -> alloy_sol_types::Result<Self::Return> {
1373 <Self::ReturnTuple<
1374 '_,
1375 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1376 .map(Into::into)
1377 }
1378 }
1379 };
1380 #[derive(serde::Serialize, serde::Deserialize)]
1381 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1382 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1387 #[derive(Clone)]
1388 pub struct upgradeAndCallCall {
1389 #[allow(missing_docs)]
1390 pub proxy: alloy::sol_types::private::Address,
1391 #[allow(missing_docs)]
1392 pub implementation: alloy::sol_types::private::Address,
1393 #[allow(missing_docs)]
1394 pub data: alloy::sol_types::private::Bytes,
1395 }
1396 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1398 #[derive(Clone)]
1399 pub struct upgradeAndCallReturn {}
1400 #[allow(
1401 non_camel_case_types,
1402 non_snake_case,
1403 clippy::pub_underscore_fields,
1404 clippy::style
1405 )]
1406 const _: () = {
1407 use alloy::sol_types as alloy_sol_types;
1408 {
1409 #[doc(hidden)]
1410 type UnderlyingSolTuple<'a> = (
1411 alloy::sol_types::sol_data::Address,
1412 alloy::sol_types::sol_data::Address,
1413 alloy::sol_types::sol_data::Bytes,
1414 );
1415 #[doc(hidden)]
1416 type UnderlyingRustTuple<'a> = (
1417 alloy::sol_types::private::Address,
1418 alloy::sol_types::private::Address,
1419 alloy::sol_types::private::Bytes,
1420 );
1421 #[cfg(test)]
1422 #[allow(dead_code, unreachable_patterns)]
1423 fn _type_assertion(
1424 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1425 ) {
1426 match _t {
1427 alloy_sol_types::private::AssertTypeEq::<
1428 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1429 >(_) => {}
1430 }
1431 }
1432 #[automatically_derived]
1433 #[doc(hidden)]
1434 impl ::core::convert::From<upgradeAndCallCall> for UnderlyingRustTuple<'_> {
1435 fn from(value: upgradeAndCallCall) -> Self {
1436 (value.proxy, value.implementation, value.data)
1437 }
1438 }
1439 #[automatically_derived]
1440 #[doc(hidden)]
1441 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeAndCallCall {
1442 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1443 Self {
1444 proxy: tuple.0,
1445 implementation: tuple.1,
1446 data: tuple.2,
1447 }
1448 }
1449 }
1450 }
1451 {
1452 #[doc(hidden)]
1453 type UnderlyingSolTuple<'a> = ();
1454 #[doc(hidden)]
1455 type UnderlyingRustTuple<'a> = ();
1456 #[cfg(test)]
1457 #[allow(dead_code, unreachable_patterns)]
1458 fn _type_assertion(
1459 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1460 ) {
1461 match _t {
1462 alloy_sol_types::private::AssertTypeEq::<
1463 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1464 >(_) => {}
1465 }
1466 }
1467 #[automatically_derived]
1468 #[doc(hidden)]
1469 impl ::core::convert::From<upgradeAndCallReturn>
1470 for UnderlyingRustTuple<'_> {
1471 fn from(value: upgradeAndCallReturn) -> Self {
1472 ()
1473 }
1474 }
1475 #[automatically_derived]
1476 #[doc(hidden)]
1477 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1478 for upgradeAndCallReturn {
1479 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1480 Self {}
1481 }
1482 }
1483 }
1484 impl upgradeAndCallReturn {
1485 fn _tokenize(
1486 &self,
1487 ) -> <upgradeAndCallCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1488 ()
1489 }
1490 }
1491 #[automatically_derived]
1492 impl alloy_sol_types::SolCall for upgradeAndCallCall {
1493 type Parameters<'a> = (
1494 alloy::sol_types::sol_data::Address,
1495 alloy::sol_types::sol_data::Address,
1496 alloy::sol_types::sol_data::Bytes,
1497 );
1498 type Token<'a> = <Self::Parameters<
1499 'a,
1500 > as alloy_sol_types::SolType>::Token<'a>;
1501 type Return = upgradeAndCallReturn;
1502 type ReturnTuple<'a> = ();
1503 type ReturnToken<'a> = <Self::ReturnTuple<
1504 'a,
1505 > as alloy_sol_types::SolType>::Token<'a>;
1506 const SIGNATURE: &'static str = "upgradeAndCall(address,address,bytes)";
1507 const SELECTOR: [u8; 4] = [150u8, 35u8, 96u8, 157u8];
1508 #[inline]
1509 fn new<'a>(
1510 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1511 ) -> Self {
1512 tuple.into()
1513 }
1514 #[inline]
1515 fn tokenize(&self) -> Self::Token<'_> {
1516 (
1517 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1518 &self.proxy,
1519 ),
1520 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1521 &self.implementation,
1522 ),
1523 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1524 &self.data,
1525 ),
1526 )
1527 }
1528 #[inline]
1529 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1530 upgradeAndCallReturn::_tokenize(ret)
1531 }
1532 #[inline]
1533 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1534 <Self::ReturnTuple<
1535 '_,
1536 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1537 .map(Into::into)
1538 }
1539 #[inline]
1540 fn abi_decode_returns_validate(
1541 data: &[u8],
1542 ) -> alloy_sol_types::Result<Self::Return> {
1543 <Self::ReturnTuple<
1544 '_,
1545 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1546 .map(Into::into)
1547 }
1548 }
1549 };
1550 #[derive(serde::Serialize, serde::Deserialize)]
1552 #[derive()]
1553 pub enum ProxyAdminCalls {
1554 #[allow(missing_docs)]
1555 changeProxyAdmin(changeProxyAdminCall),
1556 #[allow(missing_docs)]
1557 getProxyAdmin(getProxyAdminCall),
1558 #[allow(missing_docs)]
1559 getProxyImplementation(getProxyImplementationCall),
1560 #[allow(missing_docs)]
1561 owner(ownerCall),
1562 #[allow(missing_docs)]
1563 renounceOwnership(renounceOwnershipCall),
1564 #[allow(missing_docs)]
1565 transferOwnership(transferOwnershipCall),
1566 #[allow(missing_docs)]
1567 upgrade(upgradeCall),
1568 #[allow(missing_docs)]
1569 upgradeAndCall(upgradeAndCallCall),
1570 }
1571 #[automatically_derived]
1572 impl ProxyAdminCalls {
1573 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1580 [32u8, 78u8, 28u8, 122u8],
1581 [113u8, 80u8, 24u8, 166u8],
1582 [126u8, 255u8, 39u8, 94u8],
1583 [141u8, 165u8, 203u8, 91u8],
1584 [150u8, 35u8, 96u8, 157u8],
1585 [153u8, 168u8, 142u8, 196u8],
1586 [242u8, 253u8, 227u8, 139u8],
1587 [243u8, 183u8, 222u8, 173u8],
1588 ];
1589 }
1590 #[automatically_derived]
1591 impl alloy_sol_types::SolInterface for ProxyAdminCalls {
1592 const NAME: &'static str = "ProxyAdminCalls";
1593 const MIN_DATA_LENGTH: usize = 0usize;
1594 const COUNT: usize = 8usize;
1595 #[inline]
1596 fn selector(&self) -> [u8; 4] {
1597 match self {
1598 Self::changeProxyAdmin(_) => {
1599 <changeProxyAdminCall as alloy_sol_types::SolCall>::SELECTOR
1600 }
1601 Self::getProxyAdmin(_) => {
1602 <getProxyAdminCall as alloy_sol_types::SolCall>::SELECTOR
1603 }
1604 Self::getProxyImplementation(_) => {
1605 <getProxyImplementationCall as alloy_sol_types::SolCall>::SELECTOR
1606 }
1607 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
1608 Self::renounceOwnership(_) => {
1609 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1610 }
1611 Self::transferOwnership(_) => {
1612 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1613 }
1614 Self::upgrade(_) => <upgradeCall as alloy_sol_types::SolCall>::SELECTOR,
1615 Self::upgradeAndCall(_) => {
1616 <upgradeAndCallCall as alloy_sol_types::SolCall>::SELECTOR
1617 }
1618 }
1619 }
1620 #[inline]
1621 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1622 Self::SELECTORS.get(i).copied()
1623 }
1624 #[inline]
1625 fn valid_selector(selector: [u8; 4]) -> bool {
1626 Self::SELECTORS.binary_search(&selector).is_ok()
1627 }
1628 #[inline]
1629 #[allow(non_snake_case)]
1630 fn abi_decode_raw(
1631 selector: [u8; 4],
1632 data: &[u8],
1633 ) -> alloy_sol_types::Result<Self> {
1634 static DECODE_SHIMS: &[fn(
1635 &[u8],
1636 ) -> alloy_sol_types::Result<ProxyAdminCalls>] = &[
1637 {
1638 fn getProxyImplementation(
1639 data: &[u8],
1640 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1641 <getProxyImplementationCall as alloy_sol_types::SolCall>::abi_decode_raw(
1642 data,
1643 )
1644 .map(ProxyAdminCalls::getProxyImplementation)
1645 }
1646 getProxyImplementation
1647 },
1648 {
1649 fn renounceOwnership(
1650 data: &[u8],
1651 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1652 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
1653 data,
1654 )
1655 .map(ProxyAdminCalls::renounceOwnership)
1656 }
1657 renounceOwnership
1658 },
1659 {
1660 fn changeProxyAdmin(
1661 data: &[u8],
1662 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1663 <changeProxyAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
1664 data,
1665 )
1666 .map(ProxyAdminCalls::changeProxyAdmin)
1667 }
1668 changeProxyAdmin
1669 },
1670 {
1671 fn owner(data: &[u8]) -> alloy_sol_types::Result<ProxyAdminCalls> {
1672 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
1673 .map(ProxyAdminCalls::owner)
1674 }
1675 owner
1676 },
1677 {
1678 fn upgradeAndCall(
1679 data: &[u8],
1680 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1681 <upgradeAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(
1682 data,
1683 )
1684 .map(ProxyAdminCalls::upgradeAndCall)
1685 }
1686 upgradeAndCall
1687 },
1688 {
1689 fn upgrade(data: &[u8]) -> alloy_sol_types::Result<ProxyAdminCalls> {
1690 <upgradeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
1691 .map(ProxyAdminCalls::upgrade)
1692 }
1693 upgrade
1694 },
1695 {
1696 fn transferOwnership(
1697 data: &[u8],
1698 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1699 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
1700 data,
1701 )
1702 .map(ProxyAdminCalls::transferOwnership)
1703 }
1704 transferOwnership
1705 },
1706 {
1707 fn getProxyAdmin(
1708 data: &[u8],
1709 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1710 <getProxyAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
1711 data,
1712 )
1713 .map(ProxyAdminCalls::getProxyAdmin)
1714 }
1715 getProxyAdmin
1716 },
1717 ];
1718 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1719 return Err(
1720 alloy_sol_types::Error::unknown_selector(
1721 <Self as alloy_sol_types::SolInterface>::NAME,
1722 selector,
1723 ),
1724 );
1725 };
1726 DECODE_SHIMS[idx](data)
1727 }
1728 #[inline]
1729 #[allow(non_snake_case)]
1730 fn abi_decode_raw_validate(
1731 selector: [u8; 4],
1732 data: &[u8],
1733 ) -> alloy_sol_types::Result<Self> {
1734 static DECODE_VALIDATE_SHIMS: &[fn(
1735 &[u8],
1736 ) -> alloy_sol_types::Result<ProxyAdminCalls>] = &[
1737 {
1738 fn getProxyImplementation(
1739 data: &[u8],
1740 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1741 <getProxyImplementationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1742 data,
1743 )
1744 .map(ProxyAdminCalls::getProxyImplementation)
1745 }
1746 getProxyImplementation
1747 },
1748 {
1749 fn renounceOwnership(
1750 data: &[u8],
1751 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1752 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1753 data,
1754 )
1755 .map(ProxyAdminCalls::renounceOwnership)
1756 }
1757 renounceOwnership
1758 },
1759 {
1760 fn changeProxyAdmin(
1761 data: &[u8],
1762 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1763 <changeProxyAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1764 data,
1765 )
1766 .map(ProxyAdminCalls::changeProxyAdmin)
1767 }
1768 changeProxyAdmin
1769 },
1770 {
1771 fn owner(data: &[u8]) -> alloy_sol_types::Result<ProxyAdminCalls> {
1772 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1773 data,
1774 )
1775 .map(ProxyAdminCalls::owner)
1776 }
1777 owner
1778 },
1779 {
1780 fn upgradeAndCall(
1781 data: &[u8],
1782 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1783 <upgradeAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1784 data,
1785 )
1786 .map(ProxyAdminCalls::upgradeAndCall)
1787 }
1788 upgradeAndCall
1789 },
1790 {
1791 fn upgrade(data: &[u8]) -> alloy_sol_types::Result<ProxyAdminCalls> {
1792 <upgradeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1793 data,
1794 )
1795 .map(ProxyAdminCalls::upgrade)
1796 }
1797 upgrade
1798 },
1799 {
1800 fn transferOwnership(
1801 data: &[u8],
1802 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1803 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1804 data,
1805 )
1806 .map(ProxyAdminCalls::transferOwnership)
1807 }
1808 transferOwnership
1809 },
1810 {
1811 fn getProxyAdmin(
1812 data: &[u8],
1813 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1814 <getProxyAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1815 data,
1816 )
1817 .map(ProxyAdminCalls::getProxyAdmin)
1818 }
1819 getProxyAdmin
1820 },
1821 ];
1822 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1823 return Err(
1824 alloy_sol_types::Error::unknown_selector(
1825 <Self as alloy_sol_types::SolInterface>::NAME,
1826 selector,
1827 ),
1828 );
1829 };
1830 DECODE_VALIDATE_SHIMS[idx](data)
1831 }
1832 #[inline]
1833 fn abi_encoded_size(&self) -> usize {
1834 match self {
1835 Self::changeProxyAdmin(inner) => {
1836 <changeProxyAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
1837 inner,
1838 )
1839 }
1840 Self::getProxyAdmin(inner) => {
1841 <getProxyAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
1842 inner,
1843 )
1844 }
1845 Self::getProxyImplementation(inner) => {
1846 <getProxyImplementationCall as alloy_sol_types::SolCall>::abi_encoded_size(
1847 inner,
1848 )
1849 }
1850 Self::owner(inner) => {
1851 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1852 }
1853 Self::renounceOwnership(inner) => {
1854 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
1855 inner,
1856 )
1857 }
1858 Self::transferOwnership(inner) => {
1859 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
1860 inner,
1861 )
1862 }
1863 Self::upgrade(inner) => {
1864 <upgradeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1865 }
1866 Self::upgradeAndCall(inner) => {
1867 <upgradeAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(
1868 inner,
1869 )
1870 }
1871 }
1872 }
1873 #[inline]
1874 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1875 match self {
1876 Self::changeProxyAdmin(inner) => {
1877 <changeProxyAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
1878 inner,
1879 out,
1880 )
1881 }
1882 Self::getProxyAdmin(inner) => {
1883 <getProxyAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
1884 inner,
1885 out,
1886 )
1887 }
1888 Self::getProxyImplementation(inner) => {
1889 <getProxyImplementationCall as alloy_sol_types::SolCall>::abi_encode_raw(
1890 inner,
1891 out,
1892 )
1893 }
1894 Self::owner(inner) => {
1895 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
1896 }
1897 Self::renounceOwnership(inner) => {
1898 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
1899 inner,
1900 out,
1901 )
1902 }
1903 Self::transferOwnership(inner) => {
1904 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
1905 inner,
1906 out,
1907 )
1908 }
1909 Self::upgrade(inner) => {
1910 <upgradeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
1911 }
1912 Self::upgradeAndCall(inner) => {
1913 <upgradeAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(
1914 inner,
1915 out,
1916 )
1917 }
1918 }
1919 }
1920 }
1921 #[derive(serde::Serialize, serde::Deserialize)]
1923 #[derive(Debug, PartialEq, Eq, Hash)]
1924 pub enum ProxyAdminEvents {
1925 #[allow(missing_docs)]
1926 OwnershipTransferred(OwnershipTransferred),
1927 }
1928 #[automatically_derived]
1929 impl ProxyAdminEvents {
1930 pub const SELECTORS: &'static [[u8; 32usize]] = &[
1937 [
1938 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
1939 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
1940 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
1941 ],
1942 ];
1943 }
1944 #[automatically_derived]
1945 impl alloy_sol_types::SolEventInterface for ProxyAdminEvents {
1946 const NAME: &'static str = "ProxyAdminEvents";
1947 const COUNT: usize = 1usize;
1948 fn decode_raw_log(
1949 topics: &[alloy_sol_types::Word],
1950 data: &[u8],
1951 ) -> alloy_sol_types::Result<Self> {
1952 match topics.first().copied() {
1953 Some(
1954 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
1955 ) => {
1956 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
1957 topics,
1958 data,
1959 )
1960 .map(Self::OwnershipTransferred)
1961 }
1962 _ => {
1963 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
1964 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
1965 log: alloy_sol_types::private::Box::new(
1966 alloy_sol_types::private::LogData::new_unchecked(
1967 topics.to_vec(),
1968 data.to_vec().into(),
1969 ),
1970 ),
1971 })
1972 }
1973 }
1974 }
1975 }
1976 #[automatically_derived]
1977 impl alloy_sol_types::private::IntoLogData for ProxyAdminEvents {
1978 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1979 match self {
1980 Self::OwnershipTransferred(inner) => {
1981 alloy_sol_types::private::IntoLogData::to_log_data(inner)
1982 }
1983 }
1984 }
1985 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1986 match self {
1987 Self::OwnershipTransferred(inner) => {
1988 alloy_sol_types::private::IntoLogData::into_log_data(inner)
1989 }
1990 }
1991 }
1992 }
1993 use alloy::contract as alloy_contract;
1994 #[inline]
1998 pub const fn new<
1999 P: alloy_contract::private::Provider<N>,
2000 N: alloy_contract::private::Network,
2001 >(
2002 address: alloy_sol_types::private::Address,
2003 provider: P,
2004 ) -> ProxyAdminInstance<P, N> {
2005 ProxyAdminInstance::<P, N>::new(address, provider)
2006 }
2007 #[inline]
2013 pub fn deploy<
2014 P: alloy_contract::private::Provider<N>,
2015 N: alloy_contract::private::Network,
2016 >(
2017 provider: P,
2018 ) -> impl ::core::future::Future<
2019 Output = alloy_contract::Result<ProxyAdminInstance<P, N>>,
2020 > {
2021 ProxyAdminInstance::<P, N>::deploy(provider)
2022 }
2023 #[inline]
2029 pub fn deploy_builder<
2030 P: alloy_contract::private::Provider<N>,
2031 N: alloy_contract::private::Network,
2032 >(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
2033 ProxyAdminInstance::<P, N>::deploy_builder(provider)
2034 }
2035 #[derive(Clone)]
2047 pub struct ProxyAdminInstance<P, N = alloy_contract::private::Ethereum> {
2048 address: alloy_sol_types::private::Address,
2049 provider: P,
2050 _network: ::core::marker::PhantomData<N>,
2051 }
2052 #[automatically_derived]
2053 impl<P, N> ::core::fmt::Debug for ProxyAdminInstance<P, N> {
2054 #[inline]
2055 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2056 f.debug_tuple("ProxyAdminInstance").field(&self.address).finish()
2057 }
2058 }
2059 #[automatically_derived]
2061 impl<
2062 P: alloy_contract::private::Provider<N>,
2063 N: alloy_contract::private::Network,
2064 > ProxyAdminInstance<P, N> {
2065 #[inline]
2069 pub const fn new(
2070 address: alloy_sol_types::private::Address,
2071 provider: P,
2072 ) -> Self {
2073 Self {
2074 address,
2075 provider,
2076 _network: ::core::marker::PhantomData,
2077 }
2078 }
2079 #[inline]
2085 pub async fn deploy(
2086 provider: P,
2087 ) -> alloy_contract::Result<ProxyAdminInstance<P, N>> {
2088 let call_builder = Self::deploy_builder(provider);
2089 let contract_address = call_builder.deploy().await?;
2090 Ok(Self::new(contract_address, call_builder.provider))
2091 }
2092 #[inline]
2098 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
2099 alloy_contract::RawCallBuilder::new_raw_deploy(
2100 provider,
2101 ::core::clone::Clone::clone(&BYTECODE),
2102 )
2103 }
2104 #[inline]
2106 pub const fn address(&self) -> &alloy_sol_types::private::Address {
2107 &self.address
2108 }
2109 #[inline]
2111 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
2112 self.address = address;
2113 }
2114 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
2116 self.set_address(address);
2117 self
2118 }
2119 #[inline]
2121 pub const fn provider(&self) -> &P {
2122 &self.provider
2123 }
2124 }
2125 impl<P: ::core::clone::Clone, N> ProxyAdminInstance<&P, N> {
2126 #[inline]
2128 pub fn with_cloned_provider(self) -> ProxyAdminInstance<P, N> {
2129 ProxyAdminInstance {
2130 address: self.address,
2131 provider: ::core::clone::Clone::clone(&self.provider),
2132 _network: ::core::marker::PhantomData,
2133 }
2134 }
2135 }
2136 #[automatically_derived]
2138 impl<
2139 P: alloy_contract::private::Provider<N>,
2140 N: alloy_contract::private::Network,
2141 > ProxyAdminInstance<P, N> {
2142 pub fn call_builder<C: alloy_sol_types::SolCall>(
2147 &self,
2148 call: &C,
2149 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
2150 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
2151 }
2152 pub fn changeProxyAdmin(
2154 &self,
2155 proxy: alloy::sol_types::private::Address,
2156 newAdmin: alloy::sol_types::private::Address,
2157 ) -> alloy_contract::SolCallBuilder<&P, changeProxyAdminCall, N> {
2158 self.call_builder(
2159 &changeProxyAdminCall {
2160 proxy,
2161 newAdmin,
2162 },
2163 )
2164 }
2165 pub fn getProxyAdmin(
2167 &self,
2168 proxy: alloy::sol_types::private::Address,
2169 ) -> alloy_contract::SolCallBuilder<&P, getProxyAdminCall, N> {
2170 self.call_builder(&getProxyAdminCall { proxy })
2171 }
2172 pub fn getProxyImplementation(
2174 &self,
2175 proxy: alloy::sol_types::private::Address,
2176 ) -> alloy_contract::SolCallBuilder<&P, getProxyImplementationCall, N> {
2177 self.call_builder(
2178 &getProxyImplementationCall {
2179 proxy,
2180 },
2181 )
2182 }
2183 pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
2185 self.call_builder(&ownerCall)
2186 }
2187 pub fn renounceOwnership(
2189 &self,
2190 ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
2191 self.call_builder(&renounceOwnershipCall)
2192 }
2193 pub fn transferOwnership(
2195 &self,
2196 newOwner: alloy::sol_types::private::Address,
2197 ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
2198 self.call_builder(&transferOwnershipCall { newOwner })
2199 }
2200 pub fn upgrade(
2202 &self,
2203 proxy: alloy::sol_types::private::Address,
2204 implementation: alloy::sol_types::private::Address,
2205 ) -> alloy_contract::SolCallBuilder<&P, upgradeCall, N> {
2206 self.call_builder(
2207 &upgradeCall {
2208 proxy,
2209 implementation,
2210 },
2211 )
2212 }
2213 pub fn upgradeAndCall(
2215 &self,
2216 proxy: alloy::sol_types::private::Address,
2217 implementation: alloy::sol_types::private::Address,
2218 data: alloy::sol_types::private::Bytes,
2219 ) -> alloy_contract::SolCallBuilder<&P, upgradeAndCallCall, N> {
2220 self.call_builder(
2221 &upgradeAndCallCall {
2222 proxy,
2223 implementation,
2224 data,
2225 },
2226 )
2227 }
2228 }
2229 #[automatically_derived]
2231 impl<
2232 P: alloy_contract::private::Provider<N>,
2233 N: alloy_contract::private::Network,
2234 > ProxyAdminInstance<P, N> {
2235 pub fn event_filter<E: alloy_sol_types::SolEvent>(
2240 &self,
2241 ) -> alloy_contract::Event<&P, E, N> {
2242 alloy_contract::Event::new_sol(&self.provider, &self.address)
2243 }
2244 pub fn OwnershipTransferred_filter(
2246 &self,
2247 ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
2248 self.event_filter::<OwnershipTransferred>()
2249 }
2250 }
2251}