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 \xAA\xC3\x8Bl\x01Q\x85h#\0\xBA\x06\xC2\x8C\x1E\x98\x9E\xC0\xAC\xD3\x18\x95\xAC\x1D\xDDB6\x1A\x85\x13\xEC}dsolcC\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 \xAA\xC3\x8Bl\x01Q\x85h#\0\xBA\x06\xC2\x8C\x1E\x98\x9E\xC0\xAC\xD3\x18\x95\xAC\x1D\xDDB6\x1A\x85\x13\xEC}dsolcC\0\x08\x1B\x003",
185 );
186 #[derive(Default, Debug, PartialEq, Eq, Hash)]
187 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
192 #[derive(Clone)]
193 pub struct InputAddressZero {}
194 #[allow(
195 non_camel_case_types,
196 non_snake_case,
197 clippy::pub_underscore_fields,
198 clippy::style
199 )]
200 const _: () = {
201 use alloy::sol_types as alloy_sol_types;
202 #[doc(hidden)]
203 type UnderlyingSolTuple<'a> = ();
204 #[doc(hidden)]
205 type UnderlyingRustTuple<'a> = ();
206 #[cfg(test)]
207 #[allow(dead_code, unreachable_patterns)]
208 fn _type_assertion(
209 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
210 ) {
211 match _t {
212 alloy_sol_types::private::AssertTypeEq::<
213 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
214 >(_) => {}
215 }
216 }
217 #[automatically_derived]
218 #[doc(hidden)]
219 impl ::core::convert::From<InputAddressZero> for UnderlyingRustTuple<'_> {
220 fn from(value: InputAddressZero) -> Self {
221 ()
222 }
223 }
224 #[automatically_derived]
225 #[doc(hidden)]
226 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputAddressZero {
227 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
228 Self {}
229 }
230 }
231 #[automatically_derived]
232 impl alloy_sol_types::SolError for InputAddressZero {
233 type Parameters<'a> = UnderlyingSolTuple<'a>;
234 type Token<'a> = <Self::Parameters<
235 'a,
236 > as alloy_sol_types::SolType>::Token<'a>;
237 const SIGNATURE: &'static str = "InputAddressZero()";
238 const SELECTOR: [u8; 4] = [115u8, 99u8, 33u8, 118u8];
239 #[inline]
240 fn new<'a>(
241 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
242 ) -> Self {
243 tuple.into()
244 }
245 #[inline]
246 fn tokenize(&self) -> Self::Token<'_> {
247 ()
248 }
249 }
250 };
251 #[derive(Default, Debug, PartialEq, Eq, Hash)]
252 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
257 #[derive(Clone)]
258 pub struct OnlyUnpauser {}
259 #[allow(
260 non_camel_case_types,
261 non_snake_case,
262 clippy::pub_underscore_fields,
263 clippy::style
264 )]
265 const _: () = {
266 use alloy::sol_types as alloy_sol_types;
267 #[doc(hidden)]
268 type UnderlyingSolTuple<'a> = ();
269 #[doc(hidden)]
270 type UnderlyingRustTuple<'a> = ();
271 #[cfg(test)]
272 #[allow(dead_code, unreachable_patterns)]
273 fn _type_assertion(
274 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
275 ) {
276 match _t {
277 alloy_sol_types::private::AssertTypeEq::<
278 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
279 >(_) => {}
280 }
281 }
282 #[automatically_derived]
283 #[doc(hidden)]
284 impl ::core::convert::From<OnlyUnpauser> for UnderlyingRustTuple<'_> {
285 fn from(value: OnlyUnpauser) -> Self {
286 ()
287 }
288 }
289 #[automatically_derived]
290 #[doc(hidden)]
291 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnpauser {
292 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
293 Self {}
294 }
295 }
296 #[automatically_derived]
297 impl alloy_sol_types::SolError for OnlyUnpauser {
298 type Parameters<'a> = UnderlyingSolTuple<'a>;
299 type Token<'a> = <Self::Parameters<
300 'a,
301 > as alloy_sol_types::SolType>::Token<'a>;
302 const SIGNATURE: &'static str = "OnlyUnpauser()";
303 const SELECTOR: [u8; 4] = [121u8, 72u8, 33u8, 255u8];
304 #[inline]
305 fn new<'a>(
306 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
307 ) -> Self {
308 tuple.into()
309 }
310 #[inline]
311 fn tokenize(&self) -> Self::Token<'_> {
312 ()
313 }
314 }
315 };
316 #[derive(Default, Debug, PartialEq, Eq, Hash)]
317 #[allow(
322 non_camel_case_types,
323 non_snake_case,
324 clippy::pub_underscore_fields,
325 clippy::style
326 )]
327 #[derive(Clone)]
328 pub struct PauserStatusChanged {
329 #[allow(missing_docs)]
330 pub pauser: alloy::sol_types::private::Address,
331 #[allow(missing_docs)]
332 pub canPause: bool,
333 }
334 #[allow(
335 non_camel_case_types,
336 non_snake_case,
337 clippy::pub_underscore_fields,
338 clippy::style
339 )]
340 const _: () = {
341 use alloy::sol_types as alloy_sol_types;
342 #[automatically_derived]
343 impl alloy_sol_types::SolEvent for PauserStatusChanged {
344 type DataTuple<'a> = (
345 alloy::sol_types::sol_data::Address,
346 alloy::sol_types::sol_data::Bool,
347 );
348 type DataToken<'a> = <Self::DataTuple<
349 'a,
350 > as alloy_sol_types::SolType>::Token<'a>;
351 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
352 const SIGNATURE: &'static str = "PauserStatusChanged(address,bool)";
353 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
354 101u8, 211u8, 161u8, 253u8, 76u8, 19u8, 240u8, 92u8, 186u8, 22u8, 79u8,
355 128u8, 208u8, 60u8, 233u8, 15u8, 180u8, 181u8, 226u8, 25u8, 70u8, 191u8,
356 195u8, 171u8, 125u8, 189u8, 67u8, 76u8, 45u8, 11u8, 145u8, 82u8,
357 ]);
358 const ANONYMOUS: bool = false;
359 #[allow(unused_variables)]
360 #[inline]
361 fn new(
362 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
363 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
364 ) -> Self {
365 Self {
366 pauser: data.0,
367 canPause: data.1,
368 }
369 }
370 #[inline]
371 fn check_signature(
372 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
373 ) -> alloy_sol_types::Result<()> {
374 if topics.0 != Self::SIGNATURE_HASH {
375 return Err(
376 alloy_sol_types::Error::invalid_event_signature_hash(
377 Self::SIGNATURE,
378 topics.0,
379 Self::SIGNATURE_HASH,
380 ),
381 );
382 }
383 Ok(())
384 }
385 #[inline]
386 fn tokenize_body(&self) -> Self::DataToken<'_> {
387 (
388 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
389 &self.pauser,
390 ),
391 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
392 &self.canPause,
393 ),
394 )
395 }
396 #[inline]
397 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
398 (Self::SIGNATURE_HASH.into(),)
399 }
400 #[inline]
401 fn encode_topics_raw(
402 &self,
403 out: &mut [alloy_sol_types::abi::token::WordToken],
404 ) -> alloy_sol_types::Result<()> {
405 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
406 return Err(alloy_sol_types::Error::Overrun);
407 }
408 out[0usize] = alloy_sol_types::abi::token::WordToken(
409 Self::SIGNATURE_HASH,
410 );
411 Ok(())
412 }
413 }
414 #[automatically_derived]
415 impl alloy_sol_types::private::IntoLogData for PauserStatusChanged {
416 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
417 From::from(self)
418 }
419 fn into_log_data(self) -> alloy_sol_types::private::LogData {
420 From::from(&self)
421 }
422 }
423 #[automatically_derived]
424 impl From<&PauserStatusChanged> for alloy_sol_types::private::LogData {
425 #[inline]
426 fn from(this: &PauserStatusChanged) -> alloy_sol_types::private::LogData {
427 alloy_sol_types::SolEvent::encode_log_data(this)
428 }
429 }
430 };
431 #[derive(Default, Debug, PartialEq, Eq, Hash)]
432 #[allow(
437 non_camel_case_types,
438 non_snake_case,
439 clippy::pub_underscore_fields,
440 clippy::style
441 )]
442 #[derive(Clone)]
443 pub struct UnpauserChanged {
444 #[allow(missing_docs)]
445 pub previousUnpauser: alloy::sol_types::private::Address,
446 #[allow(missing_docs)]
447 pub newUnpauser: alloy::sol_types::private::Address,
448 }
449 #[allow(
450 non_camel_case_types,
451 non_snake_case,
452 clippy::pub_underscore_fields,
453 clippy::style
454 )]
455 const _: () = {
456 use alloy::sol_types as alloy_sol_types;
457 #[automatically_derived]
458 impl alloy_sol_types::SolEvent for UnpauserChanged {
459 type DataTuple<'a> = (
460 alloy::sol_types::sol_data::Address,
461 alloy::sol_types::sol_data::Address,
462 );
463 type DataToken<'a> = <Self::DataTuple<
464 'a,
465 > as alloy_sol_types::SolType>::Token<'a>;
466 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
467 const SIGNATURE: &'static str = "UnpauserChanged(address,address)";
468 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
469 6u8, 180u8, 22u8, 122u8, 37u8, 40u8, 136u8, 122u8, 30u8, 151u8, 163u8,
470 102u8, 238u8, 254u8, 133u8, 73u8, 191u8, 191u8, 30u8, 163u8, 230u8,
471 172u8, 129u8, 203u8, 37u8, 100u8, 169u8, 52u8, 210u8, 14u8, 136u8, 146u8,
472 ]);
473 const ANONYMOUS: bool = false;
474 #[allow(unused_variables)]
475 #[inline]
476 fn new(
477 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
478 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
479 ) -> Self {
480 Self {
481 previousUnpauser: data.0,
482 newUnpauser: data.1,
483 }
484 }
485 #[inline]
486 fn check_signature(
487 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
488 ) -> alloy_sol_types::Result<()> {
489 if topics.0 != Self::SIGNATURE_HASH {
490 return Err(
491 alloy_sol_types::Error::invalid_event_signature_hash(
492 Self::SIGNATURE,
493 topics.0,
494 Self::SIGNATURE_HASH,
495 ),
496 );
497 }
498 Ok(())
499 }
500 #[inline]
501 fn tokenize_body(&self) -> Self::DataToken<'_> {
502 (
503 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
504 &self.previousUnpauser,
505 ),
506 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
507 &self.newUnpauser,
508 ),
509 )
510 }
511 #[inline]
512 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
513 (Self::SIGNATURE_HASH.into(),)
514 }
515 #[inline]
516 fn encode_topics_raw(
517 &self,
518 out: &mut [alloy_sol_types::abi::token::WordToken],
519 ) -> alloy_sol_types::Result<()> {
520 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
521 return Err(alloy_sol_types::Error::Overrun);
522 }
523 out[0usize] = alloy_sol_types::abi::token::WordToken(
524 Self::SIGNATURE_HASH,
525 );
526 Ok(())
527 }
528 }
529 #[automatically_derived]
530 impl alloy_sol_types::private::IntoLogData for UnpauserChanged {
531 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
532 From::from(self)
533 }
534 fn into_log_data(self) -> alloy_sol_types::private::LogData {
535 From::from(&self)
536 }
537 }
538 #[automatically_derived]
539 impl From<&UnpauserChanged> for alloy_sol_types::private::LogData {
540 #[inline]
541 fn from(this: &UnpauserChanged) -> alloy_sol_types::private::LogData {
542 alloy_sol_types::SolEvent::encode_log_data(this)
543 }
544 }
545 };
546 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
551 #[derive(Clone)]
552 pub struct constructorCall {
553 #[allow(missing_docs)]
554 pub _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
555 #[allow(missing_docs)]
556 pub _unpauser: alloy::sol_types::private::Address,
557 }
558 const _: () = {
559 use alloy::sol_types as alloy_sol_types;
560 {
561 #[doc(hidden)]
562 type UnderlyingSolTuple<'a> = (
563 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
564 alloy::sol_types::sol_data::Address,
565 );
566 #[doc(hidden)]
567 type UnderlyingRustTuple<'a> = (
568 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
569 alloy::sol_types::private::Address,
570 );
571 #[cfg(test)]
572 #[allow(dead_code, unreachable_patterns)]
573 fn _type_assertion(
574 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
575 ) {
576 match _t {
577 alloy_sol_types::private::AssertTypeEq::<
578 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
579 >(_) => {}
580 }
581 }
582 #[automatically_derived]
583 #[doc(hidden)]
584 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
585 fn from(value: constructorCall) -> Self {
586 (value._pausers, value._unpauser)
587 }
588 }
589 #[automatically_derived]
590 #[doc(hidden)]
591 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
592 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
593 Self {
594 _pausers: tuple.0,
595 _unpauser: tuple.1,
596 }
597 }
598 }
599 }
600 #[automatically_derived]
601 impl alloy_sol_types::SolConstructor for constructorCall {
602 type Parameters<'a> = (
603 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
604 alloy::sol_types::sol_data::Address,
605 );
606 type Token<'a> = <Self::Parameters<
607 'a,
608 > as alloy_sol_types::SolType>::Token<'a>;
609 #[inline]
610 fn new<'a>(
611 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
612 ) -> Self {
613 tuple.into()
614 }
615 #[inline]
616 fn tokenize(&self) -> Self::Token<'_> {
617 (
618 <alloy::sol_types::sol_data::Array<
619 alloy::sol_types::sol_data::Address,
620 > as alloy_sol_types::SolType>::tokenize(&self._pausers),
621 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
622 &self._unpauser,
623 ),
624 )
625 }
626 }
627 };
628 #[derive(Default, Debug, PartialEq, Eq, Hash)]
629 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
634 #[derive(Clone)]
635 pub struct isPauserCall {
636 #[allow(missing_docs)]
637 pub _0: alloy::sol_types::private::Address,
638 }
639 #[derive(Default, Debug, PartialEq, Eq, Hash)]
640 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
642 #[derive(Clone)]
643 pub struct isPauserReturn {
644 #[allow(missing_docs)]
645 pub _0: bool,
646 }
647 #[allow(
648 non_camel_case_types,
649 non_snake_case,
650 clippy::pub_underscore_fields,
651 clippy::style
652 )]
653 const _: () = {
654 use alloy::sol_types as alloy_sol_types;
655 {
656 #[doc(hidden)]
657 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
658 #[doc(hidden)]
659 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
660 #[cfg(test)]
661 #[allow(dead_code, unreachable_patterns)]
662 fn _type_assertion(
663 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
664 ) {
665 match _t {
666 alloy_sol_types::private::AssertTypeEq::<
667 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
668 >(_) => {}
669 }
670 }
671 #[automatically_derived]
672 #[doc(hidden)]
673 impl ::core::convert::From<isPauserCall> for UnderlyingRustTuple<'_> {
674 fn from(value: isPauserCall) -> Self {
675 (value._0,)
676 }
677 }
678 #[automatically_derived]
679 #[doc(hidden)]
680 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPauserCall {
681 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
682 Self { _0: tuple.0 }
683 }
684 }
685 }
686 {
687 #[doc(hidden)]
688 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
689 #[doc(hidden)]
690 type UnderlyingRustTuple<'a> = (bool,);
691 #[cfg(test)]
692 #[allow(dead_code, unreachable_patterns)]
693 fn _type_assertion(
694 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
695 ) {
696 match _t {
697 alloy_sol_types::private::AssertTypeEq::<
698 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
699 >(_) => {}
700 }
701 }
702 #[automatically_derived]
703 #[doc(hidden)]
704 impl ::core::convert::From<isPauserReturn> for UnderlyingRustTuple<'_> {
705 fn from(value: isPauserReturn) -> Self {
706 (value._0,)
707 }
708 }
709 #[automatically_derived]
710 #[doc(hidden)]
711 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPauserReturn {
712 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
713 Self { _0: tuple.0 }
714 }
715 }
716 }
717 #[automatically_derived]
718 impl alloy_sol_types::SolCall for isPauserCall {
719 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
720 type Token<'a> = <Self::Parameters<
721 'a,
722 > as alloy_sol_types::SolType>::Token<'a>;
723 type Return = isPauserReturn;
724 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
725 type ReturnToken<'a> = <Self::ReturnTuple<
726 'a,
727 > as alloy_sol_types::SolType>::Token<'a>;
728 const SIGNATURE: &'static str = "isPauser(address)";
729 const SELECTOR: [u8; 4] = [70u8, 251u8, 246u8, 142u8];
730 #[inline]
731 fn new<'a>(
732 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
733 ) -> Self {
734 tuple.into()
735 }
736 #[inline]
737 fn tokenize(&self) -> Self::Token<'_> {
738 (
739 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
740 &self._0,
741 ),
742 )
743 }
744 #[inline]
745 fn abi_decode_returns(
746 data: &[u8],
747 validate: bool,
748 ) -> alloy_sol_types::Result<Self::Return> {
749 <Self::ReturnTuple<
750 '_,
751 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
752 .map(Into::into)
753 }
754 }
755 };
756 #[derive(Default, Debug, PartialEq, Eq, Hash)]
757 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
762 #[derive(Clone)]
763 pub struct setIsPauserCall {
764 #[allow(missing_docs)]
765 pub newPauser: alloy::sol_types::private::Address,
766 #[allow(missing_docs)]
767 pub canPause: bool,
768 }
769 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
771 #[derive(Clone)]
772 pub struct setIsPauserReturn {}
773 #[allow(
774 non_camel_case_types,
775 non_snake_case,
776 clippy::pub_underscore_fields,
777 clippy::style
778 )]
779 const _: () = {
780 use alloy::sol_types as alloy_sol_types;
781 {
782 #[doc(hidden)]
783 type UnderlyingSolTuple<'a> = (
784 alloy::sol_types::sol_data::Address,
785 alloy::sol_types::sol_data::Bool,
786 );
787 #[doc(hidden)]
788 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, bool);
789 #[cfg(test)]
790 #[allow(dead_code, unreachable_patterns)]
791 fn _type_assertion(
792 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
793 ) {
794 match _t {
795 alloy_sol_types::private::AssertTypeEq::<
796 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
797 >(_) => {}
798 }
799 }
800 #[automatically_derived]
801 #[doc(hidden)]
802 impl ::core::convert::From<setIsPauserCall> for UnderlyingRustTuple<'_> {
803 fn from(value: setIsPauserCall) -> Self {
804 (value.newPauser, value.canPause)
805 }
806 }
807 #[automatically_derived]
808 #[doc(hidden)]
809 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setIsPauserCall {
810 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
811 Self {
812 newPauser: tuple.0,
813 canPause: tuple.1,
814 }
815 }
816 }
817 }
818 {
819 #[doc(hidden)]
820 type UnderlyingSolTuple<'a> = ();
821 #[doc(hidden)]
822 type UnderlyingRustTuple<'a> = ();
823 #[cfg(test)]
824 #[allow(dead_code, unreachable_patterns)]
825 fn _type_assertion(
826 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
827 ) {
828 match _t {
829 alloy_sol_types::private::AssertTypeEq::<
830 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
831 >(_) => {}
832 }
833 }
834 #[automatically_derived]
835 #[doc(hidden)]
836 impl ::core::convert::From<setIsPauserReturn> for UnderlyingRustTuple<'_> {
837 fn from(value: setIsPauserReturn) -> Self {
838 ()
839 }
840 }
841 #[automatically_derived]
842 #[doc(hidden)]
843 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setIsPauserReturn {
844 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
845 Self {}
846 }
847 }
848 }
849 #[automatically_derived]
850 impl alloy_sol_types::SolCall for setIsPauserCall {
851 type Parameters<'a> = (
852 alloy::sol_types::sol_data::Address,
853 alloy::sol_types::sol_data::Bool,
854 );
855 type Token<'a> = <Self::Parameters<
856 'a,
857 > as alloy_sol_types::SolType>::Token<'a>;
858 type Return = setIsPauserReturn;
859 type ReturnTuple<'a> = ();
860 type ReturnToken<'a> = <Self::ReturnTuple<
861 'a,
862 > as alloy_sol_types::SolType>::Token<'a>;
863 const SIGNATURE: &'static str = "setIsPauser(address,bool)";
864 const SELECTOR: [u8; 4] = [133u8, 104u8, 82u8, 6u8];
865 #[inline]
866 fn new<'a>(
867 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
868 ) -> Self {
869 tuple.into()
870 }
871 #[inline]
872 fn tokenize(&self) -> Self::Token<'_> {
873 (
874 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
875 &self.newPauser,
876 ),
877 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
878 &self.canPause,
879 ),
880 )
881 }
882 #[inline]
883 fn abi_decode_returns(
884 data: &[u8],
885 validate: bool,
886 ) -> alloy_sol_types::Result<Self::Return> {
887 <Self::ReturnTuple<
888 '_,
889 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
890 .map(Into::into)
891 }
892 }
893 };
894 #[derive(Default, Debug, PartialEq, Eq, Hash)]
895 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
900 #[derive(Clone)]
901 pub struct setUnpauserCall {
902 #[allow(missing_docs)]
903 pub newUnpauser: alloy::sol_types::private::Address,
904 }
905 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
907 #[derive(Clone)]
908 pub struct setUnpauserReturn {}
909 #[allow(
910 non_camel_case_types,
911 non_snake_case,
912 clippy::pub_underscore_fields,
913 clippy::style
914 )]
915 const _: () = {
916 use alloy::sol_types as alloy_sol_types;
917 {
918 #[doc(hidden)]
919 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
920 #[doc(hidden)]
921 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
922 #[cfg(test)]
923 #[allow(dead_code, unreachable_patterns)]
924 fn _type_assertion(
925 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
926 ) {
927 match _t {
928 alloy_sol_types::private::AssertTypeEq::<
929 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
930 >(_) => {}
931 }
932 }
933 #[automatically_derived]
934 #[doc(hidden)]
935 impl ::core::convert::From<setUnpauserCall> for UnderlyingRustTuple<'_> {
936 fn from(value: setUnpauserCall) -> Self {
937 (value.newUnpauser,)
938 }
939 }
940 #[automatically_derived]
941 #[doc(hidden)]
942 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setUnpauserCall {
943 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
944 Self { newUnpauser: tuple.0 }
945 }
946 }
947 }
948 {
949 #[doc(hidden)]
950 type UnderlyingSolTuple<'a> = ();
951 #[doc(hidden)]
952 type UnderlyingRustTuple<'a> = ();
953 #[cfg(test)]
954 #[allow(dead_code, unreachable_patterns)]
955 fn _type_assertion(
956 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
957 ) {
958 match _t {
959 alloy_sol_types::private::AssertTypeEq::<
960 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
961 >(_) => {}
962 }
963 }
964 #[automatically_derived]
965 #[doc(hidden)]
966 impl ::core::convert::From<setUnpauserReturn> for UnderlyingRustTuple<'_> {
967 fn from(value: setUnpauserReturn) -> Self {
968 ()
969 }
970 }
971 #[automatically_derived]
972 #[doc(hidden)]
973 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setUnpauserReturn {
974 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
975 Self {}
976 }
977 }
978 }
979 #[automatically_derived]
980 impl alloy_sol_types::SolCall for setUnpauserCall {
981 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
982 type Token<'a> = <Self::Parameters<
983 'a,
984 > as alloy_sol_types::SolType>::Token<'a>;
985 type Return = setUnpauserReturn;
986 type ReturnTuple<'a> = ();
987 type ReturnToken<'a> = <Self::ReturnTuple<
988 'a,
989 > as alloy_sol_types::SolType>::Token<'a>;
990 const SIGNATURE: &'static str = "setUnpauser(address)";
991 const SELECTOR: [u8; 4] = [206u8, 84u8, 132u8, 40u8];
992 #[inline]
993 fn new<'a>(
994 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
995 ) -> Self {
996 tuple.into()
997 }
998 #[inline]
999 fn tokenize(&self) -> Self::Token<'_> {
1000 (
1001 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1002 &self.newUnpauser,
1003 ),
1004 )
1005 }
1006 #[inline]
1007 fn abi_decode_returns(
1008 data: &[u8],
1009 validate: bool,
1010 ) -> alloy_sol_types::Result<Self::Return> {
1011 <Self::ReturnTuple<
1012 '_,
1013 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1014 .map(Into::into)
1015 }
1016 }
1017 };
1018 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1019 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1024 #[derive(Clone)]
1025 pub struct unpauserCall {}
1026 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1027 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1029 #[derive(Clone)]
1030 pub struct unpauserReturn {
1031 #[allow(missing_docs)]
1032 pub _0: alloy::sol_types::private::Address,
1033 }
1034 #[allow(
1035 non_camel_case_types,
1036 non_snake_case,
1037 clippy::pub_underscore_fields,
1038 clippy::style
1039 )]
1040 const _: () = {
1041 use alloy::sol_types as alloy_sol_types;
1042 {
1043 #[doc(hidden)]
1044 type UnderlyingSolTuple<'a> = ();
1045 #[doc(hidden)]
1046 type UnderlyingRustTuple<'a> = ();
1047 #[cfg(test)]
1048 #[allow(dead_code, unreachable_patterns)]
1049 fn _type_assertion(
1050 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1051 ) {
1052 match _t {
1053 alloy_sol_types::private::AssertTypeEq::<
1054 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1055 >(_) => {}
1056 }
1057 }
1058 #[automatically_derived]
1059 #[doc(hidden)]
1060 impl ::core::convert::From<unpauserCall> for UnderlyingRustTuple<'_> {
1061 fn from(value: unpauserCall) -> Self {
1062 ()
1063 }
1064 }
1065 #[automatically_derived]
1066 #[doc(hidden)]
1067 impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauserCall {
1068 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1069 Self {}
1070 }
1071 }
1072 }
1073 {
1074 #[doc(hidden)]
1075 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1076 #[doc(hidden)]
1077 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1078 #[cfg(test)]
1079 #[allow(dead_code, unreachable_patterns)]
1080 fn _type_assertion(
1081 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1082 ) {
1083 match _t {
1084 alloy_sol_types::private::AssertTypeEq::<
1085 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1086 >(_) => {}
1087 }
1088 }
1089 #[automatically_derived]
1090 #[doc(hidden)]
1091 impl ::core::convert::From<unpauserReturn> for UnderlyingRustTuple<'_> {
1092 fn from(value: unpauserReturn) -> Self {
1093 (value._0,)
1094 }
1095 }
1096 #[automatically_derived]
1097 #[doc(hidden)]
1098 impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauserReturn {
1099 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1100 Self { _0: tuple.0 }
1101 }
1102 }
1103 }
1104 #[automatically_derived]
1105 impl alloy_sol_types::SolCall for unpauserCall {
1106 type Parameters<'a> = ();
1107 type Token<'a> = <Self::Parameters<
1108 'a,
1109 > as alloy_sol_types::SolType>::Token<'a>;
1110 type Return = unpauserReturn;
1111 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1112 type ReturnToken<'a> = <Self::ReturnTuple<
1113 'a,
1114 > as alloy_sol_types::SolType>::Token<'a>;
1115 const SIGNATURE: &'static str = "unpauser()";
1116 const SELECTOR: [u8; 4] = [234u8, 182u8, 109u8, 122u8];
1117 #[inline]
1118 fn new<'a>(
1119 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1120 ) -> Self {
1121 tuple.into()
1122 }
1123 #[inline]
1124 fn tokenize(&self) -> Self::Token<'_> {
1125 ()
1126 }
1127 #[inline]
1128 fn abi_decode_returns(
1129 data: &[u8],
1130 validate: bool,
1131 ) -> alloy_sol_types::Result<Self::Return> {
1132 <Self::ReturnTuple<
1133 '_,
1134 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1135 .map(Into::into)
1136 }
1137 }
1138 };
1139 #[derive()]
1141 pub enum PauserRegistryCalls {
1142 #[allow(missing_docs)]
1143 isPauser(isPauserCall),
1144 #[allow(missing_docs)]
1145 setIsPauser(setIsPauserCall),
1146 #[allow(missing_docs)]
1147 setUnpauser(setUnpauserCall),
1148 #[allow(missing_docs)]
1149 unpauser(unpauserCall),
1150 }
1151 #[automatically_derived]
1152 impl PauserRegistryCalls {
1153 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1160 [70u8, 251u8, 246u8, 142u8],
1161 [133u8, 104u8, 82u8, 6u8],
1162 [206u8, 84u8, 132u8, 40u8],
1163 [234u8, 182u8, 109u8, 122u8],
1164 ];
1165 }
1166 #[automatically_derived]
1167 impl alloy_sol_types::SolInterface for PauserRegistryCalls {
1168 const NAME: &'static str = "PauserRegistryCalls";
1169 const MIN_DATA_LENGTH: usize = 0usize;
1170 const COUNT: usize = 4usize;
1171 #[inline]
1172 fn selector(&self) -> [u8; 4] {
1173 match self {
1174 Self::isPauser(_) => <isPauserCall as alloy_sol_types::SolCall>::SELECTOR,
1175 Self::setIsPauser(_) => {
1176 <setIsPauserCall as alloy_sol_types::SolCall>::SELECTOR
1177 }
1178 Self::setUnpauser(_) => {
1179 <setUnpauserCall as alloy_sol_types::SolCall>::SELECTOR
1180 }
1181 Self::unpauser(_) => <unpauserCall as alloy_sol_types::SolCall>::SELECTOR,
1182 }
1183 }
1184 #[inline]
1185 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1186 Self::SELECTORS.get(i).copied()
1187 }
1188 #[inline]
1189 fn valid_selector(selector: [u8; 4]) -> bool {
1190 Self::SELECTORS.binary_search(&selector).is_ok()
1191 }
1192 #[inline]
1193 #[allow(non_snake_case)]
1194 fn abi_decode_raw(
1195 selector: [u8; 4],
1196 data: &[u8],
1197 validate: bool,
1198 ) -> alloy_sol_types::Result<Self> {
1199 static DECODE_SHIMS: &[fn(
1200 &[u8],
1201 bool,
1202 ) -> alloy_sol_types::Result<PauserRegistryCalls>] = &[
1203 {
1204 fn isPauser(
1205 data: &[u8],
1206 validate: bool,
1207 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1208 <isPauserCall as alloy_sol_types::SolCall>::abi_decode_raw(
1209 data,
1210 validate,
1211 )
1212 .map(PauserRegistryCalls::isPauser)
1213 }
1214 isPauser
1215 },
1216 {
1217 fn setIsPauser(
1218 data: &[u8],
1219 validate: bool,
1220 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1221 <setIsPauserCall as alloy_sol_types::SolCall>::abi_decode_raw(
1222 data,
1223 validate,
1224 )
1225 .map(PauserRegistryCalls::setIsPauser)
1226 }
1227 setIsPauser
1228 },
1229 {
1230 fn setUnpauser(
1231 data: &[u8],
1232 validate: bool,
1233 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1234 <setUnpauserCall as alloy_sol_types::SolCall>::abi_decode_raw(
1235 data,
1236 validate,
1237 )
1238 .map(PauserRegistryCalls::setUnpauser)
1239 }
1240 setUnpauser
1241 },
1242 {
1243 fn unpauser(
1244 data: &[u8],
1245 validate: bool,
1246 ) -> alloy_sol_types::Result<PauserRegistryCalls> {
1247 <unpauserCall as alloy_sol_types::SolCall>::abi_decode_raw(
1248 data,
1249 validate,
1250 )
1251 .map(PauserRegistryCalls::unpauser)
1252 }
1253 unpauser
1254 },
1255 ];
1256 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1257 return Err(
1258 alloy_sol_types::Error::unknown_selector(
1259 <Self as alloy_sol_types::SolInterface>::NAME,
1260 selector,
1261 ),
1262 );
1263 };
1264 DECODE_SHIMS[idx](data, validate)
1265 }
1266 #[inline]
1267 fn abi_encoded_size(&self) -> usize {
1268 match self {
1269 Self::isPauser(inner) => {
1270 <isPauserCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1271 }
1272 Self::setIsPauser(inner) => {
1273 <setIsPauserCall as alloy_sol_types::SolCall>::abi_encoded_size(
1274 inner,
1275 )
1276 }
1277 Self::setUnpauser(inner) => {
1278 <setUnpauserCall as alloy_sol_types::SolCall>::abi_encoded_size(
1279 inner,
1280 )
1281 }
1282 Self::unpauser(inner) => {
1283 <unpauserCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1284 }
1285 }
1286 }
1287 #[inline]
1288 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1289 match self {
1290 Self::isPauser(inner) => {
1291 <isPauserCall as alloy_sol_types::SolCall>::abi_encode_raw(
1292 inner,
1293 out,
1294 )
1295 }
1296 Self::setIsPauser(inner) => {
1297 <setIsPauserCall as alloy_sol_types::SolCall>::abi_encode_raw(
1298 inner,
1299 out,
1300 )
1301 }
1302 Self::setUnpauser(inner) => {
1303 <setUnpauserCall as alloy_sol_types::SolCall>::abi_encode_raw(
1304 inner,
1305 out,
1306 )
1307 }
1308 Self::unpauser(inner) => {
1309 <unpauserCall as alloy_sol_types::SolCall>::abi_encode_raw(
1310 inner,
1311 out,
1312 )
1313 }
1314 }
1315 }
1316 }
1317 #[derive(Debug, PartialEq, Eq, Hash)]
1319 pub enum PauserRegistryErrors {
1320 #[allow(missing_docs)]
1321 InputAddressZero(InputAddressZero),
1322 #[allow(missing_docs)]
1323 OnlyUnpauser(OnlyUnpauser),
1324 }
1325 #[automatically_derived]
1326 impl PauserRegistryErrors {
1327 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1334 [115u8, 99u8, 33u8, 118u8],
1335 [121u8, 72u8, 33u8, 255u8],
1336 ];
1337 }
1338 #[automatically_derived]
1339 impl alloy_sol_types::SolInterface for PauserRegistryErrors {
1340 const NAME: &'static str = "PauserRegistryErrors";
1341 const MIN_DATA_LENGTH: usize = 0usize;
1342 const COUNT: usize = 2usize;
1343 #[inline]
1344 fn selector(&self) -> [u8; 4] {
1345 match self {
1346 Self::InputAddressZero(_) => {
1347 <InputAddressZero as alloy_sol_types::SolError>::SELECTOR
1348 }
1349 Self::OnlyUnpauser(_) => {
1350 <OnlyUnpauser as alloy_sol_types::SolError>::SELECTOR
1351 }
1352 }
1353 }
1354 #[inline]
1355 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1356 Self::SELECTORS.get(i).copied()
1357 }
1358 #[inline]
1359 fn valid_selector(selector: [u8; 4]) -> bool {
1360 Self::SELECTORS.binary_search(&selector).is_ok()
1361 }
1362 #[inline]
1363 #[allow(non_snake_case)]
1364 fn abi_decode_raw(
1365 selector: [u8; 4],
1366 data: &[u8],
1367 validate: bool,
1368 ) -> alloy_sol_types::Result<Self> {
1369 static DECODE_SHIMS: &[fn(
1370 &[u8],
1371 bool,
1372 ) -> alloy_sol_types::Result<PauserRegistryErrors>] = &[
1373 {
1374 fn InputAddressZero(
1375 data: &[u8],
1376 validate: bool,
1377 ) -> alloy_sol_types::Result<PauserRegistryErrors> {
1378 <InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw(
1379 data,
1380 validate,
1381 )
1382 .map(PauserRegistryErrors::InputAddressZero)
1383 }
1384 InputAddressZero
1385 },
1386 {
1387 fn OnlyUnpauser(
1388 data: &[u8],
1389 validate: bool,
1390 ) -> alloy_sol_types::Result<PauserRegistryErrors> {
1391 <OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw(
1392 data,
1393 validate,
1394 )
1395 .map(PauserRegistryErrors::OnlyUnpauser)
1396 }
1397 OnlyUnpauser
1398 },
1399 ];
1400 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1401 return Err(
1402 alloy_sol_types::Error::unknown_selector(
1403 <Self as alloy_sol_types::SolInterface>::NAME,
1404 selector,
1405 ),
1406 );
1407 };
1408 DECODE_SHIMS[idx](data, validate)
1409 }
1410 #[inline]
1411 fn abi_encoded_size(&self) -> usize {
1412 match self {
1413 Self::InputAddressZero(inner) => {
1414 <InputAddressZero as alloy_sol_types::SolError>::abi_encoded_size(
1415 inner,
1416 )
1417 }
1418 Self::OnlyUnpauser(inner) => {
1419 <OnlyUnpauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
1420 }
1421 }
1422 }
1423 #[inline]
1424 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1425 match self {
1426 Self::InputAddressZero(inner) => {
1427 <InputAddressZero as alloy_sol_types::SolError>::abi_encode_raw(
1428 inner,
1429 out,
1430 )
1431 }
1432 Self::OnlyUnpauser(inner) => {
1433 <OnlyUnpauser as alloy_sol_types::SolError>::abi_encode_raw(
1434 inner,
1435 out,
1436 )
1437 }
1438 }
1439 }
1440 }
1441 #[derive(Debug, PartialEq, Eq, Hash)]
1443 pub enum PauserRegistryEvents {
1444 #[allow(missing_docs)]
1445 PauserStatusChanged(PauserStatusChanged),
1446 #[allow(missing_docs)]
1447 UnpauserChanged(UnpauserChanged),
1448 }
1449 #[automatically_derived]
1450 impl PauserRegistryEvents {
1451 pub const SELECTORS: &'static [[u8; 32usize]] = &[
1458 [
1459 6u8, 180u8, 22u8, 122u8, 37u8, 40u8, 136u8, 122u8, 30u8, 151u8, 163u8,
1460 102u8, 238u8, 254u8, 133u8, 73u8, 191u8, 191u8, 30u8, 163u8, 230u8,
1461 172u8, 129u8, 203u8, 37u8, 100u8, 169u8, 52u8, 210u8, 14u8, 136u8, 146u8,
1462 ],
1463 [
1464 101u8, 211u8, 161u8, 253u8, 76u8, 19u8, 240u8, 92u8, 186u8, 22u8, 79u8,
1465 128u8, 208u8, 60u8, 233u8, 15u8, 180u8, 181u8, 226u8, 25u8, 70u8, 191u8,
1466 195u8, 171u8, 125u8, 189u8, 67u8, 76u8, 45u8, 11u8, 145u8, 82u8,
1467 ],
1468 ];
1469 }
1470 #[automatically_derived]
1471 impl alloy_sol_types::SolEventInterface for PauserRegistryEvents {
1472 const NAME: &'static str = "PauserRegistryEvents";
1473 const COUNT: usize = 2usize;
1474 fn decode_raw_log(
1475 topics: &[alloy_sol_types::Word],
1476 data: &[u8],
1477 validate: bool,
1478 ) -> alloy_sol_types::Result<Self> {
1479 match topics.first().copied() {
1480 Some(
1481 <PauserStatusChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
1482 ) => {
1483 <PauserStatusChanged as alloy_sol_types::SolEvent>::decode_raw_log(
1484 topics,
1485 data,
1486 validate,
1487 )
1488 .map(Self::PauserStatusChanged)
1489 }
1490 Some(<UnpauserChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
1491 <UnpauserChanged as alloy_sol_types::SolEvent>::decode_raw_log(
1492 topics,
1493 data,
1494 validate,
1495 )
1496 .map(Self::UnpauserChanged)
1497 }
1498 _ => {
1499 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
1500 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
1501 log: alloy_sol_types::private::Box::new(
1502 alloy_sol_types::private::LogData::new_unchecked(
1503 topics.to_vec(),
1504 data.to_vec().into(),
1505 ),
1506 ),
1507 })
1508 }
1509 }
1510 }
1511 }
1512 #[automatically_derived]
1513 impl alloy_sol_types::private::IntoLogData for PauserRegistryEvents {
1514 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1515 match self {
1516 Self::PauserStatusChanged(inner) => {
1517 alloy_sol_types::private::IntoLogData::to_log_data(inner)
1518 }
1519 Self::UnpauserChanged(inner) => {
1520 alloy_sol_types::private::IntoLogData::to_log_data(inner)
1521 }
1522 }
1523 }
1524 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1525 match self {
1526 Self::PauserStatusChanged(inner) => {
1527 alloy_sol_types::private::IntoLogData::into_log_data(inner)
1528 }
1529 Self::UnpauserChanged(inner) => {
1530 alloy_sol_types::private::IntoLogData::into_log_data(inner)
1531 }
1532 }
1533 }
1534 }
1535 use alloy::contract as alloy_contract;
1536 #[inline]
1540 pub const fn new<
1541 T: alloy_contract::private::Transport + ::core::clone::Clone,
1542 P: alloy_contract::private::Provider<T, N>,
1543 N: alloy_contract::private::Network,
1544 >(
1545 address: alloy_sol_types::private::Address,
1546 provider: P,
1547 ) -> PauserRegistryInstance<T, P, N> {
1548 PauserRegistryInstance::<T, P, N>::new(address, provider)
1549 }
1550 #[inline]
1556 pub fn deploy<
1557 T: alloy_contract::private::Transport + ::core::clone::Clone,
1558 P: alloy_contract::private::Provider<T, N>,
1559 N: alloy_contract::private::Network,
1560 >(
1561 provider: P,
1562 _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1563 _unpauser: alloy::sol_types::private::Address,
1564 ) -> impl ::core::future::Future<
1565 Output = alloy_contract::Result<PauserRegistryInstance<T, P, N>>,
1566 > {
1567 PauserRegistryInstance::<T, P, N>::deploy(provider, _pausers, _unpauser)
1568 }
1569 #[inline]
1575 pub fn deploy_builder<
1576 T: alloy_contract::private::Transport + ::core::clone::Clone,
1577 P: alloy_contract::private::Provider<T, N>,
1578 N: alloy_contract::private::Network,
1579 >(
1580 provider: P,
1581 _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1582 _unpauser: alloy::sol_types::private::Address,
1583 ) -> alloy_contract::RawCallBuilder<T, P, N> {
1584 PauserRegistryInstance::<T, P, N>::deploy_builder(provider, _pausers, _unpauser)
1585 }
1586 #[derive(Clone)]
1598 pub struct PauserRegistryInstance<T, P, N = alloy_contract::private::Ethereum> {
1599 address: alloy_sol_types::private::Address,
1600 provider: P,
1601 _network_transport: ::core::marker::PhantomData<(N, T)>,
1602 }
1603 #[automatically_derived]
1604 impl<T, P, N> ::core::fmt::Debug for PauserRegistryInstance<T, P, N> {
1605 #[inline]
1606 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1607 f.debug_tuple("PauserRegistryInstance").field(&self.address).finish()
1608 }
1609 }
1610 #[automatically_derived]
1612 impl<
1613 T: alloy_contract::private::Transport + ::core::clone::Clone,
1614 P: alloy_contract::private::Provider<T, N>,
1615 N: alloy_contract::private::Network,
1616 > PauserRegistryInstance<T, P, N> {
1617 #[inline]
1621 pub const fn new(
1622 address: alloy_sol_types::private::Address,
1623 provider: P,
1624 ) -> Self {
1625 Self {
1626 address,
1627 provider,
1628 _network_transport: ::core::marker::PhantomData,
1629 }
1630 }
1631 #[inline]
1637 pub async fn deploy(
1638 provider: P,
1639 _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1640 _unpauser: alloy::sol_types::private::Address,
1641 ) -> alloy_contract::Result<PauserRegistryInstance<T, P, N>> {
1642 let call_builder = Self::deploy_builder(provider, _pausers, _unpauser);
1643 let contract_address = call_builder.deploy().await?;
1644 Ok(Self::new(contract_address, call_builder.provider))
1645 }
1646 #[inline]
1652 pub fn deploy_builder(
1653 provider: P,
1654 _pausers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1655 _unpauser: alloy::sol_types::private::Address,
1656 ) -> alloy_contract::RawCallBuilder<T, P, N> {
1657 alloy_contract::RawCallBuilder::new_raw_deploy(
1658 provider,
1659 [
1660 &BYTECODE[..],
1661 &alloy_sol_types::SolConstructor::abi_encode(
1662 &constructorCall {
1663 _pausers,
1664 _unpauser,
1665 },
1666 )[..],
1667 ]
1668 .concat()
1669 .into(),
1670 )
1671 }
1672 #[inline]
1674 pub const fn address(&self) -> &alloy_sol_types::private::Address {
1675 &self.address
1676 }
1677 #[inline]
1679 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1680 self.address = address;
1681 }
1682 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1684 self.set_address(address);
1685 self
1686 }
1687 #[inline]
1689 pub const fn provider(&self) -> &P {
1690 &self.provider
1691 }
1692 }
1693 impl<T, P: ::core::clone::Clone, N> PauserRegistryInstance<T, &P, N> {
1694 #[inline]
1696 pub fn with_cloned_provider(self) -> PauserRegistryInstance<T, P, N> {
1697 PauserRegistryInstance {
1698 address: self.address,
1699 provider: ::core::clone::Clone::clone(&self.provider),
1700 _network_transport: ::core::marker::PhantomData,
1701 }
1702 }
1703 }
1704 #[automatically_derived]
1706 impl<
1707 T: alloy_contract::private::Transport + ::core::clone::Clone,
1708 P: alloy_contract::private::Provider<T, N>,
1709 N: alloy_contract::private::Network,
1710 > PauserRegistryInstance<T, P, N> {
1711 pub fn call_builder<C: alloy_sol_types::SolCall>(
1716 &self,
1717 call: &C,
1718 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
1719 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1720 }
1721 pub fn isPauser(
1723 &self,
1724 _0: alloy::sol_types::private::Address,
1725 ) -> alloy_contract::SolCallBuilder<T, &P, isPauserCall, N> {
1726 self.call_builder(&isPauserCall { _0 })
1727 }
1728 pub fn setIsPauser(
1730 &self,
1731 newPauser: alloy::sol_types::private::Address,
1732 canPause: bool,
1733 ) -> alloy_contract::SolCallBuilder<T, &P, setIsPauserCall, N> {
1734 self.call_builder(
1735 &setIsPauserCall {
1736 newPauser,
1737 canPause,
1738 },
1739 )
1740 }
1741 pub fn setUnpauser(
1743 &self,
1744 newUnpauser: alloy::sol_types::private::Address,
1745 ) -> alloy_contract::SolCallBuilder<T, &P, setUnpauserCall, N> {
1746 self.call_builder(&setUnpauserCall { newUnpauser })
1747 }
1748 pub fn unpauser(
1750 &self,
1751 ) -> alloy_contract::SolCallBuilder<T, &P, unpauserCall, N> {
1752 self.call_builder(&unpauserCall {})
1753 }
1754 }
1755 #[automatically_derived]
1757 impl<
1758 T: alloy_contract::private::Transport + ::core::clone::Clone,
1759 P: alloy_contract::private::Provider<T, N>,
1760 N: alloy_contract::private::Network,
1761 > PauserRegistryInstance<T, P, N> {
1762 pub fn event_filter<E: alloy_sol_types::SolEvent>(
1767 &self,
1768 ) -> alloy_contract::Event<T, &P, E, N> {
1769 alloy_contract::Event::new_sol(&self.provider, &self.address)
1770 }
1771 pub fn PauserStatusChanged_filter(
1773 &self,
1774 ) -> alloy_contract::Event<T, &P, PauserStatusChanged, N> {
1775 self.event_filter::<PauserStatusChanged>()
1776 }
1777 pub fn UnpauserChanged_filter(
1779 &self,
1780 ) -> alloy_contract::Event<T, &P, UnpauserChanged, N> {
1781 self.event_filter::<UnpauserChanged>()
1782 }
1783 }
1784}