1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use PauserRegistry::*;
3
4#[allow(
157 non_camel_case_types,
158 non_snake_case,
159 clippy::pub_underscore_fields,
160 clippy::style,
161 clippy::empty_structs_with_brackets
162)]
163pub mod PauserRegistry {
164 use super::*;
165 use alloy::sol_types as alloy_sol_types;
166 #[rustfmt::skip]
172 #[allow(clippy::all)]
173 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
174 b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x05\xC88\x03\x80a\x05\xC8\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01\xC2V[_[\x82Q\x81\x10\x15a\0kWa\0c\x83\x82\x81Q\x81\x10a\0NWa\0Na\x02\x9EV[` \x02` \x01\x01Q`\x01a\0|` \x1B` \x1CV[`\x01\x01a\x000V[Pa\0u\x81a\x01\x03V[PPa\x02\xB2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\0\xA3W`@Qc9\xB1\x90\xBB`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x81\x81R` \x81\x81R`@\x91\x82\x90 \x80T`\xFF\x19\x16\x85\x15\x15\x90\x81\x17\x90\x91U\x82Q\x93\x84R\x90\x83\x01R\x7Fe\xD3\xA1\xFDL\x13\xF0\\\xBA\x16O\x80\xD0<\xE9\x0F\xB4\xB5\xE2\x19F\xBF\xC3\xAB}\xBDCL-\x0B\x91R\x91\x01`@Q\x80\x91\x03\x90\xA1PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x01*W`@Qc9\xB1\x90\xBB`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T`@\x80Q`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x83\x16` \x83\x01R\x7F\x06\xB4\x16z%(\x88z\x1E\x97\xA3f\xEE\xFE\x85I\xBF\xBF\x1E\xA3\xE6\xAC\x81\xCB%d\xA94\xD2\x0E\x88\x92\x91\x01`@Q\x80\x91\x03\x90\xA1`\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x01\xBDW__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x01\xD3W__\xFD[\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xE8W__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a\x01\xF8W__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\x11Wa\x02\x11a\x01\x93V[`@Q`\x05\x82\x90\x1B\x90`?\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x02?Wa\x02?a\x01\x93V[`@R\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x88\x84\x11\x15a\x02\\W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x02\x82Wa\x02t\x85a\x01\xA7V[\x81R` \x94\x85\x01\x94\x01a\x02cV[P\x94Pa\x02\x95\x92PPP` \x84\x01a\x01\xA7V[\x90P\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[a\x03\t\x80a\x02\xBF_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cF\xFB\xF6\x8E\x14a\0NW\x80c\x85hR\x06\x14a\0\x85W\x80c\xCET\x84(\x14a\0\x9AW\x80c\xEA\xB6mz\x14a\0\xADW[__\xFD[a\0pa\0\\6`\x04a\x02zV[_` \x81\x90R\x90\x81R`@\x90 T`\xFF\x16\x81V[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\x98a\0\x936`\x04a\x02\x9AV[a\0\xD8V[\0[a\0\x98a\0\xA86`\x04a\x02zV[a\x01\x11V[`\x01Ta\0\xC0\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0|V[`\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x01\x03W`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\r\x82\x82a\x01HV[PPV[`\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x01<W`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01E\x81a\x01\xCFV[PV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x01oW`@Qc9\xB1\x90\xBB`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x81\x81R` \x81\x81R`@\x91\x82\x90 \x80T`\xFF\x19\x16\x85\x15\x15\x90\x81\x17\x90\x91U\x82Q\x93\x84R\x90\x83\x01R\x7Fe\xD3\xA1\xFDL\x13\xF0\\\xBA\x16O\x80\xD0<\xE9\x0F\xB4\xB5\xE2\x19F\xBF\xC3\xAB}\xBDCL-\x0B\x91R\x91\x01`@Q\x80\x91\x03\x90\xA1PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x01\xF6W`@Qc9\xB1\x90\xBB`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T`@\x80Q`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x83\x16` \x83\x01R\x7F\x06\xB4\x16z%(\x88z\x1E\x97\xA3f\xEE\xFE\x85I\xBF\xBF\x1E\xA3\xE6\xAC\x81\xCB%d\xA94\xD2\x0E\x88\x92\x91\x01`@Q\x80\x91\x03\x90\xA1`\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02uW__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x02\x8AW__\xFD[a\x02\x93\x82a\x02_V[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x02\xABW__\xFD[a\x02\xB4\x83a\x02_V[\x91P` \x83\x015\x80\x15\x15\x81\x14a\x02\xC8W__\xFD[\x80\x91PP\x92P\x92\x90PV\xFE\xA2dipfsX\"\x12 \xFC4\xC6@\x11\x9E\xE7\x89\xB6\x07@|\x9C\xA3\xEA\x8B\xB2O\x06\xD1\x17}\x9F\xF8q\xBE\xCB\x1D\xD1\xFAy\xB4dsolcC\0\x08\x1B\x003",
175 );
176 #[rustfmt::skip]
182 #[allow(clippy::all)]
183 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
184 b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cF\xFB\xF6\x8E\x14a\0NW\x80c\x85hR\x06\x14a\0\x85W\x80c\xCET\x84(\x14a\0\x9AW\x80c\xEA\xB6mz\x14a\0\xADW[__\xFD[a\0pa\0\\6`\x04a\x02zV[_` \x81\x90R\x90\x81R`@\x90 T`\xFF\x16\x81V[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\x98a\0\x936`\x04a\x02\x9AV[a\0\xD8V[\0[a\0\x98a\0\xA86`\x04a\x02zV[a\x01\x11V[`\x01Ta\0\xC0\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0|V[`\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x01\x03W`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\r\x82\x82a\x01HV[PPV[`\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x01<W`@QcyH!\xFF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01E\x81a\x01\xCFV[PV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x01oW`@Qc9\xB1\x90\xBB`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x81\x81R` \x81\x81R`@\x91\x82\x90 \x80T`\xFF\x19\x16\x85\x15\x15\x90\x81\x17\x90\x91U\x82Q\x93\x84R\x90\x83\x01R\x7Fe\xD3\xA1\xFDL\x13\xF0\\\xBA\x16O\x80\xD0<\xE9\x0F\xB4\xB5\xE2\x19F\xBF\xC3\xAB}\xBDCL-\x0B\x91R\x91\x01`@Q\x80\x91\x03\x90\xA1PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x01\xF6W`@Qc9\xB1\x90\xBB`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T`@\x80Q`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x83\x16` \x83\x01R\x7F\x06\xB4\x16z%(\x88z\x1E\x97\xA3f\xEE\xFE\x85I\xBF\xBF\x1E\xA3\xE6\xAC\x81\xCB%d\xA94\xD2\x0E\x88\x92\x91\x01`@Q\x80\x91\x03\x90\xA1`\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02uW__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x02\x8AW__\xFD[a\x02\x93\x82a\x02_V[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x02\xABW__\xFD[a\x02\xB4\x83a\x02_V[\x91P` \x83\x015\x80\x15\x15\x81\x14a\x02\xC8W__\xFD[\x80\x91PP\x92P\x92\x90PV\xFE\xA2dipfsX\"\x12 \xFC4\xC6@\x11\x9E\xE7\x89\xB6\x07@|\x9C\xA3\xEA\x8B\xB2O\x06\xD1\x17}\x9F\xF8q\xBE\xCB\x1D\xD1\xFAy\xB4dsolcC\0\x08\x1B\x003",
185 );
186 #[derive(serde::Serialize, serde::Deserialize)]
187 #[derive(Default, Debug, PartialEq, Eq, Hash)]
188 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
193 #[derive(Clone)]
194 pub struct InputAddressZero;
195 #[allow(
196 non_camel_case_types,
197 non_snake_case,
198 clippy::pub_underscore_fields,
199 clippy::style
200 )]
201 const _: () = {
202 use alloy::sol_types as alloy_sol_types;
203 #[doc(hidden)]
204 type UnderlyingSolTuple<'a> = ();
205 #[doc(hidden)]
206 type UnderlyingRustTuple<'a> = ();
207 #[cfg(test)]
208 #[allow(dead_code, unreachable_patterns)]
209 fn _type_assertion(
210 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
211 ) {
212 match _t {
213 alloy_sol_types::private::AssertTypeEq::<
214 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
215 >(_) => {}
216 }
217 }
218 #[automatically_derived]
219 #[doc(hidden)]
220 impl ::core::convert::From<InputAddressZero> for UnderlyingRustTuple<'_> {
221 fn from(value: InputAddressZero) -> Self {
222 ()
223 }
224 }
225 #[automatically_derived]
226 #[doc(hidden)]
227 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputAddressZero {
228 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
229 Self
230 }
231 }
232 #[automatically_derived]
233 impl alloy_sol_types::SolError for InputAddressZero {
234 type Parameters<'a> = UnderlyingSolTuple<'a>;
235 type Token<'a> = <Self::Parameters<
236 'a,
237 > as alloy_sol_types::SolType>::Token<'a>;
238 const SIGNATURE: &'static str = "InputAddressZero()";
239 const SELECTOR: [u8; 4] = [115u8, 99u8, 33u8, 118u8];
240 #[inline]
241 fn new<'a>(
242 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
243 ) -> Self {
244 tuple.into()
245 }
246 #[inline]
247 fn tokenize(&self) -> Self::Token<'_> {
248 ()
249 }
250 #[inline]
251 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
252 <Self::Parameters<
253 '_,
254 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
255 .map(Self::new)
256 }
257 }
258 };
259 #[derive(serde::Serialize, serde::Deserialize)]
260 #[derive(Default, Debug, PartialEq, Eq, Hash)]
261 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
266 #[derive(Clone)]
267 pub struct OnlyUnpauser;
268 #[allow(
269 non_camel_case_types,
270 non_snake_case,
271 clippy::pub_underscore_fields,
272 clippy::style
273 )]
274 const _: () = {
275 use alloy::sol_types as alloy_sol_types;
276 #[doc(hidden)]
277 type UnderlyingSolTuple<'a> = ();
278 #[doc(hidden)]
279 type UnderlyingRustTuple<'a> = ();
280 #[cfg(test)]
281 #[allow(dead_code, unreachable_patterns)]
282 fn _type_assertion(
283 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
284 ) {
285 match _t {
286 alloy_sol_types::private::AssertTypeEq::<
287 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
288 >(_) => {}
289 }
290 }
291 #[automatically_derived]
292 #[doc(hidden)]
293 impl ::core::convert::From<OnlyUnpauser> for UnderlyingRustTuple<'_> {
294 fn from(value: OnlyUnpauser) -> Self {
295 ()
296 }
297 }
298 #[automatically_derived]
299 #[doc(hidden)]
300 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnpauser {
301 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
302 Self
303 }
304 }
305 #[automatically_derived]
306 impl alloy_sol_types::SolError for OnlyUnpauser {
307 type Parameters<'a> = UnderlyingSolTuple<'a>;
308 type Token<'a> = <Self::Parameters<
309 'a,
310 > as alloy_sol_types::SolType>::Token<'a>;
311 const SIGNATURE: &'static str = "OnlyUnpauser()";
312 const SELECTOR: [u8; 4] = [121u8, 72u8, 33u8, 255u8];
313 #[inline]
314 fn new<'a>(
315 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
316 ) -> Self {
317 tuple.into()
318 }
319 #[inline]
320 fn tokenize(&self) -> Self::Token<'_> {
321 ()
322 }
323 #[inline]
324 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
325 <Self::Parameters<
326 '_,
327 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
328 .map(Self::new)
329 }
330 }
331 };
332 #[derive(serde::Serialize, serde::Deserialize)]
333 #[derive(Default, Debug, PartialEq, Eq, Hash)]
334 #[allow(
339 non_camel_case_types,
340 non_snake_case,
341 clippy::pub_underscore_fields,
342 clippy::style
343 )]
344 #[derive(Clone)]
345 pub struct PauserStatusChanged {
346 #[allow(missing_docs)]
347 pub pauser: alloy::sol_types::private::Address,
348 #[allow(missing_docs)]
349 pub canPause: bool,
350 }
351 #[allow(
352 non_camel_case_types,
353 non_snake_case,
354 clippy::pub_underscore_fields,
355 clippy::style
356 )]
357 const _: () = {
358 use alloy::sol_types as alloy_sol_types;
359 #[automatically_derived]
360 impl alloy_sol_types::SolEvent for PauserStatusChanged {
361 type DataTuple<'a> = (
362 alloy::sol_types::sol_data::Address,
363 alloy::sol_types::sol_data::Bool,
364 );
365 type DataToken<'a> = <Self::DataTuple<
366 'a,
367 > as alloy_sol_types::SolType>::Token<'a>;
368 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
369 const SIGNATURE: &'static str = "PauserStatusChanged(address,bool)";
370 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
371 101u8, 211u8, 161u8, 253u8, 76u8, 19u8, 240u8, 92u8, 186u8, 22u8, 79u8,
372 128u8, 208u8, 60u8, 233u8, 15u8, 180u8, 181u8, 226u8, 25u8, 70u8, 191u8,
373 195u8, 171u8, 125u8, 189u8, 67u8, 76u8, 45u8, 11u8, 145u8, 82u8,
374 ]);
375 const ANONYMOUS: bool = false;
376 #[allow(unused_variables)]
377 #[inline]
378 fn new(
379 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
380 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
381 ) -> Self {
382 Self {
383 pauser: data.0,
384 canPause: data.1,
385 }
386 }
387 #[inline]
388 fn check_signature(
389 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
390 ) -> alloy_sol_types::Result<()> {
391 if topics.0 != Self::SIGNATURE_HASH {
392 return Err(
393 alloy_sol_types::Error::invalid_event_signature_hash(
394 Self::SIGNATURE,
395 topics.0,
396 Self::SIGNATURE_HASH,
397 ),
398 );
399 }
400 Ok(())
401 }
402 #[inline]
403 fn tokenize_body(&self) -> Self::DataToken<'_> {
404 (
405 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
406 &self.pauser,
407 ),
408 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
409 &self.canPause,
410 ),
411 )
412 }
413 #[inline]
414 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
415 (Self::SIGNATURE_HASH.into(),)
416 }
417 #[inline]
418 fn encode_topics_raw(
419 &self,
420 out: &mut [alloy_sol_types::abi::token::WordToken],
421 ) -> alloy_sol_types::Result<()> {
422 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
423 return Err(alloy_sol_types::Error::Overrun);
424 }
425 out[0usize] = alloy_sol_types::abi::token::WordToken(
426 Self::SIGNATURE_HASH,
427 );
428 Ok(())
429 }
430 }
431 #[automatically_derived]
432 impl alloy_sol_types::private::IntoLogData for PauserStatusChanged {
433 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
434 From::from(self)
435 }
436 fn into_log_data(self) -> alloy_sol_types::private::LogData {
437 From::from(&self)
438 }
439 }
440 #[automatically_derived]
441 impl From<&PauserStatusChanged> for alloy_sol_types::private::LogData {
442 #[inline]
443 fn from(this: &PauserStatusChanged) -> alloy_sol_types::private::LogData {
444 alloy_sol_types::SolEvent::encode_log_data(this)
445 }
446 }
447 };
448 #[derive(serde::Serialize, serde::Deserialize)]
449 #[derive(Default, Debug, PartialEq, Eq, Hash)]
450 #[allow(
455 non_camel_case_types,
456 non_snake_case,
457 clippy::pub_underscore_fields,
458 clippy::style
459 )]
460 #[derive(Clone)]
461 pub struct UnpauserChanged {
462 #[allow(missing_docs)]
463 pub previousUnpauser: alloy::sol_types::private::Address,
464 #[allow(missing_docs)]
465 pub newUnpauser: alloy::sol_types::private::Address,
466 }
467 #[allow(
468 non_camel_case_types,
469 non_snake_case,
470 clippy::pub_underscore_fields,
471 clippy::style
472 )]
473 const _: () = {
474 use alloy::sol_types as alloy_sol_types;
475 #[automatically_derived]
476 impl alloy_sol_types::SolEvent for UnpauserChanged {
477 type DataTuple<'a> = (
478 alloy::sol_types::sol_data::Address,
479 alloy::sol_types::sol_data::Address,
480 );
481 type DataToken<'a> = <Self::DataTuple<
482 'a,
483 > as alloy_sol_types::SolType>::Token<'a>;
484 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
485 const SIGNATURE: &'static str = "UnpauserChanged(address,address)";
486 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
487 6u8, 180u8, 22u8, 122u8, 37u8, 40u8, 136u8, 122u8, 30u8, 151u8, 163u8,
488 102u8, 238u8, 254u8, 133u8, 73u8, 191u8, 191u8, 30u8, 163u8, 230u8,
489 172u8, 129u8, 203u8, 37u8, 100u8, 169u8, 52u8, 210u8, 14u8, 136u8, 146u8,
490 ]);
491 const ANONYMOUS: bool = false;
492 #[allow(unused_variables)]
493 #[inline]
494 fn new(
495 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
496 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
497 ) -> Self {
498 Self {
499 previousUnpauser: data.0,
500 newUnpauser: data.1,
501 }
502 }
503 #[inline]
504 fn check_signature(
505 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
506 ) -> alloy_sol_types::Result<()> {
507 if topics.0 != Self::SIGNATURE_HASH {
508 return Err(
509 alloy_sol_types::Error::invalid_event_signature_hash(
510 Self::SIGNATURE,
511 topics.0,
512 Self::SIGNATURE_HASH,
513 ),
514 );
515 }
516 Ok(())
517 }
518 #[inline]
519 fn tokenize_body(&self) -> Self::DataToken<'_> {
520 (
521 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
522 &self.previousUnpauser,
523 ),
524 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
525 &self.newUnpauser,
526 ),
527 )
528 }
529 #[inline]
530 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
531 (Self::SIGNATURE_HASH.into(),)
532 }
533 #[inline]
534 fn encode_topics_raw(
535 &self,
536 out: &mut [alloy_sol_types::abi::token::WordToken],
537 ) -> alloy_sol_types::Result<()> {
538 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
539 return Err(alloy_sol_types::Error::Overrun);
540 }
541 out[0usize] = alloy_sol_types::abi::token::WordToken(
542 Self::SIGNATURE_HASH,
543 );
544 Ok(())
545 }
546 }
547 #[automatically_derived]
548 impl alloy_sol_types::private::IntoLogData for UnpauserChanged {
549 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
550 From::from(self)
551 }
552 fn into_log_data(self) -> alloy_sol_types::private::LogData {
553 From::from(&self)
554 }
555 }
556 #[automatically_derived]
557 impl From<&UnpauserChanged> for alloy_sol_types::private::LogData {
558 #[inline]
559 fn from(this: &UnpauserChanged) -> alloy_sol_types::private::LogData {
560 alloy_sol_types::SolEvent::encode_log_data(this)
561 }
562 }
563 };
564 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
569 #[derive(Clone)]
570 pub struct constructorCall {
571 #[allow(missing_docs)]
572 pub _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
573 #[allow(missing_docs)]
574 pub _unpauser: alloy::sol_types::private::Address,
575 }
576 const _: () = {
577 use alloy::sol_types as alloy_sol_types;
578 {
579 #[doc(hidden)]
580 type UnderlyingSolTuple<'a> = (
581 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
582 alloy::sol_types::sol_data::Address,
583 );
584 #[doc(hidden)]
585 type UnderlyingRustTuple<'a> = (
586 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
587 alloy::sol_types::private::Address,
588 );
589 #[cfg(test)]
590 #[allow(dead_code, unreachable_patterns)]
591 fn _type_assertion(
592 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
593 ) {
594 match _t {
595 alloy_sol_types::private::AssertTypeEq::<
596 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
597 >(_) => {}
598 }
599 }
600 #[automatically_derived]
601 #[doc(hidden)]
602 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
603 fn from(value: constructorCall) -> Self {
604 (value._pausers, value._unpauser)
605 }
606 }
607 #[automatically_derived]
608 #[doc(hidden)]
609 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
610 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
611 Self {
612 _pausers: tuple.0,
613 _unpauser: tuple.1,
614 }
615 }
616 }
617 }
618 #[automatically_derived]
619 impl alloy_sol_types::SolConstructor for constructorCall {
620 type Parameters<'a> = (
621 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
622 alloy::sol_types::sol_data::Address,
623 );
624 type Token<'a> = <Self::Parameters<
625 'a,
626 > as alloy_sol_types::SolType>::Token<'a>;
627 #[inline]
628 fn new<'a>(
629 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
630 ) -> Self {
631 tuple.into()
632 }
633 #[inline]
634 fn tokenize(&self) -> Self::Token<'_> {
635 (
636 <alloy::sol_types::sol_data::Array<
637 alloy::sol_types::sol_data::Address,
638 > as alloy_sol_types::SolType>::tokenize(&self._pausers),
639 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
640 &self._unpauser,
641 ),
642 )
643 }
644 }
645 };
646 #[derive(serde::Serialize, serde::Deserialize)]
647 #[derive(Default, Debug, PartialEq, Eq, Hash)]
648 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
653 #[derive(Clone)]
654 pub struct isPauserCall(pub alloy::sol_types::private::Address);
655 #[derive(serde::Serialize, serde::Deserialize)]
656 #[derive(Default, Debug, PartialEq, Eq, Hash)]
657 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
659 #[derive(Clone)]
660 pub struct isPauserReturn {
661 #[allow(missing_docs)]
662 pub _0: bool,
663 }
664 #[allow(
665 non_camel_case_types,
666 non_snake_case,
667 clippy::pub_underscore_fields,
668 clippy::style
669 )]
670 const _: () = {
671 use alloy::sol_types as alloy_sol_types;
672 {
673 #[doc(hidden)]
674 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
675 #[doc(hidden)]
676 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
677 #[cfg(test)]
678 #[allow(dead_code, unreachable_patterns)]
679 fn _type_assertion(
680 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
681 ) {
682 match _t {
683 alloy_sol_types::private::AssertTypeEq::<
684 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
685 >(_) => {}
686 }
687 }
688 #[automatically_derived]
689 #[doc(hidden)]
690 impl ::core::convert::From<isPauserCall> for UnderlyingRustTuple<'_> {
691 fn from(value: isPauserCall) -> Self {
692 (value.0,)
693 }
694 }
695 #[automatically_derived]
696 #[doc(hidden)]
697 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPauserCall {
698 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
699 Self(tuple.0)
700 }
701 }
702 }
703 {
704 #[doc(hidden)]
705 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
706 #[doc(hidden)]
707 type UnderlyingRustTuple<'a> = (bool,);
708 #[cfg(test)]
709 #[allow(dead_code, unreachable_patterns)]
710 fn _type_assertion(
711 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
712 ) {
713 match _t {
714 alloy_sol_types::private::AssertTypeEq::<
715 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
716 >(_) => {}
717 }
718 }
719 #[automatically_derived]
720 #[doc(hidden)]
721 impl ::core::convert::From<isPauserReturn> for UnderlyingRustTuple<'_> {
722 fn from(value: isPauserReturn) -> Self {
723 (value._0,)
724 }
725 }
726 #[automatically_derived]
727 #[doc(hidden)]
728 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPauserReturn {
729 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
730 Self { _0: tuple.0 }
731 }
732 }
733 }
734 #[automatically_derived]
735 impl alloy_sol_types::SolCall for isPauserCall {
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 = bool;
741 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
742 type ReturnToken<'a> = <Self::ReturnTuple<
743 'a,
744 > as alloy_sol_types::SolType>::Token<'a>;
745 const SIGNATURE: &'static str = "isPauser(address)";
746 const SELECTOR: [u8; 4] = [70u8, 251u8, 246u8, 142u8];
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.0,
758 ),
759 )
760 }
761 #[inline]
762 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
763 (
764 <alloy::sol_types::sol_data::Bool 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: isPauserReturn = 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: isPauserReturn = 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 setIsPauserCall {
802 #[allow(missing_docs)]
803 pub newPauser: alloy::sol_types::private::Address,
804 #[allow(missing_docs)]
805 pub canPause: bool,
806 }
807 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
809 #[derive(Clone)]
810 pub struct setIsPauserReturn {}
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 alloy::sol_types::sol_data::Address,
823 alloy::sol_types::sol_data::Bool,
824 );
825 #[doc(hidden)]
826 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, bool);
827 #[cfg(test)]
828 #[allow(dead_code, unreachable_patterns)]
829 fn _type_assertion(
830 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
831 ) {
832 match _t {
833 alloy_sol_types::private::AssertTypeEq::<
834 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
835 >(_) => {}
836 }
837 }
838 #[automatically_derived]
839 #[doc(hidden)]
840 impl ::core::convert::From<setIsPauserCall> for UnderlyingRustTuple<'_> {
841 fn from(value: setIsPauserCall) -> Self {
842 (value.newPauser, value.canPause)
843 }
844 }
845 #[automatically_derived]
846 #[doc(hidden)]
847 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setIsPauserCall {
848 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
849 Self {
850 newPauser: tuple.0,
851 canPause: tuple.1,
852 }
853 }
854 }
855 }
856 {
857 #[doc(hidden)]
858 type UnderlyingSolTuple<'a> = ();
859 #[doc(hidden)]
860 type UnderlyingRustTuple<'a> = ();
861 #[cfg(test)]
862 #[allow(dead_code, unreachable_patterns)]
863 fn _type_assertion(
864 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
865 ) {
866 match _t {
867 alloy_sol_types::private::AssertTypeEq::<
868 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
869 >(_) => {}
870 }
871 }
872 #[automatically_derived]
873 #[doc(hidden)]
874 impl ::core::convert::From<setIsPauserReturn> for UnderlyingRustTuple<'_> {
875 fn from(value: setIsPauserReturn) -> Self {
876 ()
877 }
878 }
879 #[automatically_derived]
880 #[doc(hidden)]
881 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setIsPauserReturn {
882 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
883 Self {}
884 }
885 }
886 }
887 impl setIsPauserReturn {
888 fn _tokenize(
889 &self,
890 ) -> <setIsPauserCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
891 ()
892 }
893 }
894 #[automatically_derived]
895 impl alloy_sol_types::SolCall for setIsPauserCall {
896 type Parameters<'a> = (
897 alloy::sol_types::sol_data::Address,
898 alloy::sol_types::sol_data::Bool,
899 );
900 type Token<'a> = <Self::Parameters<
901 'a,
902 > as alloy_sol_types::SolType>::Token<'a>;
903 type Return = setIsPauserReturn;
904 type ReturnTuple<'a> = ();
905 type ReturnToken<'a> = <Self::ReturnTuple<
906 'a,
907 > as alloy_sol_types::SolType>::Token<'a>;
908 const SIGNATURE: &'static str = "setIsPauser(address,bool)";
909 const SELECTOR: [u8; 4] = [133u8, 104u8, 82u8, 6u8];
910 #[inline]
911 fn new<'a>(
912 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
913 ) -> Self {
914 tuple.into()
915 }
916 #[inline]
917 fn tokenize(&self) -> Self::Token<'_> {
918 (
919 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
920 &self.newPauser,
921 ),
922 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
923 &self.canPause,
924 ),
925 )
926 }
927 #[inline]
928 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
929 setIsPauserReturn::_tokenize(ret)
930 }
931 #[inline]
932 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
933 <Self::ReturnTuple<
934 '_,
935 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
936 .map(Into::into)
937 }
938 #[inline]
939 fn abi_decode_returns_validate(
940 data: &[u8],
941 ) -> alloy_sol_types::Result<Self::Return> {
942 <Self::ReturnTuple<
943 '_,
944 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
945 .map(Into::into)
946 }
947 }
948 };
949 #[derive(serde::Serialize, serde::Deserialize)]
950 #[derive(Default, Debug, PartialEq, Eq, Hash)]
951 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
956 #[derive(Clone)]
957 pub struct setUnpauserCall {
958 #[allow(missing_docs)]
959 pub newUnpauser: alloy::sol_types::private::Address,
960 }
961 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
963 #[derive(Clone)]
964 pub struct setUnpauserReturn {}
965 #[allow(
966 non_camel_case_types,
967 non_snake_case,
968 clippy::pub_underscore_fields,
969 clippy::style
970 )]
971 const _: () = {
972 use alloy::sol_types as alloy_sol_types;
973 {
974 #[doc(hidden)]
975 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
976 #[doc(hidden)]
977 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
978 #[cfg(test)]
979 #[allow(dead_code, unreachable_patterns)]
980 fn _type_assertion(
981 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
982 ) {
983 match _t {
984 alloy_sol_types::private::AssertTypeEq::<
985 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
986 >(_) => {}
987 }
988 }
989 #[automatically_derived]
990 #[doc(hidden)]
991 impl ::core::convert::From<setUnpauserCall> for UnderlyingRustTuple<'_> {
992 fn from(value: setUnpauserCall) -> Self {
993 (value.newUnpauser,)
994 }
995 }
996 #[automatically_derived]
997 #[doc(hidden)]
998 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setUnpauserCall {
999 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1000 Self { newUnpauser: tuple.0 }
1001 }
1002 }
1003 }
1004 {
1005 #[doc(hidden)]
1006 type UnderlyingSolTuple<'a> = ();
1007 #[doc(hidden)]
1008 type UnderlyingRustTuple<'a> = ();
1009 #[cfg(test)]
1010 #[allow(dead_code, unreachable_patterns)]
1011 fn _type_assertion(
1012 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1013 ) {
1014 match _t {
1015 alloy_sol_types::private::AssertTypeEq::<
1016 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1017 >(_) => {}
1018 }
1019 }
1020 #[automatically_derived]
1021 #[doc(hidden)]
1022 impl ::core::convert::From<setUnpauserReturn> for UnderlyingRustTuple<'_> {
1023 fn from(value: setUnpauserReturn) -> Self {
1024 ()
1025 }
1026 }
1027 #[automatically_derived]
1028 #[doc(hidden)]
1029 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setUnpauserReturn {
1030 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1031 Self {}
1032 }
1033 }
1034 }
1035 impl setUnpauserReturn {
1036 fn _tokenize(
1037 &self,
1038 ) -> <setUnpauserCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1039 ()
1040 }
1041 }
1042 #[automatically_derived]
1043 impl alloy_sol_types::SolCall for setUnpauserCall {
1044 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1045 type Token<'a> = <Self::Parameters<
1046 'a,
1047 > as alloy_sol_types::SolType>::Token<'a>;
1048 type Return = setUnpauserReturn;
1049 type ReturnTuple<'a> = ();
1050 type ReturnToken<'a> = <Self::ReturnTuple<
1051 'a,
1052 > as alloy_sol_types::SolType>::Token<'a>;
1053 const SIGNATURE: &'static str = "setUnpauser(address)";
1054 const SELECTOR: [u8; 4] = [206u8, 84u8, 132u8, 40u8];
1055 #[inline]
1056 fn new<'a>(
1057 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1058 ) -> Self {
1059 tuple.into()
1060 }
1061 #[inline]
1062 fn tokenize(&self) -> Self::Token<'_> {
1063 (
1064 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1065 &self.newUnpauser,
1066 ),
1067 )
1068 }
1069 #[inline]
1070 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1071 setUnpauserReturn::_tokenize(ret)
1072 }
1073 #[inline]
1074 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1075 <Self::ReturnTuple<
1076 '_,
1077 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1078 .map(Into::into)
1079 }
1080 #[inline]
1081 fn abi_decode_returns_validate(
1082 data: &[u8],
1083 ) -> alloy_sol_types::Result<Self::Return> {
1084 <Self::ReturnTuple<
1085 '_,
1086 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1087 .map(Into::into)
1088 }
1089 }
1090 };
1091 #[derive(serde::Serialize, serde::Deserialize)]
1092 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1093 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1098 #[derive(Clone)]
1099 pub struct unpauserCall;
1100 #[derive(serde::Serialize, serde::Deserialize)]
1101 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1102 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1104 #[derive(Clone)]
1105 pub struct unpauserReturn {
1106 #[allow(missing_docs)]
1107 pub _0: alloy::sol_types::private::Address,
1108 }
1109 #[allow(
1110 non_camel_case_types,
1111 non_snake_case,
1112 clippy::pub_underscore_fields,
1113 clippy::style
1114 )]
1115 const _: () = {
1116 use alloy::sol_types as alloy_sol_types;
1117 {
1118 #[doc(hidden)]
1119 type UnderlyingSolTuple<'a> = ();
1120 #[doc(hidden)]
1121 type UnderlyingRustTuple<'a> = ();
1122 #[cfg(test)]
1123 #[allow(dead_code, unreachable_patterns)]
1124 fn _type_assertion(
1125 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1126 ) {
1127 match _t {
1128 alloy_sol_types::private::AssertTypeEq::<
1129 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1130 >(_) => {}
1131 }
1132 }
1133 #[automatically_derived]
1134 #[doc(hidden)]
1135 impl ::core::convert::From<unpauserCall> for UnderlyingRustTuple<'_> {
1136 fn from(value: unpauserCall) -> Self {
1137 ()
1138 }
1139 }
1140 #[automatically_derived]
1141 #[doc(hidden)]
1142 impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauserCall {
1143 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1144 Self
1145 }
1146 }
1147 }
1148 {
1149 #[doc(hidden)]
1150 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1151 #[doc(hidden)]
1152 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1153 #[cfg(test)]
1154 #[allow(dead_code, unreachable_patterns)]
1155 fn _type_assertion(
1156 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1157 ) {
1158 match _t {
1159 alloy_sol_types::private::AssertTypeEq::<
1160 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1161 >(_) => {}
1162 }
1163 }
1164 #[automatically_derived]
1165 #[doc(hidden)]
1166 impl ::core::convert::From<unpauserReturn> for UnderlyingRustTuple<'_> {
1167 fn from(value: unpauserReturn) -> Self {
1168 (value._0,)
1169 }
1170 }
1171 #[automatically_derived]
1172 #[doc(hidden)]
1173 impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauserReturn {
1174 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1175 Self { _0: tuple.0 }
1176 }
1177 }
1178 }
1179 #[automatically_derived]
1180 impl alloy_sol_types::SolCall for unpauserCall {
1181 type Parameters<'a> = ();
1182 type Token<'a> = <Self::Parameters<
1183 'a,
1184 > as alloy_sol_types::SolType>::Token<'a>;
1185 type Return = alloy::sol_types::private::Address;
1186 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1187 type ReturnToken<'a> = <Self::ReturnTuple<
1188 'a,
1189 > as alloy_sol_types::SolType>::Token<'a>;
1190 const SIGNATURE: &'static str = "unpauser()";
1191 const SELECTOR: [u8; 4] = [234u8, 182u8, 109u8, 122u8];
1192 #[inline]
1193 fn new<'a>(
1194 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1195 ) -> Self {
1196 tuple.into()
1197 }
1198 #[inline]
1199 fn tokenize(&self) -> Self::Token<'_> {
1200 ()
1201 }
1202 #[inline]
1203 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1204 (
1205 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1206 ret,
1207 ),
1208 )
1209 }
1210 #[inline]
1211 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1212 <Self::ReturnTuple<
1213 '_,
1214 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1215 .map(|r| {
1216 let r: unpauserReturn = r.into();
1217 r._0
1218 })
1219 }
1220 #[inline]
1221 fn abi_decode_returns_validate(
1222 data: &[u8],
1223 ) -> alloy_sol_types::Result<Self::Return> {
1224 <Self::ReturnTuple<
1225 '_,
1226 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1227 .map(|r| {
1228 let r: unpauserReturn = r.into();
1229 r._0
1230 })
1231 }
1232 }
1233 };
1234 #[derive(serde::Serialize, serde::Deserialize)]
1236 #[derive()]
1237 pub enum PauserRegistryCalls {
1238 #[allow(missing_docs)]
1239 isPauser(isPauserCall),
1240 #[allow(missing_docs)]
1241 setIsPauser(setIsPauserCall),
1242 #[allow(missing_docs)]
1243 setUnpauser(setUnpauserCall),
1244 #[allow(missing_docs)]
1245 unpauser(unpauserCall),
1246 }
1247 #[automatically_derived]
1248 impl PauserRegistryCalls {
1249 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1256 [70u8, 251u8, 246u8, 142u8],
1257 [133u8, 104u8, 82u8, 6u8],
1258 [206u8, 84u8, 132u8, 40u8],
1259 [234u8, 182u8, 109u8, 122u8],
1260 ];
1261 }
1262 #[automatically_derived]
1263 impl alloy_sol_types::SolInterface for PauserRegistryCalls {
1264 const NAME: &'static str = "PauserRegistryCalls";
1265 const MIN_DATA_LENGTH: usize = 0usize;
1266 const COUNT: usize = 4usize;
1267 #[inline]
1268 fn selector(&self) -> [u8; 4] {
1269 match self {
1270 Self::isPauser(_) => <isPauserCall as alloy_sol_types::SolCall>::SELECTOR,
1271 Self::setIsPauser(_) => {
1272 <setIsPauserCall as alloy_sol_types::SolCall>::SELECTOR
1273 }
1274 Self::setUnpauser(_) => {
1275 <setUnpauserCall as alloy_sol_types::SolCall>::SELECTOR
1276 }
1277 Self::unpauser(_) => <unpauserCall as alloy_sol_types::SolCall>::SELECTOR,
1278 }
1279 }
1280 #[inline]
1281 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1282 Self::SELECTORS.get(i).copied()
1283 }
1284 #[inline]
1285 fn valid_selector(selector: [u8; 4]) -> bool {
1286 Self::SELECTORS.binary_search(&selector).is_ok()
1287 }
1288 #[inline]
1289 #[allow(non_snake_case)]
1290 fn abi_decode_raw(
1291 selector: [u8; 4],
1292 data: &[u8],
1293 ) -> alloy_sol_types::Result<Self> {
1294 static DECODE_SHIMS: &[fn(
1295 &[u8],
1296 ) -> alloy_sol_types::Result<PauserRegistryCalls>] = &[
1297 {
1298 fn isPauser(
1299 data: &[u8],
1300 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1301 <isPauserCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
1302 .map(PauserRegistryCalls::isPauser)
1303 }
1304 isPauser
1305 },
1306 {
1307 fn setIsPauser(
1308 data: &[u8],
1309 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1310 <setIsPauserCall as alloy_sol_types::SolCall>::abi_decode_raw(
1311 data,
1312 )
1313 .map(PauserRegistryCalls::setIsPauser)
1314 }
1315 setIsPauser
1316 },
1317 {
1318 fn setUnpauser(
1319 data: &[u8],
1320 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1321 <setUnpauserCall as alloy_sol_types::SolCall>::abi_decode_raw(
1322 data,
1323 )
1324 .map(PauserRegistryCalls::setUnpauser)
1325 }
1326 setUnpauser
1327 },
1328 {
1329 fn unpauser(
1330 data: &[u8],
1331 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1332 <unpauserCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
1333 .map(PauserRegistryCalls::unpauser)
1334 }
1335 unpauser
1336 },
1337 ];
1338 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1339 return Err(
1340 alloy_sol_types::Error::unknown_selector(
1341 <Self as alloy_sol_types::SolInterface>::NAME,
1342 selector,
1343 ),
1344 );
1345 };
1346 DECODE_SHIMS[idx](data)
1347 }
1348 #[inline]
1349 #[allow(non_snake_case)]
1350 fn abi_decode_raw_validate(
1351 selector: [u8; 4],
1352 data: &[u8],
1353 ) -> alloy_sol_types::Result<Self> {
1354 static DECODE_VALIDATE_SHIMS: &[fn(
1355 &[u8],
1356 ) -> alloy_sol_types::Result<PauserRegistryCalls>] = &[
1357 {
1358 fn isPauser(
1359 data: &[u8],
1360 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1361 <isPauserCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1362 data,
1363 )
1364 .map(PauserRegistryCalls::isPauser)
1365 }
1366 isPauser
1367 },
1368 {
1369 fn setIsPauser(
1370 data: &[u8],
1371 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1372 <setIsPauserCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1373 data,
1374 )
1375 .map(PauserRegistryCalls::setIsPauser)
1376 }
1377 setIsPauser
1378 },
1379 {
1380 fn setUnpauser(
1381 data: &[u8],
1382 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1383 <setUnpauserCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1384 data,
1385 )
1386 .map(PauserRegistryCalls::setUnpauser)
1387 }
1388 setUnpauser
1389 },
1390 {
1391 fn unpauser(
1392 data: &[u8],
1393 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1394 <unpauserCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1395 data,
1396 )
1397 .map(PauserRegistryCalls::unpauser)
1398 }
1399 unpauser
1400 },
1401 ];
1402 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1403 return Err(
1404 alloy_sol_types::Error::unknown_selector(
1405 <Self as alloy_sol_types::SolInterface>::NAME,
1406 selector,
1407 ),
1408 );
1409 };
1410 DECODE_VALIDATE_SHIMS[idx](data)
1411 }
1412 #[inline]
1413 fn abi_encoded_size(&self) -> usize {
1414 match self {
1415 Self::isPauser(inner) => {
1416 <isPauserCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1417 }
1418 Self::setIsPauser(inner) => {
1419 <setIsPauserCall as alloy_sol_types::SolCall>::abi_encoded_size(
1420 inner,
1421 )
1422 }
1423 Self::setUnpauser(inner) => {
1424 <setUnpauserCall as alloy_sol_types::SolCall>::abi_encoded_size(
1425 inner,
1426 )
1427 }
1428 Self::unpauser(inner) => {
1429 <unpauserCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1430 }
1431 }
1432 }
1433 #[inline]
1434 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1435 match self {
1436 Self::isPauser(inner) => {
1437 <isPauserCall as alloy_sol_types::SolCall>::abi_encode_raw(
1438 inner,
1439 out,
1440 )
1441 }
1442 Self::setIsPauser(inner) => {
1443 <setIsPauserCall as alloy_sol_types::SolCall>::abi_encode_raw(
1444 inner,
1445 out,
1446 )
1447 }
1448 Self::setUnpauser(inner) => {
1449 <setUnpauserCall as alloy_sol_types::SolCall>::abi_encode_raw(
1450 inner,
1451 out,
1452 )
1453 }
1454 Self::unpauser(inner) => {
1455 <unpauserCall as alloy_sol_types::SolCall>::abi_encode_raw(
1456 inner,
1457 out,
1458 )
1459 }
1460 }
1461 }
1462 }
1463 #[derive(serde::Serialize, serde::Deserialize)]
1465 #[derive(Debug, PartialEq, Eq, Hash)]
1466 pub enum PauserRegistryErrors {
1467 #[allow(missing_docs)]
1468 InputAddressZero(InputAddressZero),
1469 #[allow(missing_docs)]
1470 OnlyUnpauser(OnlyUnpauser),
1471 }
1472 #[automatically_derived]
1473 impl PauserRegistryErrors {
1474 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1481 [115u8, 99u8, 33u8, 118u8],
1482 [121u8, 72u8, 33u8, 255u8],
1483 ];
1484 }
1485 #[automatically_derived]
1486 impl alloy_sol_types::SolInterface for PauserRegistryErrors {
1487 const NAME: &'static str = "PauserRegistryErrors";
1488 const MIN_DATA_LENGTH: usize = 0usize;
1489 const COUNT: usize = 2usize;
1490 #[inline]
1491 fn selector(&self) -> [u8; 4] {
1492 match self {
1493 Self::InputAddressZero(_) => {
1494 <InputAddressZero as alloy_sol_types::SolError>::SELECTOR
1495 }
1496 Self::OnlyUnpauser(_) => {
1497 <OnlyUnpauser as alloy_sol_types::SolError>::SELECTOR
1498 }
1499 }
1500 }
1501 #[inline]
1502 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1503 Self::SELECTORS.get(i).copied()
1504 }
1505 #[inline]
1506 fn valid_selector(selector: [u8; 4]) -> bool {
1507 Self::SELECTORS.binary_search(&selector).is_ok()
1508 }
1509 #[inline]
1510 #[allow(non_snake_case)]
1511 fn abi_decode_raw(
1512 selector: [u8; 4],
1513 data: &[u8],
1514 ) -> alloy_sol_types::Result<Self> {
1515 static DECODE_SHIMS: &[fn(
1516 &[u8],
1517 ) -> alloy_sol_types::Result<PauserRegistryErrors>] = &[
1518 {
1519 fn InputAddressZero(
1520 data: &[u8],
1521 ) -> alloy_sol_types::Result<PauserRegistryErrors> {
1522 <InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw(
1523 data,
1524 )
1525 .map(PauserRegistryErrors::InputAddressZero)
1526 }
1527 InputAddressZero
1528 },
1529 {
1530 fn OnlyUnpauser(
1531 data: &[u8],
1532 ) -> alloy_sol_types::Result<PauserRegistryErrors> {
1533 <OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw(data)
1534 .map(PauserRegistryErrors::OnlyUnpauser)
1535 }
1536 OnlyUnpauser
1537 },
1538 ];
1539 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1540 return Err(
1541 alloy_sol_types::Error::unknown_selector(
1542 <Self as alloy_sol_types::SolInterface>::NAME,
1543 selector,
1544 ),
1545 );
1546 };
1547 DECODE_SHIMS[idx](data)
1548 }
1549 #[inline]
1550 #[allow(non_snake_case)]
1551 fn abi_decode_raw_validate(
1552 selector: [u8; 4],
1553 data: &[u8],
1554 ) -> alloy_sol_types::Result<Self> {
1555 static DECODE_VALIDATE_SHIMS: &[fn(
1556 &[u8],
1557 ) -> alloy_sol_types::Result<PauserRegistryErrors>] = &[
1558 {
1559 fn InputAddressZero(
1560 data: &[u8],
1561 ) -> alloy_sol_types::Result<PauserRegistryErrors> {
1562 <InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
1563 data,
1564 )
1565 .map(PauserRegistryErrors::InputAddressZero)
1566 }
1567 InputAddressZero
1568 },
1569 {
1570 fn OnlyUnpauser(
1571 data: &[u8],
1572 ) -> alloy_sol_types::Result<PauserRegistryErrors> {
1573 <OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw_validate(
1574 data,
1575 )
1576 .map(PauserRegistryErrors::OnlyUnpauser)
1577 }
1578 OnlyUnpauser
1579 },
1580 ];
1581 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1582 return Err(
1583 alloy_sol_types::Error::unknown_selector(
1584 <Self as alloy_sol_types::SolInterface>::NAME,
1585 selector,
1586 ),
1587 );
1588 };
1589 DECODE_VALIDATE_SHIMS[idx](data)
1590 }
1591 #[inline]
1592 fn abi_encoded_size(&self) -> usize {
1593 match self {
1594 Self::InputAddressZero(inner) => {
1595 <InputAddressZero as alloy_sol_types::SolError>::abi_encoded_size(
1596 inner,
1597 )
1598 }
1599 Self::OnlyUnpauser(inner) => {
1600 <OnlyUnpauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
1601 }
1602 }
1603 }
1604 #[inline]
1605 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1606 match self {
1607 Self::InputAddressZero(inner) => {
1608 <InputAddressZero as alloy_sol_types::SolError>::abi_encode_raw(
1609 inner,
1610 out,
1611 )
1612 }
1613 Self::OnlyUnpauser(inner) => {
1614 <OnlyUnpauser as alloy_sol_types::SolError>::abi_encode_raw(
1615 inner,
1616 out,
1617 )
1618 }
1619 }
1620 }
1621 }
1622 #[derive(serde::Serialize, serde::Deserialize)]
1624 #[derive(Debug, PartialEq, Eq, Hash)]
1625 pub enum PauserRegistryEvents {
1626 #[allow(missing_docs)]
1627 PauserStatusChanged(PauserStatusChanged),
1628 #[allow(missing_docs)]
1629 UnpauserChanged(UnpauserChanged),
1630 }
1631 #[automatically_derived]
1632 impl PauserRegistryEvents {
1633 pub const SELECTORS: &'static [[u8; 32usize]] = &[
1640 [
1641 6u8, 180u8, 22u8, 122u8, 37u8, 40u8, 136u8, 122u8, 30u8, 151u8, 163u8,
1642 102u8, 238u8, 254u8, 133u8, 73u8, 191u8, 191u8, 30u8, 163u8, 230u8,
1643 172u8, 129u8, 203u8, 37u8, 100u8, 169u8, 52u8, 210u8, 14u8, 136u8, 146u8,
1644 ],
1645 [
1646 101u8, 211u8, 161u8, 253u8, 76u8, 19u8, 240u8, 92u8, 186u8, 22u8, 79u8,
1647 128u8, 208u8, 60u8, 233u8, 15u8, 180u8, 181u8, 226u8, 25u8, 70u8, 191u8,
1648 195u8, 171u8, 125u8, 189u8, 67u8, 76u8, 45u8, 11u8, 145u8, 82u8,
1649 ],
1650 ];
1651 }
1652 #[automatically_derived]
1653 impl alloy_sol_types::SolEventInterface for PauserRegistryEvents {
1654 const NAME: &'static str = "PauserRegistryEvents";
1655 const COUNT: usize = 2usize;
1656 fn decode_raw_log(
1657 topics: &[alloy_sol_types::Word],
1658 data: &[u8],
1659 ) -> alloy_sol_types::Result<Self> {
1660 match topics.first().copied() {
1661 Some(
1662 <PauserStatusChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
1663 ) => {
1664 <PauserStatusChanged as alloy_sol_types::SolEvent>::decode_raw_log(
1665 topics,
1666 data,
1667 )
1668 .map(Self::PauserStatusChanged)
1669 }
1670 Some(<UnpauserChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
1671 <UnpauserChanged as alloy_sol_types::SolEvent>::decode_raw_log(
1672 topics,
1673 data,
1674 )
1675 .map(Self::UnpauserChanged)
1676 }
1677 _ => {
1678 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
1679 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
1680 log: alloy_sol_types::private::Box::new(
1681 alloy_sol_types::private::LogData::new_unchecked(
1682 topics.to_vec(),
1683 data.to_vec().into(),
1684 ),
1685 ),
1686 })
1687 }
1688 }
1689 }
1690 }
1691 #[automatically_derived]
1692 impl alloy_sol_types::private::IntoLogData for PauserRegistryEvents {
1693 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1694 match self {
1695 Self::PauserStatusChanged(inner) => {
1696 alloy_sol_types::private::IntoLogData::to_log_data(inner)
1697 }
1698 Self::UnpauserChanged(inner) => {
1699 alloy_sol_types::private::IntoLogData::to_log_data(inner)
1700 }
1701 }
1702 }
1703 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1704 match self {
1705 Self::PauserStatusChanged(inner) => {
1706 alloy_sol_types::private::IntoLogData::into_log_data(inner)
1707 }
1708 Self::UnpauserChanged(inner) => {
1709 alloy_sol_types::private::IntoLogData::into_log_data(inner)
1710 }
1711 }
1712 }
1713 }
1714 use alloy::contract as alloy_contract;
1715 #[inline]
1719 pub const fn new<
1720 P: alloy_contract::private::Provider<N>,
1721 N: alloy_contract::private::Network,
1722 >(
1723 address: alloy_sol_types::private::Address,
1724 provider: P,
1725 ) -> PauserRegistryInstance<P, N> {
1726 PauserRegistryInstance::<P, N>::new(address, provider)
1727 }
1728 #[inline]
1734 pub fn deploy<
1735 P: alloy_contract::private::Provider<N>,
1736 N: alloy_contract::private::Network,
1737 >(
1738 provider: P,
1739 _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1740 _unpauser: alloy::sol_types::private::Address,
1741 ) -> impl ::core::future::Future<
1742 Output = alloy_contract::Result<PauserRegistryInstance<P, N>>,
1743 > {
1744 PauserRegistryInstance::<P, N>::deploy(provider, _pausers, _unpauser)
1745 }
1746 #[inline]
1752 pub fn deploy_builder<
1753 P: alloy_contract::private::Provider<N>,
1754 N: alloy_contract::private::Network,
1755 >(
1756 provider: P,
1757 _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1758 _unpauser: alloy::sol_types::private::Address,
1759 ) -> alloy_contract::RawCallBuilder<P, N> {
1760 PauserRegistryInstance::<P, N>::deploy_builder(provider, _pausers, _unpauser)
1761 }
1762 #[derive(Clone)]
1774 pub struct PauserRegistryInstance<P, N = alloy_contract::private::Ethereum> {
1775 address: alloy_sol_types::private::Address,
1776 provider: P,
1777 _network: ::core::marker::PhantomData<N>,
1778 }
1779 #[automatically_derived]
1780 impl<P, N> ::core::fmt::Debug for PauserRegistryInstance<P, N> {
1781 #[inline]
1782 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1783 f.debug_tuple("PauserRegistryInstance").field(&self.address).finish()
1784 }
1785 }
1786 #[automatically_derived]
1788 impl<
1789 P: alloy_contract::private::Provider<N>,
1790 N: alloy_contract::private::Network,
1791 > PauserRegistryInstance<P, N> {
1792 #[inline]
1796 pub const fn new(
1797 address: alloy_sol_types::private::Address,
1798 provider: P,
1799 ) -> Self {
1800 Self {
1801 address,
1802 provider,
1803 _network: ::core::marker::PhantomData,
1804 }
1805 }
1806 #[inline]
1812 pub async fn deploy(
1813 provider: P,
1814 _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1815 _unpauser: alloy::sol_types::private::Address,
1816 ) -> alloy_contract::Result<PauserRegistryInstance<P, N>> {
1817 let call_builder = Self::deploy_builder(provider, _pausers, _unpauser);
1818 let contract_address = call_builder.deploy().await?;
1819 Ok(Self::new(contract_address, call_builder.provider))
1820 }
1821 #[inline]
1827 pub fn deploy_builder(
1828 provider: P,
1829 _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1830 _unpauser: alloy::sol_types::private::Address,
1831 ) -> alloy_contract::RawCallBuilder<P, N> {
1832 alloy_contract::RawCallBuilder::new_raw_deploy(
1833 provider,
1834 [
1835 &BYTECODE[..],
1836 &alloy_sol_types::SolConstructor::abi_encode(
1837 &constructorCall {
1838 _pausers,
1839 _unpauser,
1840 },
1841 )[..],
1842 ]
1843 .concat()
1844 .into(),
1845 )
1846 }
1847 #[inline]
1849 pub const fn address(&self) -> &alloy_sol_types::private::Address {
1850 &self.address
1851 }
1852 #[inline]
1854 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1855 self.address = address;
1856 }
1857 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1859 self.set_address(address);
1860 self
1861 }
1862 #[inline]
1864 pub const fn provider(&self) -> &P {
1865 &self.provider
1866 }
1867 }
1868 impl<P: ::core::clone::Clone, N> PauserRegistryInstance<&P, N> {
1869 #[inline]
1871 pub fn with_cloned_provider(self) -> PauserRegistryInstance<P, N> {
1872 PauserRegistryInstance {
1873 address: self.address,
1874 provider: ::core::clone::Clone::clone(&self.provider),
1875 _network: ::core::marker::PhantomData,
1876 }
1877 }
1878 }
1879 #[automatically_derived]
1881 impl<
1882 P: alloy_contract::private::Provider<N>,
1883 N: alloy_contract::private::Network,
1884 > PauserRegistryInstance<P, N> {
1885 pub fn call_builder<C: alloy_sol_types::SolCall>(
1890 &self,
1891 call: &C,
1892 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1893 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1894 }
1895 pub fn isPauser(
1897 &self,
1898 _0: alloy::sol_types::private::Address,
1899 ) -> alloy_contract::SolCallBuilder<&P, isPauserCall, N> {
1900 self.call_builder(&isPauserCall(_0))
1901 }
1902 pub fn setIsPauser(
1904 &self,
1905 newPauser: alloy::sol_types::private::Address,
1906 canPause: bool,
1907 ) -> alloy_contract::SolCallBuilder<&P, setIsPauserCall, N> {
1908 self.call_builder(
1909 &setIsPauserCall {
1910 newPauser,
1911 canPause,
1912 },
1913 )
1914 }
1915 pub fn setUnpauser(
1917 &self,
1918 newUnpauser: alloy::sol_types::private::Address,
1919 ) -> alloy_contract::SolCallBuilder<&P, setUnpauserCall, N> {
1920 self.call_builder(&setUnpauserCall { newUnpauser })
1921 }
1922 pub fn unpauser(&self) -> alloy_contract::SolCallBuilder<&P, unpauserCall, N> {
1924 self.call_builder(&unpauserCall)
1925 }
1926 }
1927 #[automatically_derived]
1929 impl<
1930 P: alloy_contract::private::Provider<N>,
1931 N: alloy_contract::private::Network,
1932 > PauserRegistryInstance<P, N> {
1933 pub fn event_filter<E: alloy_sol_types::SolEvent>(
1938 &self,
1939 ) -> alloy_contract::Event<&P, E, N> {
1940 alloy_contract::Event::new_sol(&self.provider, &self.address)
1941 }
1942 pub fn PauserStatusChanged_filter(
1944 &self,
1945 ) -> alloy_contract::Event<&P, PauserStatusChanged, N> {
1946 self.event_filter::<PauserStatusChanged>()
1947 }
1948 pub fn UnpauserChanged_filter(
1950 &self,
1951 ) -> alloy_contract::Event<&P, UnpauserChanged, N> {
1952 self.event_filter::<UnpauserChanged>()
1953 }
1954 }
1955}