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\x06g\x80a\0v_9_\xF3\xFE`\x80`@R`\x046\x10a\0jW_5`\xE0\x1C\x80c N\x1Cz\x14a\0nW\x80cqP\x18\xA6\x14a\0\xA3W\x80c~\xFF'^\x14a\0\xB9W\x80c\x8D\xA5\xCB[\x14a\0\xD8W\x80c\x96#`\x9D\x14a\0\xF4W\x80c\x99\xA8\x8E\xC4\x14a\x01\x07W\x80c\xF2\xFD\xE3\x8B\x14a\x01&W\x80c\xF3\xB7\xDE\xAD\x14a\x01EW[__\xFD[4\x80\x15a\0yW__\xFD[Pa\0\x8Da\0\x886`\x04a\x04dV[a\x01dV[`@Qa\0\x9A\x91\x90a\x04\x86V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\0\xAEW__\xFD[Pa\0\xB7a\x01\xEFV[\0[4\x80\x15a\0\xC4W__\xFD[Pa\0\xB7a\0\xD36`\x04a\x04\x9AV[a\x02\x02V[4\x80\x15a\0\xE3W__\xFD[P_T`\x01`\x01`\xA0\x1B\x03\x16a\0\x8DV[a\0\xB7a\x01\x026`\x04a\x04\xE5V[a\x02gV[4\x80\x15a\x01\x12W__\xFD[Pa\0\xB7a\x01!6`\x04a\x04\x9AV[a\x02\xD2V[4\x80\x15a\x011W__\xFD[Pa\0\xB7a\x01@6`\x04a\x04dV[a\x03\x06V[4\x80\x15a\x01PW__\xFD[Pa\0\x8Da\x01_6`\x04a\x04dV[a\x03\x84V[___\x83`\x01`\x01`\xA0\x1B\x03\x16`@Qa\x01\x88\x90c\\`\xDA\x1B`\xE0\x1B\x81R`\x04\x01\x90V[_`@Q\x80\x83\x03\x81\x85Z\xFA\x91PP=\x80_\x81\x14a\x01\xC0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01\xC5V[``\x91P[P\x91P\x91P\x81a\x01\xD3W__\xFD[\x80\x80` \x01\x90Q\x81\x01\x90a\x01\xE7\x91\x90a\x05\xBCV[\x94\x93PPPPV[a\x01\xF7a\x03\xA8V[a\x02\0_a\x04\x01V[V[a\x02\na\x03\xA8V[`@Qc\x08\xF2\x83\x97`\xE4\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90c\x8F(9p\x90a\x026\x90\x84\x90`\x04\x01a\x04\x86V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02MW__\xFD[PZ\xF1\x15\x80\x15a\x02_W=__>=_\xFD[PPPPPPV[a\x02oa\x03\xA8V[`@Qc'\x8FyC`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16\x90cO\x1E\xF2\x86\x904\x90a\x02\x9F\x90\x86\x90\x86\x90`\x04\x01a\x05\xD7V[_`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x02\xB6W__\xFD[PZ\xF1\x15\x80\x15a\x02\xC8W=__>=_\xFD[PPPPPPPPV[a\x02\xDAa\x03\xA8V[`@Qc\x1B,\xE7\xF3`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90c6Y\xCF\xE6\x90a\x026\x90\x84\x90`\x04\x01a\x04\x86V[a\x03\x0Ea\x03\xA8V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x03xW`@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\x81\x81a\x04\x01V[PV[___\x83`\x01`\x01`\xA0\x1B\x03\x16`@Qa\x01\x88\x90c\x03\xE1F\x91`\xE6\x1B\x81R`\x04\x01\x90V[_T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x02\0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03oV[_\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\x81W__\xFD[_` \x82\x84\x03\x12\x15a\x04tW__\xFD[\x815a\x04\x7F\x81a\x04PV[\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[__`@\x83\x85\x03\x12\x15a\x04\xABW__\xFD[\x825a\x04\xB6\x81a\x04PV[\x91P` \x83\x015a\x04\xC6\x81a\x04PV[\x80\x91PP\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x04\xF7W__\xFD[\x835a\x05\x02\x81a\x04PV[\x92P` \x84\x015a\x05\x12\x81a\x04PV[\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\x05WWa\x05Wa\x04\xD1V[`@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\x86Wa\x05\x86a\x04\xD1V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x05\x9DW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\xCCW__\xFD[\x81Qa\x04\x7F\x81a\x04PV[`\x01\x80`\xA0\x1B\x03\x83\x16\x81R`@` \x82\x01R_\x82Q\x80`@\x84\x01R_[\x81\x81\x10\x15a\x06\x11W` \x81\x86\x01\x81\x01Q``\x86\x84\x01\x01R\x01a\x05\xF4V[P_``\x82\x85\x01\x01R```\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x9Ds\xB0\xBA\x89\xBE]N\xD8\x9E\x81\xB3\xC4\x1FhmJ\xF1p\x0E\x84I\x02\x14\xD2\xB9\xB1\x9F8\x11\xF8VdsolcC\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\0jW_5`\xE0\x1C\x80c N\x1Cz\x14a\0nW\x80cqP\x18\xA6\x14a\0\xA3W\x80c~\xFF'^\x14a\0\xB9W\x80c\x8D\xA5\xCB[\x14a\0\xD8W\x80c\x96#`\x9D\x14a\0\xF4W\x80c\x99\xA8\x8E\xC4\x14a\x01\x07W\x80c\xF2\xFD\xE3\x8B\x14a\x01&W\x80c\xF3\xB7\xDE\xAD\x14a\x01EW[__\xFD[4\x80\x15a\0yW__\xFD[Pa\0\x8Da\0\x886`\x04a\x04dV[a\x01dV[`@Qa\0\x9A\x91\x90a\x04\x86V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\0\xAEW__\xFD[Pa\0\xB7a\x01\xEFV[\0[4\x80\x15a\0\xC4W__\xFD[Pa\0\xB7a\0\xD36`\x04a\x04\x9AV[a\x02\x02V[4\x80\x15a\0\xE3W__\xFD[P_T`\x01`\x01`\xA0\x1B\x03\x16a\0\x8DV[a\0\xB7a\x01\x026`\x04a\x04\xE5V[a\x02gV[4\x80\x15a\x01\x12W__\xFD[Pa\0\xB7a\x01!6`\x04a\x04\x9AV[a\x02\xD2V[4\x80\x15a\x011W__\xFD[Pa\0\xB7a\x01@6`\x04a\x04dV[a\x03\x06V[4\x80\x15a\x01PW__\xFD[Pa\0\x8Da\x01_6`\x04a\x04dV[a\x03\x84V[___\x83`\x01`\x01`\xA0\x1B\x03\x16`@Qa\x01\x88\x90c\\`\xDA\x1B`\xE0\x1B\x81R`\x04\x01\x90V[_`@Q\x80\x83\x03\x81\x85Z\xFA\x91PP=\x80_\x81\x14a\x01\xC0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01\xC5V[``\x91P[P\x91P\x91P\x81a\x01\xD3W__\xFD[\x80\x80` \x01\x90Q\x81\x01\x90a\x01\xE7\x91\x90a\x05\xBCV[\x94\x93PPPPV[a\x01\xF7a\x03\xA8V[a\x02\0_a\x04\x01V[V[a\x02\na\x03\xA8V[`@Qc\x08\xF2\x83\x97`\xE4\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90c\x8F(9p\x90a\x026\x90\x84\x90`\x04\x01a\x04\x86V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02MW__\xFD[PZ\xF1\x15\x80\x15a\x02_W=__>=_\xFD[PPPPPPV[a\x02oa\x03\xA8V[`@Qc'\x8FyC`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16\x90cO\x1E\xF2\x86\x904\x90a\x02\x9F\x90\x86\x90\x86\x90`\x04\x01a\x05\xD7V[_`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x02\xB6W__\xFD[PZ\xF1\x15\x80\x15a\x02\xC8W=__>=_\xFD[PPPPPPPPV[a\x02\xDAa\x03\xA8V[`@Qc\x1B,\xE7\xF3`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90c6Y\xCF\xE6\x90a\x026\x90\x84\x90`\x04\x01a\x04\x86V[a\x03\x0Ea\x03\xA8V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x03xW`@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\x81\x81a\x04\x01V[PV[___\x83`\x01`\x01`\xA0\x1B\x03\x16`@Qa\x01\x88\x90c\x03\xE1F\x91`\xE6\x1B\x81R`\x04\x01\x90V[_T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x02\0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03oV[_\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\x81W__\xFD[_` \x82\x84\x03\x12\x15a\x04tW__\xFD[\x815a\x04\x7F\x81a\x04PV[\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[__`@\x83\x85\x03\x12\x15a\x04\xABW__\xFD[\x825a\x04\xB6\x81a\x04PV[\x91P` \x83\x015a\x04\xC6\x81a\x04PV[\x80\x91PP\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x04\xF7W__\xFD[\x835a\x05\x02\x81a\x04PV[\x92P` \x84\x015a\x05\x12\x81a\x04PV[\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\x05WWa\x05Wa\x04\xD1V[`@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\x86Wa\x05\x86a\x04\xD1V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x05\x9DW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\xCCW__\xFD[\x81Qa\x04\x7F\x81a\x04PV[`\x01\x80`\xA0\x1B\x03\x83\x16\x81R`@` \x82\x01R_\x82Q\x80`@\x84\x01R_[\x81\x81\x10\x15a\x06\x11W` \x81\x86\x01\x81\x01Q``\x86\x84\x01\x01R\x01a\x05\xF4V[P_``\x82\x85\x01\x01R```\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x9Ds\xB0\xBA\x89\xBE]N\xD8\x9E\x81\xB3\xC4\x1FhmJ\xF1p\x0E\x84I\x02\x14\xD2\xB9\xB1\x9F8\x11\xF8VdsolcC\0\x08\x1B\x003",
205 );
206 #[derive(Default, Debug, PartialEq, Eq, Hash)]
207 #[allow(
212 non_camel_case_types,
213 non_snake_case,
214 clippy::pub_underscore_fields,
215 clippy::style
216 )]
217 #[derive(Clone)]
218 pub struct OwnershipTransferred {
219 #[allow(missing_docs)]
220 pub previousOwner: alloy::sol_types::private::Address,
221 #[allow(missing_docs)]
222 pub newOwner: alloy::sol_types::private::Address,
223 }
224 #[allow(
225 non_camel_case_types,
226 non_snake_case,
227 clippy::pub_underscore_fields,
228 clippy::style
229 )]
230 const _: () = {
231 use alloy::sol_types as alloy_sol_types;
232 #[automatically_derived]
233 impl alloy_sol_types::SolEvent for OwnershipTransferred {
234 type DataTuple<'a> = ();
235 type DataToken<'a> = <Self::DataTuple<
236 'a,
237 > as alloy_sol_types::SolType>::Token<'a>;
238 type TopicList = (
239 alloy_sol_types::sol_data::FixedBytes<32>,
240 alloy::sol_types::sol_data::Address,
241 alloy::sol_types::sol_data::Address,
242 );
243 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
244 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
245 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
246 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
247 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
248 ]);
249 const ANONYMOUS: bool = false;
250 #[allow(unused_variables)]
251 #[inline]
252 fn new(
253 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
254 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
255 ) -> Self {
256 Self {
257 previousOwner: topics.1,
258 newOwner: topics.2,
259 }
260 }
261 #[inline]
262 fn check_signature(
263 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
264 ) -> alloy_sol_types::Result<()> {
265 if topics.0 != Self::SIGNATURE_HASH {
266 return Err(
267 alloy_sol_types::Error::invalid_event_signature_hash(
268 Self::SIGNATURE,
269 topics.0,
270 Self::SIGNATURE_HASH,
271 ),
272 );
273 }
274 Ok(())
275 }
276 #[inline]
277 fn tokenize_body(&self) -> Self::DataToken<'_> {
278 ()
279 }
280 #[inline]
281 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
282 (
283 Self::SIGNATURE_HASH.into(),
284 self.previousOwner.clone(),
285 self.newOwner.clone(),
286 )
287 }
288 #[inline]
289 fn encode_topics_raw(
290 &self,
291 out: &mut [alloy_sol_types::abi::token::WordToken],
292 ) -> alloy_sol_types::Result<()> {
293 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
294 return Err(alloy_sol_types::Error::Overrun);
295 }
296 out[0usize] = alloy_sol_types::abi::token::WordToken(
297 Self::SIGNATURE_HASH,
298 );
299 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
300 &self.previousOwner,
301 );
302 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
303 &self.newOwner,
304 );
305 Ok(())
306 }
307 }
308 #[automatically_derived]
309 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
310 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
311 From::from(self)
312 }
313 fn into_log_data(self) -> alloy_sol_types::private::LogData {
314 From::from(&self)
315 }
316 }
317 #[automatically_derived]
318 impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
319 #[inline]
320 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
321 alloy_sol_types::SolEvent::encode_log_data(this)
322 }
323 }
324 };
325 #[derive(Default, Debug, PartialEq, Eq, Hash)]
326 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
331 #[derive(Clone)]
332 pub struct changeProxyAdminCall {
333 #[allow(missing_docs)]
334 pub proxy: alloy::sol_types::private::Address,
335 #[allow(missing_docs)]
336 pub newAdmin: alloy::sol_types::private::Address,
337 }
338 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
340 #[derive(Clone)]
341 pub struct changeProxyAdminReturn {}
342 #[allow(
343 non_camel_case_types,
344 non_snake_case,
345 clippy::pub_underscore_fields,
346 clippy::style
347 )]
348 const _: () = {
349 use alloy::sol_types as alloy_sol_types;
350 {
351 #[doc(hidden)]
352 type UnderlyingSolTuple<'a> = (
353 alloy::sol_types::sol_data::Address,
354 alloy::sol_types::sol_data::Address,
355 );
356 #[doc(hidden)]
357 type UnderlyingRustTuple<'a> = (
358 alloy::sol_types::private::Address,
359 alloy::sol_types::private::Address,
360 );
361 #[cfg(test)]
362 #[allow(dead_code, unreachable_patterns)]
363 fn _type_assertion(
364 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
365 ) {
366 match _t {
367 alloy_sol_types::private::AssertTypeEq::<
368 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
369 >(_) => {}
370 }
371 }
372 #[automatically_derived]
373 #[doc(hidden)]
374 impl ::core::convert::From<changeProxyAdminCall>
375 for UnderlyingRustTuple<'_> {
376 fn from(value: changeProxyAdminCall) -> Self {
377 (value.proxy, value.newAdmin)
378 }
379 }
380 #[automatically_derived]
381 #[doc(hidden)]
382 impl ::core::convert::From<UnderlyingRustTuple<'_>>
383 for changeProxyAdminCall {
384 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
385 Self {
386 proxy: tuple.0,
387 newAdmin: tuple.1,
388 }
389 }
390 }
391 }
392 {
393 #[doc(hidden)]
394 type UnderlyingSolTuple<'a> = ();
395 #[doc(hidden)]
396 type UnderlyingRustTuple<'a> = ();
397 #[cfg(test)]
398 #[allow(dead_code, unreachable_patterns)]
399 fn _type_assertion(
400 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
401 ) {
402 match _t {
403 alloy_sol_types::private::AssertTypeEq::<
404 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
405 >(_) => {}
406 }
407 }
408 #[automatically_derived]
409 #[doc(hidden)]
410 impl ::core::convert::From<changeProxyAdminReturn>
411 for UnderlyingRustTuple<'_> {
412 fn from(value: changeProxyAdminReturn) -> Self {
413 ()
414 }
415 }
416 #[automatically_derived]
417 #[doc(hidden)]
418 impl ::core::convert::From<UnderlyingRustTuple<'_>>
419 for changeProxyAdminReturn {
420 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
421 Self {}
422 }
423 }
424 }
425 #[automatically_derived]
426 impl alloy_sol_types::SolCall for changeProxyAdminCall {
427 type Parameters<'a> = (
428 alloy::sol_types::sol_data::Address,
429 alloy::sol_types::sol_data::Address,
430 );
431 type Token<'a> = <Self::Parameters<
432 'a,
433 > as alloy_sol_types::SolType>::Token<'a>;
434 type Return = changeProxyAdminReturn;
435 type ReturnTuple<'a> = ();
436 type ReturnToken<'a> = <Self::ReturnTuple<
437 'a,
438 > as alloy_sol_types::SolType>::Token<'a>;
439 const SIGNATURE: &'static str = "changeProxyAdmin(address,address)";
440 const SELECTOR: [u8; 4] = [126u8, 255u8, 39u8, 94u8];
441 #[inline]
442 fn new<'a>(
443 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
444 ) -> Self {
445 tuple.into()
446 }
447 #[inline]
448 fn tokenize(&self) -> Self::Token<'_> {
449 (
450 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
451 &self.proxy,
452 ),
453 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
454 &self.newAdmin,
455 ),
456 )
457 }
458 #[inline]
459 fn abi_decode_returns(
460 data: &[u8],
461 validate: bool,
462 ) -> alloy_sol_types::Result<Self::Return> {
463 <Self::ReturnTuple<
464 '_,
465 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
466 .map(Into::into)
467 }
468 }
469 };
470 #[derive(Default, Debug, PartialEq, Eq, Hash)]
471 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
476 #[derive(Clone)]
477 pub struct getProxyAdminCall {
478 #[allow(missing_docs)]
479 pub proxy: alloy::sol_types::private::Address,
480 }
481 #[derive(Default, Debug, PartialEq, Eq, Hash)]
482 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
484 #[derive(Clone)]
485 pub struct getProxyAdminReturn {
486 #[allow(missing_docs)]
487 pub _0: alloy::sol_types::private::Address,
488 }
489 #[allow(
490 non_camel_case_types,
491 non_snake_case,
492 clippy::pub_underscore_fields,
493 clippy::style
494 )]
495 const _: () = {
496 use alloy::sol_types as alloy_sol_types;
497 {
498 #[doc(hidden)]
499 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
500 #[doc(hidden)]
501 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
502 #[cfg(test)]
503 #[allow(dead_code, unreachable_patterns)]
504 fn _type_assertion(
505 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
506 ) {
507 match _t {
508 alloy_sol_types::private::AssertTypeEq::<
509 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
510 >(_) => {}
511 }
512 }
513 #[automatically_derived]
514 #[doc(hidden)]
515 impl ::core::convert::From<getProxyAdminCall> for UnderlyingRustTuple<'_> {
516 fn from(value: getProxyAdminCall) -> Self {
517 (value.proxy,)
518 }
519 }
520 #[automatically_derived]
521 #[doc(hidden)]
522 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProxyAdminCall {
523 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
524 Self { proxy: tuple.0 }
525 }
526 }
527 }
528 {
529 #[doc(hidden)]
530 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
531 #[doc(hidden)]
532 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
533 #[cfg(test)]
534 #[allow(dead_code, unreachable_patterns)]
535 fn _type_assertion(
536 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
537 ) {
538 match _t {
539 alloy_sol_types::private::AssertTypeEq::<
540 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
541 >(_) => {}
542 }
543 }
544 #[automatically_derived]
545 #[doc(hidden)]
546 impl ::core::convert::From<getProxyAdminReturn> for UnderlyingRustTuple<'_> {
547 fn from(value: getProxyAdminReturn) -> Self {
548 (value._0,)
549 }
550 }
551 #[automatically_derived]
552 #[doc(hidden)]
553 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProxyAdminReturn {
554 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
555 Self { _0: tuple.0 }
556 }
557 }
558 }
559 #[automatically_derived]
560 impl alloy_sol_types::SolCall for getProxyAdminCall {
561 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
562 type Token<'a> = <Self::Parameters<
563 'a,
564 > as alloy_sol_types::SolType>::Token<'a>;
565 type Return = getProxyAdminReturn;
566 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
567 type ReturnToken<'a> = <Self::ReturnTuple<
568 'a,
569 > as alloy_sol_types::SolType>::Token<'a>;
570 const SIGNATURE: &'static str = "getProxyAdmin(address)";
571 const SELECTOR: [u8; 4] = [243u8, 183u8, 222u8, 173u8];
572 #[inline]
573 fn new<'a>(
574 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
575 ) -> Self {
576 tuple.into()
577 }
578 #[inline]
579 fn tokenize(&self) -> Self::Token<'_> {
580 (
581 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
582 &self.proxy,
583 ),
584 )
585 }
586 #[inline]
587 fn abi_decode_returns(
588 data: &[u8],
589 validate: bool,
590 ) -> alloy_sol_types::Result<Self::Return> {
591 <Self::ReturnTuple<
592 '_,
593 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
594 .map(Into::into)
595 }
596 }
597 };
598 #[derive(Default, Debug, PartialEq, Eq, Hash)]
599 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
604 #[derive(Clone)]
605 pub struct getProxyImplementationCall {
606 #[allow(missing_docs)]
607 pub proxy: alloy::sol_types::private::Address,
608 }
609 #[derive(Default, Debug, PartialEq, Eq, Hash)]
610 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
612 #[derive(Clone)]
613 pub struct getProxyImplementationReturn {
614 #[allow(missing_docs)]
615 pub _0: alloy::sol_types::private::Address,
616 }
617 #[allow(
618 non_camel_case_types,
619 non_snake_case,
620 clippy::pub_underscore_fields,
621 clippy::style
622 )]
623 const _: () = {
624 use alloy::sol_types as alloy_sol_types;
625 {
626 #[doc(hidden)]
627 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
628 #[doc(hidden)]
629 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
630 #[cfg(test)]
631 #[allow(dead_code, unreachable_patterns)]
632 fn _type_assertion(
633 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
634 ) {
635 match _t {
636 alloy_sol_types::private::AssertTypeEq::<
637 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
638 >(_) => {}
639 }
640 }
641 #[automatically_derived]
642 #[doc(hidden)]
643 impl ::core::convert::From<getProxyImplementationCall>
644 for UnderlyingRustTuple<'_> {
645 fn from(value: getProxyImplementationCall) -> Self {
646 (value.proxy,)
647 }
648 }
649 #[automatically_derived]
650 #[doc(hidden)]
651 impl ::core::convert::From<UnderlyingRustTuple<'_>>
652 for getProxyImplementationCall {
653 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
654 Self { proxy: tuple.0 }
655 }
656 }
657 }
658 {
659 #[doc(hidden)]
660 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
661 #[doc(hidden)]
662 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
663 #[cfg(test)]
664 #[allow(dead_code, unreachable_patterns)]
665 fn _type_assertion(
666 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
667 ) {
668 match _t {
669 alloy_sol_types::private::AssertTypeEq::<
670 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
671 >(_) => {}
672 }
673 }
674 #[automatically_derived]
675 #[doc(hidden)]
676 impl ::core::convert::From<getProxyImplementationReturn>
677 for UnderlyingRustTuple<'_> {
678 fn from(value: getProxyImplementationReturn) -> Self {
679 (value._0,)
680 }
681 }
682 #[automatically_derived]
683 #[doc(hidden)]
684 impl ::core::convert::From<UnderlyingRustTuple<'_>>
685 for getProxyImplementationReturn {
686 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
687 Self { _0: tuple.0 }
688 }
689 }
690 }
691 #[automatically_derived]
692 impl alloy_sol_types::SolCall for getProxyImplementationCall {
693 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
694 type Token<'a> = <Self::Parameters<
695 'a,
696 > as alloy_sol_types::SolType>::Token<'a>;
697 type Return = getProxyImplementationReturn;
698 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
699 type ReturnToken<'a> = <Self::ReturnTuple<
700 'a,
701 > as alloy_sol_types::SolType>::Token<'a>;
702 const SIGNATURE: &'static str = "getProxyImplementation(address)";
703 const SELECTOR: [u8; 4] = [32u8, 78u8, 28u8, 122u8];
704 #[inline]
705 fn new<'a>(
706 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
707 ) -> Self {
708 tuple.into()
709 }
710 #[inline]
711 fn tokenize(&self) -> Self::Token<'_> {
712 (
713 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
714 &self.proxy,
715 ),
716 )
717 }
718 #[inline]
719 fn abi_decode_returns(
720 data: &[u8],
721 validate: bool,
722 ) -> alloy_sol_types::Result<Self::Return> {
723 <Self::ReturnTuple<
724 '_,
725 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
726 .map(Into::into)
727 }
728 }
729 };
730 #[derive(Default, Debug, PartialEq, Eq, Hash)]
731 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
736 #[derive(Clone)]
737 pub struct ownerCall {}
738 #[derive(Default, Debug, PartialEq, Eq, Hash)]
739 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
741 #[derive(Clone)]
742 pub struct ownerReturn {
743 #[allow(missing_docs)]
744 pub _0: alloy::sol_types::private::Address,
745 }
746 #[allow(
747 non_camel_case_types,
748 non_snake_case,
749 clippy::pub_underscore_fields,
750 clippy::style
751 )]
752 const _: () = {
753 use alloy::sol_types as alloy_sol_types;
754 {
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<ownerCall> for UnderlyingRustTuple<'_> {
773 fn from(value: ownerCall) -> Self {
774 ()
775 }
776 }
777 #[automatically_derived]
778 #[doc(hidden)]
779 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
780 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
781 Self {}
782 }
783 }
784 }
785 {
786 #[doc(hidden)]
787 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
788 #[doc(hidden)]
789 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
790 #[cfg(test)]
791 #[allow(dead_code, unreachable_patterns)]
792 fn _type_assertion(
793 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
794 ) {
795 match _t {
796 alloy_sol_types::private::AssertTypeEq::<
797 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
798 >(_) => {}
799 }
800 }
801 #[automatically_derived]
802 #[doc(hidden)]
803 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
804 fn from(value: ownerReturn) -> Self {
805 (value._0,)
806 }
807 }
808 #[automatically_derived]
809 #[doc(hidden)]
810 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
811 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
812 Self { _0: tuple.0 }
813 }
814 }
815 }
816 #[automatically_derived]
817 impl alloy_sol_types::SolCall for ownerCall {
818 type Parameters<'a> = ();
819 type Token<'a> = <Self::Parameters<
820 'a,
821 > as alloy_sol_types::SolType>::Token<'a>;
822 type Return = ownerReturn;
823 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
824 type ReturnToken<'a> = <Self::ReturnTuple<
825 'a,
826 > as alloy_sol_types::SolType>::Token<'a>;
827 const SIGNATURE: &'static str = "owner()";
828 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
829 #[inline]
830 fn new<'a>(
831 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
832 ) -> Self {
833 tuple.into()
834 }
835 #[inline]
836 fn tokenize(&self) -> Self::Token<'_> {
837 ()
838 }
839 #[inline]
840 fn abi_decode_returns(
841 data: &[u8],
842 validate: bool,
843 ) -> alloy_sol_types::Result<Self::Return> {
844 <Self::ReturnTuple<
845 '_,
846 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
847 .map(Into::into)
848 }
849 }
850 };
851 #[derive(Default, Debug, PartialEq, Eq, Hash)]
852 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
857 #[derive(Clone)]
858 pub struct renounceOwnershipCall {}
859 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
861 #[derive(Clone)]
862 pub struct renounceOwnershipReturn {}
863 #[allow(
864 non_camel_case_types,
865 non_snake_case,
866 clippy::pub_underscore_fields,
867 clippy::style
868 )]
869 const _: () = {
870 use alloy::sol_types as alloy_sol_types;
871 {
872 #[doc(hidden)]
873 type UnderlyingSolTuple<'a> = ();
874 #[doc(hidden)]
875 type UnderlyingRustTuple<'a> = ();
876 #[cfg(test)]
877 #[allow(dead_code, unreachable_patterns)]
878 fn _type_assertion(
879 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
880 ) {
881 match _t {
882 alloy_sol_types::private::AssertTypeEq::<
883 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
884 >(_) => {}
885 }
886 }
887 #[automatically_derived]
888 #[doc(hidden)]
889 impl ::core::convert::From<renounceOwnershipCall>
890 for UnderlyingRustTuple<'_> {
891 fn from(value: renounceOwnershipCall) -> Self {
892 ()
893 }
894 }
895 #[automatically_derived]
896 #[doc(hidden)]
897 impl ::core::convert::From<UnderlyingRustTuple<'_>>
898 for renounceOwnershipCall {
899 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
900 Self {}
901 }
902 }
903 }
904 {
905 #[doc(hidden)]
906 type UnderlyingSolTuple<'a> = ();
907 #[doc(hidden)]
908 type UnderlyingRustTuple<'a> = ();
909 #[cfg(test)]
910 #[allow(dead_code, unreachable_patterns)]
911 fn _type_assertion(
912 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
913 ) {
914 match _t {
915 alloy_sol_types::private::AssertTypeEq::<
916 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
917 >(_) => {}
918 }
919 }
920 #[automatically_derived]
921 #[doc(hidden)]
922 impl ::core::convert::From<renounceOwnershipReturn>
923 for UnderlyingRustTuple<'_> {
924 fn from(value: renounceOwnershipReturn) -> Self {
925 ()
926 }
927 }
928 #[automatically_derived]
929 #[doc(hidden)]
930 impl ::core::convert::From<UnderlyingRustTuple<'_>>
931 for renounceOwnershipReturn {
932 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
933 Self {}
934 }
935 }
936 }
937 #[automatically_derived]
938 impl alloy_sol_types::SolCall for renounceOwnershipCall {
939 type Parameters<'a> = ();
940 type Token<'a> = <Self::Parameters<
941 'a,
942 > as alloy_sol_types::SolType>::Token<'a>;
943 type Return = renounceOwnershipReturn;
944 type ReturnTuple<'a> = ();
945 type ReturnToken<'a> = <Self::ReturnTuple<
946 'a,
947 > as alloy_sol_types::SolType>::Token<'a>;
948 const SIGNATURE: &'static str = "renounceOwnership()";
949 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
950 #[inline]
951 fn new<'a>(
952 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
953 ) -> Self {
954 tuple.into()
955 }
956 #[inline]
957 fn tokenize(&self) -> Self::Token<'_> {
958 ()
959 }
960 #[inline]
961 fn abi_decode_returns(
962 data: &[u8],
963 validate: bool,
964 ) -> alloy_sol_types::Result<Self::Return> {
965 <Self::ReturnTuple<
966 '_,
967 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
968 .map(Into::into)
969 }
970 }
971 };
972 #[derive(Default, Debug, PartialEq, Eq, Hash)]
973 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
978 #[derive(Clone)]
979 pub struct transferOwnershipCall {
980 #[allow(missing_docs)]
981 pub newOwner: alloy::sol_types::private::Address,
982 }
983 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
985 #[derive(Clone)]
986 pub struct transferOwnershipReturn {}
987 #[allow(
988 non_camel_case_types,
989 non_snake_case,
990 clippy::pub_underscore_fields,
991 clippy::style
992 )]
993 const _: () = {
994 use alloy::sol_types as alloy_sol_types;
995 {
996 #[doc(hidden)]
997 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
998 #[doc(hidden)]
999 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1000 #[cfg(test)]
1001 #[allow(dead_code, unreachable_patterns)]
1002 fn _type_assertion(
1003 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1004 ) {
1005 match _t {
1006 alloy_sol_types::private::AssertTypeEq::<
1007 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1008 >(_) => {}
1009 }
1010 }
1011 #[automatically_derived]
1012 #[doc(hidden)]
1013 impl ::core::convert::From<transferOwnershipCall>
1014 for UnderlyingRustTuple<'_> {
1015 fn from(value: transferOwnershipCall) -> Self {
1016 (value.newOwner,)
1017 }
1018 }
1019 #[automatically_derived]
1020 #[doc(hidden)]
1021 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1022 for transferOwnershipCall {
1023 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1024 Self { newOwner: tuple.0 }
1025 }
1026 }
1027 }
1028 {
1029 #[doc(hidden)]
1030 type UnderlyingSolTuple<'a> = ();
1031 #[doc(hidden)]
1032 type UnderlyingRustTuple<'a> = ();
1033 #[cfg(test)]
1034 #[allow(dead_code, unreachable_patterns)]
1035 fn _type_assertion(
1036 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1037 ) {
1038 match _t {
1039 alloy_sol_types::private::AssertTypeEq::<
1040 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1041 >(_) => {}
1042 }
1043 }
1044 #[automatically_derived]
1045 #[doc(hidden)]
1046 impl ::core::convert::From<transferOwnershipReturn>
1047 for UnderlyingRustTuple<'_> {
1048 fn from(value: transferOwnershipReturn) -> Self {
1049 ()
1050 }
1051 }
1052 #[automatically_derived]
1053 #[doc(hidden)]
1054 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1055 for transferOwnershipReturn {
1056 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1057 Self {}
1058 }
1059 }
1060 }
1061 #[automatically_derived]
1062 impl alloy_sol_types::SolCall for transferOwnershipCall {
1063 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1064 type Token<'a> = <Self::Parameters<
1065 'a,
1066 > as alloy_sol_types::SolType>::Token<'a>;
1067 type Return = transferOwnershipReturn;
1068 type ReturnTuple<'a> = ();
1069 type ReturnToken<'a> = <Self::ReturnTuple<
1070 'a,
1071 > as alloy_sol_types::SolType>::Token<'a>;
1072 const SIGNATURE: &'static str = "transferOwnership(address)";
1073 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
1074 #[inline]
1075 fn new<'a>(
1076 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1077 ) -> Self {
1078 tuple.into()
1079 }
1080 #[inline]
1081 fn tokenize(&self) -> Self::Token<'_> {
1082 (
1083 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1084 &self.newOwner,
1085 ),
1086 )
1087 }
1088 #[inline]
1089 fn abi_decode_returns(
1090 data: &[u8],
1091 validate: bool,
1092 ) -> alloy_sol_types::Result<Self::Return> {
1093 <Self::ReturnTuple<
1094 '_,
1095 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1096 .map(Into::into)
1097 }
1098 }
1099 };
1100 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1101 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1106 #[derive(Clone)]
1107 pub struct upgradeCall {
1108 #[allow(missing_docs)]
1109 pub proxy: alloy::sol_types::private::Address,
1110 #[allow(missing_docs)]
1111 pub implementation: alloy::sol_types::private::Address,
1112 }
1113 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1115 #[derive(Clone)]
1116 pub struct upgradeReturn {}
1117 #[allow(
1118 non_camel_case_types,
1119 non_snake_case,
1120 clippy::pub_underscore_fields,
1121 clippy::style
1122 )]
1123 const _: () = {
1124 use alloy::sol_types as alloy_sol_types;
1125 {
1126 #[doc(hidden)]
1127 type UnderlyingSolTuple<'a> = (
1128 alloy::sol_types::sol_data::Address,
1129 alloy::sol_types::sol_data::Address,
1130 );
1131 #[doc(hidden)]
1132 type UnderlyingRustTuple<'a> = (
1133 alloy::sol_types::private::Address,
1134 alloy::sol_types::private::Address,
1135 );
1136 #[cfg(test)]
1137 #[allow(dead_code, unreachable_patterns)]
1138 fn _type_assertion(
1139 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1140 ) {
1141 match _t {
1142 alloy_sol_types::private::AssertTypeEq::<
1143 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1144 >(_) => {}
1145 }
1146 }
1147 #[automatically_derived]
1148 #[doc(hidden)]
1149 impl ::core::convert::From<upgradeCall> for UnderlyingRustTuple<'_> {
1150 fn from(value: upgradeCall) -> Self {
1151 (value.proxy, value.implementation)
1152 }
1153 }
1154 #[automatically_derived]
1155 #[doc(hidden)]
1156 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeCall {
1157 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1158 Self {
1159 proxy: tuple.0,
1160 implementation: tuple.1,
1161 }
1162 }
1163 }
1164 }
1165 {
1166 #[doc(hidden)]
1167 type UnderlyingSolTuple<'a> = ();
1168 #[doc(hidden)]
1169 type UnderlyingRustTuple<'a> = ();
1170 #[cfg(test)]
1171 #[allow(dead_code, unreachable_patterns)]
1172 fn _type_assertion(
1173 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1174 ) {
1175 match _t {
1176 alloy_sol_types::private::AssertTypeEq::<
1177 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1178 >(_) => {}
1179 }
1180 }
1181 #[automatically_derived]
1182 #[doc(hidden)]
1183 impl ::core::convert::From<upgradeReturn> for UnderlyingRustTuple<'_> {
1184 fn from(value: upgradeReturn) -> Self {
1185 ()
1186 }
1187 }
1188 #[automatically_derived]
1189 #[doc(hidden)]
1190 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeReturn {
1191 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1192 Self {}
1193 }
1194 }
1195 }
1196 #[automatically_derived]
1197 impl alloy_sol_types::SolCall for upgradeCall {
1198 type Parameters<'a> = (
1199 alloy::sol_types::sol_data::Address,
1200 alloy::sol_types::sol_data::Address,
1201 );
1202 type Token<'a> = <Self::Parameters<
1203 'a,
1204 > as alloy_sol_types::SolType>::Token<'a>;
1205 type Return = upgradeReturn;
1206 type ReturnTuple<'a> = ();
1207 type ReturnToken<'a> = <Self::ReturnTuple<
1208 'a,
1209 > as alloy_sol_types::SolType>::Token<'a>;
1210 const SIGNATURE: &'static str = "upgrade(address,address)";
1211 const SELECTOR: [u8; 4] = [153u8, 168u8, 142u8, 196u8];
1212 #[inline]
1213 fn new<'a>(
1214 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1215 ) -> Self {
1216 tuple.into()
1217 }
1218 #[inline]
1219 fn tokenize(&self) -> Self::Token<'_> {
1220 (
1221 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1222 &self.proxy,
1223 ),
1224 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1225 &self.implementation,
1226 ),
1227 )
1228 }
1229 #[inline]
1230 fn abi_decode_returns(
1231 data: &[u8],
1232 validate: bool,
1233 ) -> alloy_sol_types::Result<Self::Return> {
1234 <Self::ReturnTuple<
1235 '_,
1236 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1237 .map(Into::into)
1238 }
1239 }
1240 };
1241 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1242 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1247 #[derive(Clone)]
1248 pub struct upgradeAndCallCall {
1249 #[allow(missing_docs)]
1250 pub proxy: alloy::sol_types::private::Address,
1251 #[allow(missing_docs)]
1252 pub implementation: alloy::sol_types::private::Address,
1253 #[allow(missing_docs)]
1254 pub data: alloy::sol_types::private::Bytes,
1255 }
1256 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1258 #[derive(Clone)]
1259 pub struct upgradeAndCallReturn {}
1260 #[allow(
1261 non_camel_case_types,
1262 non_snake_case,
1263 clippy::pub_underscore_fields,
1264 clippy::style
1265 )]
1266 const _: () = {
1267 use alloy::sol_types as alloy_sol_types;
1268 {
1269 #[doc(hidden)]
1270 type UnderlyingSolTuple<'a> = (
1271 alloy::sol_types::sol_data::Address,
1272 alloy::sol_types::sol_data::Address,
1273 alloy::sol_types::sol_data::Bytes,
1274 );
1275 #[doc(hidden)]
1276 type UnderlyingRustTuple<'a> = (
1277 alloy::sol_types::private::Address,
1278 alloy::sol_types::private::Address,
1279 alloy::sol_types::private::Bytes,
1280 );
1281 #[cfg(test)]
1282 #[allow(dead_code, unreachable_patterns)]
1283 fn _type_assertion(
1284 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1285 ) {
1286 match _t {
1287 alloy_sol_types::private::AssertTypeEq::<
1288 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1289 >(_) => {}
1290 }
1291 }
1292 #[automatically_derived]
1293 #[doc(hidden)]
1294 impl ::core::convert::From<upgradeAndCallCall> for UnderlyingRustTuple<'_> {
1295 fn from(value: upgradeAndCallCall) -> Self {
1296 (value.proxy, value.implementation, value.data)
1297 }
1298 }
1299 #[automatically_derived]
1300 #[doc(hidden)]
1301 impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeAndCallCall {
1302 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1303 Self {
1304 proxy: tuple.0,
1305 implementation: tuple.1,
1306 data: tuple.2,
1307 }
1308 }
1309 }
1310 }
1311 {
1312 #[doc(hidden)]
1313 type UnderlyingSolTuple<'a> = ();
1314 #[doc(hidden)]
1315 type UnderlyingRustTuple<'a> = ();
1316 #[cfg(test)]
1317 #[allow(dead_code, unreachable_patterns)]
1318 fn _type_assertion(
1319 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1320 ) {
1321 match _t {
1322 alloy_sol_types::private::AssertTypeEq::<
1323 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1324 >(_) => {}
1325 }
1326 }
1327 #[automatically_derived]
1328 #[doc(hidden)]
1329 impl ::core::convert::From<upgradeAndCallReturn>
1330 for UnderlyingRustTuple<'_> {
1331 fn from(value: upgradeAndCallReturn) -> Self {
1332 ()
1333 }
1334 }
1335 #[automatically_derived]
1336 #[doc(hidden)]
1337 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1338 for upgradeAndCallReturn {
1339 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1340 Self {}
1341 }
1342 }
1343 }
1344 #[automatically_derived]
1345 impl alloy_sol_types::SolCall for upgradeAndCallCall {
1346 type Parameters<'a> = (
1347 alloy::sol_types::sol_data::Address,
1348 alloy::sol_types::sol_data::Address,
1349 alloy::sol_types::sol_data::Bytes,
1350 );
1351 type Token<'a> = <Self::Parameters<
1352 'a,
1353 > as alloy_sol_types::SolType>::Token<'a>;
1354 type Return = upgradeAndCallReturn;
1355 type ReturnTuple<'a> = ();
1356 type ReturnToken<'a> = <Self::ReturnTuple<
1357 'a,
1358 > as alloy_sol_types::SolType>::Token<'a>;
1359 const SIGNATURE: &'static str = "upgradeAndCall(address,address,bytes)";
1360 const SELECTOR: [u8; 4] = [150u8, 35u8, 96u8, 157u8];
1361 #[inline]
1362 fn new<'a>(
1363 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1364 ) -> Self {
1365 tuple.into()
1366 }
1367 #[inline]
1368 fn tokenize(&self) -> Self::Token<'_> {
1369 (
1370 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1371 &self.proxy,
1372 ),
1373 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1374 &self.implementation,
1375 ),
1376 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1377 &self.data,
1378 ),
1379 )
1380 }
1381 #[inline]
1382 fn abi_decode_returns(
1383 data: &[u8],
1384 validate: bool,
1385 ) -> alloy_sol_types::Result<Self::Return> {
1386 <Self::ReturnTuple<
1387 '_,
1388 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1389 .map(Into::into)
1390 }
1391 }
1392 };
1393 #[derive()]
1395 pub enum ProxyAdminCalls {
1396 #[allow(missing_docs)]
1397 changeProxyAdmin(changeProxyAdminCall),
1398 #[allow(missing_docs)]
1399 getProxyAdmin(getProxyAdminCall),
1400 #[allow(missing_docs)]
1401 getProxyImplementation(getProxyImplementationCall),
1402 #[allow(missing_docs)]
1403 owner(ownerCall),
1404 #[allow(missing_docs)]
1405 renounceOwnership(renounceOwnershipCall),
1406 #[allow(missing_docs)]
1407 transferOwnership(transferOwnershipCall),
1408 #[allow(missing_docs)]
1409 upgrade(upgradeCall),
1410 #[allow(missing_docs)]
1411 upgradeAndCall(upgradeAndCallCall),
1412 }
1413 #[automatically_derived]
1414 impl ProxyAdminCalls {
1415 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1422 [32u8, 78u8, 28u8, 122u8],
1423 [113u8, 80u8, 24u8, 166u8],
1424 [126u8, 255u8, 39u8, 94u8],
1425 [141u8, 165u8, 203u8, 91u8],
1426 [150u8, 35u8, 96u8, 157u8],
1427 [153u8, 168u8, 142u8, 196u8],
1428 [242u8, 253u8, 227u8, 139u8],
1429 [243u8, 183u8, 222u8, 173u8],
1430 ];
1431 }
1432 #[automatically_derived]
1433 impl alloy_sol_types::SolInterface for ProxyAdminCalls {
1434 const NAME: &'static str = "ProxyAdminCalls";
1435 const MIN_DATA_LENGTH: usize = 0usize;
1436 const COUNT: usize = 8usize;
1437 #[inline]
1438 fn selector(&self) -> [u8; 4] {
1439 match self {
1440 Self::changeProxyAdmin(_) => {
1441 <changeProxyAdminCall as alloy_sol_types::SolCall>::SELECTOR
1442 }
1443 Self::getProxyAdmin(_) => {
1444 <getProxyAdminCall as alloy_sol_types::SolCall>::SELECTOR
1445 }
1446 Self::getProxyImplementation(_) => {
1447 <getProxyImplementationCall as alloy_sol_types::SolCall>::SELECTOR
1448 }
1449 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
1450 Self::renounceOwnership(_) => {
1451 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1452 }
1453 Self::transferOwnership(_) => {
1454 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1455 }
1456 Self::upgrade(_) => <upgradeCall as alloy_sol_types::SolCall>::SELECTOR,
1457 Self::upgradeAndCall(_) => {
1458 <upgradeAndCallCall as alloy_sol_types::SolCall>::SELECTOR
1459 }
1460 }
1461 }
1462 #[inline]
1463 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1464 Self::SELECTORS.get(i).copied()
1465 }
1466 #[inline]
1467 fn valid_selector(selector: [u8; 4]) -> bool {
1468 Self::SELECTORS.binary_search(&selector).is_ok()
1469 }
1470 #[inline]
1471 #[allow(non_snake_case)]
1472 fn abi_decode_raw(
1473 selector: [u8; 4],
1474 data: &[u8],
1475 validate: bool,
1476 ) -> alloy_sol_types::Result<Self> {
1477 static DECODE_SHIMS: &[fn(
1478 &[u8],
1479 bool,
1480 ) -> alloy_sol_types::Result<ProxyAdminCalls>] = &[
1481 {
1482 fn getProxyImplementation(
1483 data: &[u8],
1484 validate: bool,
1485 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1486 <getProxyImplementationCall as alloy_sol_types::SolCall>::abi_decode_raw(
1487 data,
1488 validate,
1489 )
1490 .map(ProxyAdminCalls::getProxyImplementation)
1491 }
1492 getProxyImplementation
1493 },
1494 {
1495 fn renounceOwnership(
1496 data: &[u8],
1497 validate: bool,
1498 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1499 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
1500 data,
1501 validate,
1502 )
1503 .map(ProxyAdminCalls::renounceOwnership)
1504 }
1505 renounceOwnership
1506 },
1507 {
1508 fn changeProxyAdmin(
1509 data: &[u8],
1510 validate: bool,
1511 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1512 <changeProxyAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
1513 data,
1514 validate,
1515 )
1516 .map(ProxyAdminCalls::changeProxyAdmin)
1517 }
1518 changeProxyAdmin
1519 },
1520 {
1521 fn owner(
1522 data: &[u8],
1523 validate: bool,
1524 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1525 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(
1526 data,
1527 validate,
1528 )
1529 .map(ProxyAdminCalls::owner)
1530 }
1531 owner
1532 },
1533 {
1534 fn upgradeAndCall(
1535 data: &[u8],
1536 validate: bool,
1537 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1538 <upgradeAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(
1539 data,
1540 validate,
1541 )
1542 .map(ProxyAdminCalls::upgradeAndCall)
1543 }
1544 upgradeAndCall
1545 },
1546 {
1547 fn upgrade(
1548 data: &[u8],
1549 validate: bool,
1550 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1551 <upgradeCall as alloy_sol_types::SolCall>::abi_decode_raw(
1552 data,
1553 validate,
1554 )
1555 .map(ProxyAdminCalls::upgrade)
1556 }
1557 upgrade
1558 },
1559 {
1560 fn transferOwnership(
1561 data: &[u8],
1562 validate: bool,
1563 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1564 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
1565 data,
1566 validate,
1567 )
1568 .map(ProxyAdminCalls::transferOwnership)
1569 }
1570 transferOwnership
1571 },
1572 {
1573 fn getProxyAdmin(
1574 data: &[u8],
1575 validate: bool,
1576 ) -> alloy_sol_types::Result<ProxyAdminCalls> {
1577 <getProxyAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
1578 data,
1579 validate,
1580 )
1581 .map(ProxyAdminCalls::getProxyAdmin)
1582 }
1583 getProxyAdmin
1584 },
1585 ];
1586 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1587 return Err(
1588 alloy_sol_types::Error::unknown_selector(
1589 <Self as alloy_sol_types::SolInterface>::NAME,
1590 selector,
1591 ),
1592 );
1593 };
1594 DECODE_SHIMS[idx](data, validate)
1595 }
1596 #[inline]
1597 fn abi_encoded_size(&self) -> usize {
1598 match self {
1599 Self::changeProxyAdmin(inner) => {
1600 <changeProxyAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
1601 inner,
1602 )
1603 }
1604 Self::getProxyAdmin(inner) => {
1605 <getProxyAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
1606 inner,
1607 )
1608 }
1609 Self::getProxyImplementation(inner) => {
1610 <getProxyImplementationCall as alloy_sol_types::SolCall>::abi_encoded_size(
1611 inner,
1612 )
1613 }
1614 Self::owner(inner) => {
1615 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1616 }
1617 Self::renounceOwnership(inner) => {
1618 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
1619 inner,
1620 )
1621 }
1622 Self::transferOwnership(inner) => {
1623 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
1624 inner,
1625 )
1626 }
1627 Self::upgrade(inner) => {
1628 <upgradeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1629 }
1630 Self::upgradeAndCall(inner) => {
1631 <upgradeAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(
1632 inner,
1633 )
1634 }
1635 }
1636 }
1637 #[inline]
1638 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1639 match self {
1640 Self::changeProxyAdmin(inner) => {
1641 <changeProxyAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
1642 inner,
1643 out,
1644 )
1645 }
1646 Self::getProxyAdmin(inner) => {
1647 <getProxyAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
1648 inner,
1649 out,
1650 )
1651 }
1652 Self::getProxyImplementation(inner) => {
1653 <getProxyImplementationCall as alloy_sol_types::SolCall>::abi_encode_raw(
1654 inner,
1655 out,
1656 )
1657 }
1658 Self::owner(inner) => {
1659 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
1660 }
1661 Self::renounceOwnership(inner) => {
1662 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
1663 inner,
1664 out,
1665 )
1666 }
1667 Self::transferOwnership(inner) => {
1668 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
1669 inner,
1670 out,
1671 )
1672 }
1673 Self::upgrade(inner) => {
1674 <upgradeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
1675 }
1676 Self::upgradeAndCall(inner) => {
1677 <upgradeAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(
1678 inner,
1679 out,
1680 )
1681 }
1682 }
1683 }
1684 }
1685 #[derive(Debug, PartialEq, Eq, Hash)]
1687 pub enum ProxyAdminEvents {
1688 #[allow(missing_docs)]
1689 OwnershipTransferred(OwnershipTransferred),
1690 }
1691 #[automatically_derived]
1692 impl ProxyAdminEvents {
1693 pub const SELECTORS: &'static [[u8; 32usize]] = &[
1700 [
1701 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
1702 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
1703 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
1704 ],
1705 ];
1706 }
1707 #[automatically_derived]
1708 impl alloy_sol_types::SolEventInterface for ProxyAdminEvents {
1709 const NAME: &'static str = "ProxyAdminEvents";
1710 const COUNT: usize = 1usize;
1711 fn decode_raw_log(
1712 topics: &[alloy_sol_types::Word],
1713 data: &[u8],
1714 validate: bool,
1715 ) -> alloy_sol_types::Result<Self> {
1716 match topics.first().copied() {
1717 Some(
1718 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
1719 ) => {
1720 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
1721 topics,
1722 data,
1723 validate,
1724 )
1725 .map(Self::OwnershipTransferred)
1726 }
1727 _ => {
1728 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
1729 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
1730 log: alloy_sol_types::private::Box::new(
1731 alloy_sol_types::private::LogData::new_unchecked(
1732 topics.to_vec(),
1733 data.to_vec().into(),
1734 ),
1735 ),
1736 })
1737 }
1738 }
1739 }
1740 }
1741 #[automatically_derived]
1742 impl alloy_sol_types::private::IntoLogData for ProxyAdminEvents {
1743 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1744 match self {
1745 Self::OwnershipTransferred(inner) => {
1746 alloy_sol_types::private::IntoLogData::to_log_data(inner)
1747 }
1748 }
1749 }
1750 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1751 match self {
1752 Self::OwnershipTransferred(inner) => {
1753 alloy_sol_types::private::IntoLogData::into_log_data(inner)
1754 }
1755 }
1756 }
1757 }
1758 use alloy::contract as alloy_contract;
1759 #[inline]
1763 pub const fn new<
1764 T: alloy_contract::private::Transport + ::core::clone::Clone,
1765 P: alloy_contract::private::Provider<T, N>,
1766 N: alloy_contract::private::Network,
1767 >(
1768 address: alloy_sol_types::private::Address,
1769 provider: P,
1770 ) -> ProxyAdminInstance<T, P, N> {
1771 ProxyAdminInstance::<T, P, N>::new(address, provider)
1772 }
1773 #[inline]
1779 pub fn deploy<
1780 T: alloy_contract::private::Transport + ::core::clone::Clone,
1781 P: alloy_contract::private::Provider<T, N>,
1782 N: alloy_contract::private::Network,
1783 >(
1784 provider: P,
1785 ) -> impl ::core::future::Future<
1786 Output = alloy_contract::Result<ProxyAdminInstance<T, P, N>>,
1787 > {
1788 ProxyAdminInstance::<T, P, N>::deploy(provider)
1789 }
1790 #[inline]
1796 pub fn deploy_builder<
1797 T: alloy_contract::private::Transport + ::core::clone::Clone,
1798 P: alloy_contract::private::Provider<T, N>,
1799 N: alloy_contract::private::Network,
1800 >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
1801 ProxyAdminInstance::<T, P, N>::deploy_builder(provider)
1802 }
1803 #[derive(Clone)]
1815 pub struct ProxyAdminInstance<T, P, N = alloy_contract::private::Ethereum> {
1816 address: alloy_sol_types::private::Address,
1817 provider: P,
1818 _network_transport: ::core::marker::PhantomData<(N, T)>,
1819 }
1820 #[automatically_derived]
1821 impl<T, P, N> ::core::fmt::Debug for ProxyAdminInstance<T, P, N> {
1822 #[inline]
1823 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1824 f.debug_tuple("ProxyAdminInstance").field(&self.address).finish()
1825 }
1826 }
1827 #[automatically_derived]
1829 impl<
1830 T: alloy_contract::private::Transport + ::core::clone::Clone,
1831 P: alloy_contract::private::Provider<T, N>,
1832 N: alloy_contract::private::Network,
1833 > ProxyAdminInstance<T, P, N> {
1834 #[inline]
1838 pub const fn new(
1839 address: alloy_sol_types::private::Address,
1840 provider: P,
1841 ) -> Self {
1842 Self {
1843 address,
1844 provider,
1845 _network_transport: ::core::marker::PhantomData,
1846 }
1847 }
1848 #[inline]
1854 pub async fn deploy(
1855 provider: P,
1856 ) -> alloy_contract::Result<ProxyAdminInstance<T, P, N>> {
1857 let call_builder = Self::deploy_builder(provider);
1858 let contract_address = call_builder.deploy().await?;
1859 Ok(Self::new(contract_address, call_builder.provider))
1860 }
1861 #[inline]
1867 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
1868 alloy_contract::RawCallBuilder::new_raw_deploy(
1869 provider,
1870 ::core::clone::Clone::clone(&BYTECODE),
1871 )
1872 }
1873 #[inline]
1875 pub const fn address(&self) -> &alloy_sol_types::private::Address {
1876 &self.address
1877 }
1878 #[inline]
1880 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1881 self.address = address;
1882 }
1883 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1885 self.set_address(address);
1886 self
1887 }
1888 #[inline]
1890 pub const fn provider(&self) -> &P {
1891 &self.provider
1892 }
1893 }
1894 impl<T, P: ::core::clone::Clone, N> ProxyAdminInstance<T, &P, N> {
1895 #[inline]
1897 pub fn with_cloned_provider(self) -> ProxyAdminInstance<T, P, N> {
1898 ProxyAdminInstance {
1899 address: self.address,
1900 provider: ::core::clone::Clone::clone(&self.provider),
1901 _network_transport: ::core::marker::PhantomData,
1902 }
1903 }
1904 }
1905 #[automatically_derived]
1907 impl<
1908 T: alloy_contract::private::Transport + ::core::clone::Clone,
1909 P: alloy_contract::private::Provider<T, N>,
1910 N: alloy_contract::private::Network,
1911 > ProxyAdminInstance<T, P, N> {
1912 pub fn call_builder<C: alloy_sol_types::SolCall>(
1917 &self,
1918 call: &C,
1919 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
1920 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1921 }
1922 pub fn changeProxyAdmin(
1924 &self,
1925 proxy: alloy::sol_types::private::Address,
1926 newAdmin: alloy::sol_types::private::Address,
1927 ) -> alloy_contract::SolCallBuilder<T, &P, changeProxyAdminCall, N> {
1928 self.call_builder(
1929 &changeProxyAdminCall {
1930 proxy,
1931 newAdmin,
1932 },
1933 )
1934 }
1935 pub fn getProxyAdmin(
1937 &self,
1938 proxy: alloy::sol_types::private::Address,
1939 ) -> alloy_contract::SolCallBuilder<T, &P, getProxyAdminCall, N> {
1940 self.call_builder(&getProxyAdminCall { proxy })
1941 }
1942 pub fn getProxyImplementation(
1944 &self,
1945 proxy: alloy::sol_types::private::Address,
1946 ) -> alloy_contract::SolCallBuilder<T, &P, getProxyImplementationCall, N> {
1947 self.call_builder(
1948 &getProxyImplementationCall {
1949 proxy,
1950 },
1951 )
1952 }
1953 pub fn owner(&self) -> alloy_contract::SolCallBuilder<T, &P, ownerCall, N> {
1955 self.call_builder(&ownerCall {})
1956 }
1957 pub fn renounceOwnership(
1959 &self,
1960 ) -> alloy_contract::SolCallBuilder<T, &P, renounceOwnershipCall, N> {
1961 self.call_builder(&renounceOwnershipCall {})
1962 }
1963 pub fn transferOwnership(
1965 &self,
1966 newOwner: alloy::sol_types::private::Address,
1967 ) -> alloy_contract::SolCallBuilder<T, &P, transferOwnershipCall, N> {
1968 self.call_builder(&transferOwnershipCall { newOwner })
1969 }
1970 pub fn upgrade(
1972 &self,
1973 proxy: alloy::sol_types::private::Address,
1974 implementation: alloy::sol_types::private::Address,
1975 ) -> alloy_contract::SolCallBuilder<T, &P, upgradeCall, N> {
1976 self.call_builder(
1977 &upgradeCall {
1978 proxy,
1979 implementation,
1980 },
1981 )
1982 }
1983 pub fn upgradeAndCall(
1985 &self,
1986 proxy: alloy::sol_types::private::Address,
1987 implementation: alloy::sol_types::private::Address,
1988 data: alloy::sol_types::private::Bytes,
1989 ) -> alloy_contract::SolCallBuilder<T, &P, upgradeAndCallCall, N> {
1990 self.call_builder(
1991 &upgradeAndCallCall {
1992 proxy,
1993 implementation,
1994 data,
1995 },
1996 )
1997 }
1998 }
1999 #[automatically_derived]
2001 impl<
2002 T: alloy_contract::private::Transport + ::core::clone::Clone,
2003 P: alloy_contract::private::Provider<T, N>,
2004 N: alloy_contract::private::Network,
2005 > ProxyAdminInstance<T, P, N> {
2006 pub fn event_filter<E: alloy_sol_types::SolEvent>(
2011 &self,
2012 ) -> alloy_contract::Event<T, &P, E, N> {
2013 alloy_contract::Event::new_sol(&self.provider, &self.address)
2014 }
2015 pub fn OwnershipTransferred_filter(
2017 &self,
2018 ) -> alloy_contract::Event<T, &P, OwnershipTransferred, N> {
2019 self.event_filter::<OwnershipTransferred>()
2020 }
2021 }
2022}