1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use ISlashingRegistryCoordinator::*;
3
4#[allow(
13 non_camel_case_types,
14 non_snake_case,
15 clippy::pub_underscore_fields,
16 clippy::style,
17 clippy::empty_structs_with_brackets
18)]
19pub mod BN254 {
20 use super::*;
21 use alloy::sol_types as alloy_sol_types;
22 #[derive(Default, Debug, PartialEq, Eq, Hash)]
23 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
27 #[derive(Clone)]
28 pub struct G1Point {
29 #[allow(missing_docs)]
30 pub X: alloy::sol_types::private::primitives::aliases::U256,
31 #[allow(missing_docs)]
32 pub Y: alloy::sol_types::private::primitives::aliases::U256,
33 }
34 #[allow(
35 non_camel_case_types,
36 non_snake_case,
37 clippy::pub_underscore_fields,
38 clippy::style
39 )]
40 const _: () = {
41 use alloy::sol_types as alloy_sol_types;
42 #[doc(hidden)]
43 type UnderlyingSolTuple<'a> = (
44 alloy::sol_types::sol_data::Uint<256>,
45 alloy::sol_types::sol_data::Uint<256>,
46 );
47 #[doc(hidden)]
48 type UnderlyingRustTuple<'a> = (
49 alloy::sol_types::private::primitives::aliases::U256,
50 alloy::sol_types::private::primitives::aliases::U256,
51 );
52 #[cfg(test)]
53 #[allow(dead_code, unreachable_patterns)]
54 fn _type_assertion(
55 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
56 ) {
57 match _t {
58 alloy_sol_types::private::AssertTypeEq::<
59 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
60 >(_) => {}
61 }
62 }
63 #[automatically_derived]
64 #[doc(hidden)]
65 impl ::core::convert::From<G1Point> for UnderlyingRustTuple<'_> {
66 fn from(value: G1Point) -> Self {
67 (value.X, value.Y)
68 }
69 }
70 #[automatically_derived]
71 #[doc(hidden)]
72 impl ::core::convert::From<UnderlyingRustTuple<'_>> for G1Point {
73 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
74 Self { X: tuple.0, Y: tuple.1 }
75 }
76 }
77 #[automatically_derived]
78 impl alloy_sol_types::SolValue for G1Point {
79 type SolType = Self;
80 }
81 #[automatically_derived]
82 impl alloy_sol_types::private::SolTypeValue<Self> for G1Point {
83 #[inline]
84 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
85 (
86 <alloy::sol_types::sol_data::Uint<
87 256,
88 > as alloy_sol_types::SolType>::tokenize(&self.X),
89 <alloy::sol_types::sol_data::Uint<
90 256,
91 > as alloy_sol_types::SolType>::tokenize(&self.Y),
92 )
93 }
94 #[inline]
95 fn stv_abi_encoded_size(&self) -> usize {
96 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
97 return size;
98 }
99 let tuple = <UnderlyingRustTuple<
100 '_,
101 > as ::core::convert::From<Self>>::from(self.clone());
102 <UnderlyingSolTuple<
103 '_,
104 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
105 }
106 #[inline]
107 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
108 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
109 }
110 #[inline]
111 fn stv_abi_encode_packed_to(
112 &self,
113 out: &mut alloy_sol_types::private::Vec<u8>,
114 ) {
115 let tuple = <UnderlyingRustTuple<
116 '_,
117 > as ::core::convert::From<Self>>::from(self.clone());
118 <UnderlyingSolTuple<
119 '_,
120 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
121 }
122 #[inline]
123 fn stv_abi_packed_encoded_size(&self) -> usize {
124 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
125 return size;
126 }
127 let tuple = <UnderlyingRustTuple<
128 '_,
129 > as ::core::convert::From<Self>>::from(self.clone());
130 <UnderlyingSolTuple<
131 '_,
132 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
133 }
134 }
135 #[automatically_derived]
136 impl alloy_sol_types::SolType for G1Point {
137 type RustType = Self;
138 type Token<'a> = <UnderlyingSolTuple<
139 'a,
140 > as alloy_sol_types::SolType>::Token<'a>;
141 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
142 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
143 '_,
144 > as alloy_sol_types::SolType>::ENCODED_SIZE;
145 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
146 '_,
147 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
148 #[inline]
149 fn valid_token(token: &Self::Token<'_>) -> bool {
150 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
151 }
152 #[inline]
153 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
154 let tuple = <UnderlyingSolTuple<
155 '_,
156 > as alloy_sol_types::SolType>::detokenize(token);
157 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
158 }
159 }
160 #[automatically_derived]
161 impl alloy_sol_types::SolStruct for G1Point {
162 const NAME: &'static str = "G1Point";
163 #[inline]
164 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
165 alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 X,uint256 Y)")
166 }
167 #[inline]
168 fn eip712_components() -> alloy_sol_types::private::Vec<
169 alloy_sol_types::private::Cow<'static, str>,
170 > {
171 alloy_sol_types::private::Vec::new()
172 }
173 #[inline]
174 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
175 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
176 }
177 #[inline]
178 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
179 [
180 <alloy::sol_types::sol_data::Uint<
181 256,
182 > as alloy_sol_types::SolType>::eip712_data_word(&self.X)
183 .0,
184 <alloy::sol_types::sol_data::Uint<
185 256,
186 > as alloy_sol_types::SolType>::eip712_data_word(&self.Y)
187 .0,
188 ]
189 .concat()
190 }
191 }
192 #[automatically_derived]
193 impl alloy_sol_types::EventTopic for G1Point {
194 #[inline]
195 fn topic_preimage_length(rust: &Self::RustType) -> usize {
196 0usize
197 + <alloy::sol_types::sol_data::Uint<
198 256,
199 > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.X)
200 + <alloy::sol_types::sol_data::Uint<
201 256,
202 > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.Y)
203 }
204 #[inline]
205 fn encode_topic_preimage(
206 rust: &Self::RustType,
207 out: &mut alloy_sol_types::private::Vec<u8>,
208 ) {
209 out.reserve(
210 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
211 );
212 <alloy::sol_types::sol_data::Uint<
213 256,
214 > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.X, out);
215 <alloy::sol_types::sol_data::Uint<
216 256,
217 > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.Y, out);
218 }
219 #[inline]
220 fn encode_topic(
221 rust: &Self::RustType,
222 ) -> alloy_sol_types::abi::token::WordToken {
223 let mut out = alloy_sol_types::private::Vec::new();
224 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
225 rust,
226 &mut out,
227 );
228 alloy_sol_types::abi::token::WordToken(
229 alloy_sol_types::private::keccak256(out),
230 )
231 }
232 }
233 };
234 use alloy::contract as alloy_contract;
235 #[inline]
239 pub const fn new<
240 T: alloy_contract::private::Transport + ::core::clone::Clone,
241 P: alloy_contract::private::Provider<T, N>,
242 N: alloy_contract::private::Network,
243 >(
244 address: alloy_sol_types::private::Address,
245 provider: P,
246 ) -> BN254Instance<T, P, N> {
247 BN254Instance::<T, P, N>::new(address, provider)
248 }
249 #[derive(Clone)]
261 pub struct BN254Instance<T, P, N = alloy_contract::private::Ethereum> {
262 address: alloy_sol_types::private::Address,
263 provider: P,
264 _network_transport: ::core::marker::PhantomData<(N, T)>,
265 }
266 #[automatically_derived]
267 impl<T, P, N> ::core::fmt::Debug for BN254Instance<T, P, N> {
268 #[inline]
269 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
270 f.debug_tuple("BN254Instance").field(&self.address).finish()
271 }
272 }
273 #[automatically_derived]
275 impl<
276 T: alloy_contract::private::Transport + ::core::clone::Clone,
277 P: alloy_contract::private::Provider<T, N>,
278 N: alloy_contract::private::Network,
279 > BN254Instance<T, P, N> {
280 #[inline]
284 pub const fn new(
285 address: alloy_sol_types::private::Address,
286 provider: P,
287 ) -> Self {
288 Self {
289 address,
290 provider,
291 _network_transport: ::core::marker::PhantomData,
292 }
293 }
294 #[inline]
296 pub const fn address(&self) -> &alloy_sol_types::private::Address {
297 &self.address
298 }
299 #[inline]
301 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
302 self.address = address;
303 }
304 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
306 self.set_address(address);
307 self
308 }
309 #[inline]
311 pub const fn provider(&self) -> &P {
312 &self.provider
313 }
314 }
315 impl<T, P: ::core::clone::Clone, N> BN254Instance<T, &P, N> {
316 #[inline]
318 pub fn with_cloned_provider(self) -> BN254Instance<T, P, N> {
319 BN254Instance {
320 address: self.address,
321 provider: ::core::clone::Clone::clone(&self.provider),
322 _network_transport: ::core::marker::PhantomData,
323 }
324 }
325 }
326 #[automatically_derived]
328 impl<
329 T: alloy_contract::private::Transport + ::core::clone::Clone,
330 P: alloy_contract::private::Provider<T, N>,
331 N: alloy_contract::private::Network,
332 > BN254Instance<T, P, N> {
333 pub fn call_builder<C: alloy_sol_types::SolCall>(
338 &self,
339 call: &C,
340 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
341 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
342 }
343 }
344 #[automatically_derived]
346 impl<
347 T: alloy_contract::private::Transport + ::core::clone::Clone,
348 P: alloy_contract::private::Provider<T, N>,
349 N: alloy_contract::private::Network,
350 > BN254Instance<T, P, N> {
351 pub fn event_filter<E: alloy_sol_types::SolEvent>(
356 &self,
357 ) -> alloy_contract::Event<T, &P, E, N> {
358 alloy_contract::Event::new_sol(&self.provider, &self.address)
359 }
360 }
361}
362#[allow(
375 non_camel_case_types,
376 non_snake_case,
377 clippy::pub_underscore_fields,
378 clippy::style,
379 clippy::empty_structs_with_brackets
380)]
381pub mod ISlashingRegistryCoordinatorTypes {
382 use super::*;
383 use alloy::sol_types as alloy_sol_types;
384 #[derive(Default, Debug, PartialEq, Eq, Hash)]
385 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
386 #[derive(Clone)]
387 pub struct OperatorStatus(u8);
388 const _: () = {
389 use alloy::sol_types as alloy_sol_types;
390 #[automatically_derived]
391 impl alloy_sol_types::private::SolTypeValue<OperatorStatus> for u8 {
392 #[inline]
393 fn stv_to_tokens(
394 &self,
395 ) -> <alloy::sol_types::sol_data::Uint<
396 8,
397 > as alloy_sol_types::SolType>::Token<'_> {
398 alloy_sol_types::private::SolTypeValue::<
399 alloy::sol_types::sol_data::Uint<8>,
400 >::stv_to_tokens(self)
401 }
402 #[inline]
403 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
404 <alloy::sol_types::sol_data::Uint<
405 8,
406 > as alloy_sol_types::SolType>::tokenize(self)
407 .0
408 }
409 #[inline]
410 fn stv_abi_encode_packed_to(
411 &self,
412 out: &mut alloy_sol_types::private::Vec<u8>,
413 ) {
414 <alloy::sol_types::sol_data::Uint<
415 8,
416 > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
417 }
418 #[inline]
419 fn stv_abi_packed_encoded_size(&self) -> usize {
420 <alloy::sol_types::sol_data::Uint<
421 8,
422 > as alloy_sol_types::SolType>::abi_encoded_size(self)
423 }
424 }
425 #[automatically_derived]
426 impl OperatorStatus {
427 pub const NAME: &'static str = stringify!(@ name);
429 #[inline]
431 pub const fn from(value: u8) -> Self {
432 Self(value)
433 }
434 #[inline]
436 pub const fn into(self) -> u8 {
437 self.0
438 }
439 #[inline]
442 pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
443 <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
444 }
445 #[inline]
448 pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
449 <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
450 }
451 }
452 #[automatically_derived]
453 impl alloy_sol_types::SolType for OperatorStatus {
454 type RustType = u8;
455 type Token<'a> = <alloy::sol_types::sol_data::Uint<
456 8,
457 > as alloy_sol_types::SolType>::Token<'a>;
458 const SOL_NAME: &'static str = Self::NAME;
459 const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
460 8,
461 > as alloy_sol_types::SolType>::ENCODED_SIZE;
462 const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
463 8,
464 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
465 #[inline]
466 fn valid_token(token: &Self::Token<'_>) -> bool {
467 Self::type_check(token).is_ok()
468 }
469 #[inline]
470 fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
471 <alloy::sol_types::sol_data::Uint<
472 8,
473 > as alloy_sol_types::SolType>::type_check(token)
474 }
475 #[inline]
476 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
477 <alloy::sol_types::sol_data::Uint<
478 8,
479 > as alloy_sol_types::SolType>::detokenize(token)
480 }
481 }
482 #[automatically_derived]
483 impl alloy_sol_types::EventTopic for OperatorStatus {
484 #[inline]
485 fn topic_preimage_length(rust: &Self::RustType) -> usize {
486 <alloy::sol_types::sol_data::Uint<
487 8,
488 > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
489 }
490 #[inline]
491 fn encode_topic_preimage(
492 rust: &Self::RustType,
493 out: &mut alloy_sol_types::private::Vec<u8>,
494 ) {
495 <alloy::sol_types::sol_data::Uint<
496 8,
497 > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
498 }
499 #[inline]
500 fn encode_topic(
501 rust: &Self::RustType,
502 ) -> alloy_sol_types::abi::token::WordToken {
503 <alloy::sol_types::sol_data::Uint<
504 8,
505 > as alloy_sol_types::EventTopic>::encode_topic(rust)
506 }
507 }
508 };
509 #[derive(Default, Debug, PartialEq, Eq, Hash)]
510 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
514 #[derive(Clone)]
515 pub struct OperatorInfo {
516 #[allow(missing_docs)]
517 pub operatorId: alloy::sol_types::private::FixedBytes<32>,
518 #[allow(missing_docs)]
519 pub status: <OperatorStatus as alloy::sol_types::SolType>::RustType,
520 }
521 #[allow(
522 non_camel_case_types,
523 non_snake_case,
524 clippy::pub_underscore_fields,
525 clippy::style
526 )]
527 const _: () = {
528 use alloy::sol_types as alloy_sol_types;
529 #[doc(hidden)]
530 type UnderlyingSolTuple<'a> = (
531 alloy::sol_types::sol_data::FixedBytes<32>,
532 OperatorStatus,
533 );
534 #[doc(hidden)]
535 type UnderlyingRustTuple<'a> = (
536 alloy::sol_types::private::FixedBytes<32>,
537 <OperatorStatus as alloy::sol_types::SolType>::RustType,
538 );
539 #[cfg(test)]
540 #[allow(dead_code, unreachable_patterns)]
541 fn _type_assertion(
542 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
543 ) {
544 match _t {
545 alloy_sol_types::private::AssertTypeEq::<
546 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
547 >(_) => {}
548 }
549 }
550 #[automatically_derived]
551 #[doc(hidden)]
552 impl ::core::convert::From<OperatorInfo> for UnderlyingRustTuple<'_> {
553 fn from(value: OperatorInfo) -> Self {
554 (value.operatorId, value.status)
555 }
556 }
557 #[automatically_derived]
558 #[doc(hidden)]
559 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorInfo {
560 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
561 Self {
562 operatorId: tuple.0,
563 status: tuple.1,
564 }
565 }
566 }
567 #[automatically_derived]
568 impl alloy_sol_types::SolValue for OperatorInfo {
569 type SolType = Self;
570 }
571 #[automatically_derived]
572 impl alloy_sol_types::private::SolTypeValue<Self> for OperatorInfo {
573 #[inline]
574 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
575 (
576 <alloy::sol_types::sol_data::FixedBytes<
577 32,
578 > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
579 <OperatorStatus as alloy_sol_types::SolType>::tokenize(&self.status),
580 )
581 }
582 #[inline]
583 fn stv_abi_encoded_size(&self) -> usize {
584 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
585 return size;
586 }
587 let tuple = <UnderlyingRustTuple<
588 '_,
589 > as ::core::convert::From<Self>>::from(self.clone());
590 <UnderlyingSolTuple<
591 '_,
592 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
593 }
594 #[inline]
595 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
596 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
597 }
598 #[inline]
599 fn stv_abi_encode_packed_to(
600 &self,
601 out: &mut alloy_sol_types::private::Vec<u8>,
602 ) {
603 let tuple = <UnderlyingRustTuple<
604 '_,
605 > as ::core::convert::From<Self>>::from(self.clone());
606 <UnderlyingSolTuple<
607 '_,
608 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
609 }
610 #[inline]
611 fn stv_abi_packed_encoded_size(&self) -> usize {
612 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
613 return size;
614 }
615 let tuple = <UnderlyingRustTuple<
616 '_,
617 > as ::core::convert::From<Self>>::from(self.clone());
618 <UnderlyingSolTuple<
619 '_,
620 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
621 }
622 }
623 #[automatically_derived]
624 impl alloy_sol_types::SolType for OperatorInfo {
625 type RustType = Self;
626 type Token<'a> = <UnderlyingSolTuple<
627 'a,
628 > as alloy_sol_types::SolType>::Token<'a>;
629 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
630 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
631 '_,
632 > as alloy_sol_types::SolType>::ENCODED_SIZE;
633 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
634 '_,
635 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
636 #[inline]
637 fn valid_token(token: &Self::Token<'_>) -> bool {
638 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
639 }
640 #[inline]
641 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
642 let tuple = <UnderlyingSolTuple<
643 '_,
644 > as alloy_sol_types::SolType>::detokenize(token);
645 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
646 }
647 }
648 #[automatically_derived]
649 impl alloy_sol_types::SolStruct for OperatorInfo {
650 const NAME: &'static str = "OperatorInfo";
651 #[inline]
652 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
653 alloy_sol_types::private::Cow::Borrowed(
654 "OperatorInfo(bytes32 operatorId,uint8 status)",
655 )
656 }
657 #[inline]
658 fn eip712_components() -> alloy_sol_types::private::Vec<
659 alloy_sol_types::private::Cow<'static, str>,
660 > {
661 alloy_sol_types::private::Vec::new()
662 }
663 #[inline]
664 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
665 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
666 }
667 #[inline]
668 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
669 [
670 <alloy::sol_types::sol_data::FixedBytes<
671 32,
672 > as alloy_sol_types::SolType>::eip712_data_word(&self.operatorId)
673 .0,
674 <OperatorStatus as alloy_sol_types::SolType>::eip712_data_word(
675 &self.status,
676 )
677 .0,
678 ]
679 .concat()
680 }
681 }
682 #[automatically_derived]
683 impl alloy_sol_types::EventTopic for OperatorInfo {
684 #[inline]
685 fn topic_preimage_length(rust: &Self::RustType) -> usize {
686 0usize
687 + <alloy::sol_types::sol_data::FixedBytes<
688 32,
689 > as alloy_sol_types::EventTopic>::topic_preimage_length(
690 &rust.operatorId,
691 )
692 + <OperatorStatus as alloy_sol_types::EventTopic>::topic_preimage_length(
693 &rust.status,
694 )
695 }
696 #[inline]
697 fn encode_topic_preimage(
698 rust: &Self::RustType,
699 out: &mut alloy_sol_types::private::Vec<u8>,
700 ) {
701 out.reserve(
702 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
703 );
704 <alloy::sol_types::sol_data::FixedBytes<
705 32,
706 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
707 &rust.operatorId,
708 out,
709 );
710 <OperatorStatus as alloy_sol_types::EventTopic>::encode_topic_preimage(
711 &rust.status,
712 out,
713 );
714 }
715 #[inline]
716 fn encode_topic(
717 rust: &Self::RustType,
718 ) -> alloy_sol_types::abi::token::WordToken {
719 let mut out = alloy_sol_types::private::Vec::new();
720 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
721 rust,
722 &mut out,
723 );
724 alloy_sol_types::abi::token::WordToken(
725 alloy_sol_types::private::keccak256(out),
726 )
727 }
728 }
729 };
730 #[derive(Default, Debug, PartialEq, Eq, Hash)]
731 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
735 #[derive(Clone)]
736 pub struct OperatorKickParam {
737 #[allow(missing_docs)]
738 pub quorumNumber: u8,
739 #[allow(missing_docs)]
740 pub operator: alloy::sol_types::private::Address,
741 }
742 #[allow(
743 non_camel_case_types,
744 non_snake_case,
745 clippy::pub_underscore_fields,
746 clippy::style
747 )]
748 const _: () = {
749 use alloy::sol_types as alloy_sol_types;
750 #[doc(hidden)]
751 type UnderlyingSolTuple<'a> = (
752 alloy::sol_types::sol_data::Uint<8>,
753 alloy::sol_types::sol_data::Address,
754 );
755 #[doc(hidden)]
756 type UnderlyingRustTuple<'a> = (u8, alloy::sol_types::private::Address);
757 #[cfg(test)]
758 #[allow(dead_code, unreachable_patterns)]
759 fn _type_assertion(
760 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
761 ) {
762 match _t {
763 alloy_sol_types::private::AssertTypeEq::<
764 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
765 >(_) => {}
766 }
767 }
768 #[automatically_derived]
769 #[doc(hidden)]
770 impl ::core::convert::From<OperatorKickParam> for UnderlyingRustTuple<'_> {
771 fn from(value: OperatorKickParam) -> Self {
772 (value.quorumNumber, value.operator)
773 }
774 }
775 #[automatically_derived]
776 #[doc(hidden)]
777 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorKickParam {
778 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
779 Self {
780 quorumNumber: tuple.0,
781 operator: tuple.1,
782 }
783 }
784 }
785 #[automatically_derived]
786 impl alloy_sol_types::SolValue for OperatorKickParam {
787 type SolType = Self;
788 }
789 #[automatically_derived]
790 impl alloy_sol_types::private::SolTypeValue<Self> for OperatorKickParam {
791 #[inline]
792 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
793 (
794 <alloy::sol_types::sol_data::Uint<
795 8,
796 > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
797 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
798 &self.operator,
799 ),
800 )
801 }
802 #[inline]
803 fn stv_abi_encoded_size(&self) -> usize {
804 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
805 return size;
806 }
807 let tuple = <UnderlyingRustTuple<
808 '_,
809 > as ::core::convert::From<Self>>::from(self.clone());
810 <UnderlyingSolTuple<
811 '_,
812 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
813 }
814 #[inline]
815 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
816 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
817 }
818 #[inline]
819 fn stv_abi_encode_packed_to(
820 &self,
821 out: &mut alloy_sol_types::private::Vec<u8>,
822 ) {
823 let tuple = <UnderlyingRustTuple<
824 '_,
825 > as ::core::convert::From<Self>>::from(self.clone());
826 <UnderlyingSolTuple<
827 '_,
828 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
829 }
830 #[inline]
831 fn stv_abi_packed_encoded_size(&self) -> usize {
832 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
833 return size;
834 }
835 let tuple = <UnderlyingRustTuple<
836 '_,
837 > as ::core::convert::From<Self>>::from(self.clone());
838 <UnderlyingSolTuple<
839 '_,
840 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
841 }
842 }
843 #[automatically_derived]
844 impl alloy_sol_types::SolType for OperatorKickParam {
845 type RustType = Self;
846 type Token<'a> = <UnderlyingSolTuple<
847 'a,
848 > as alloy_sol_types::SolType>::Token<'a>;
849 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
850 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
851 '_,
852 > as alloy_sol_types::SolType>::ENCODED_SIZE;
853 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
854 '_,
855 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
856 #[inline]
857 fn valid_token(token: &Self::Token<'_>) -> bool {
858 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
859 }
860 #[inline]
861 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
862 let tuple = <UnderlyingSolTuple<
863 '_,
864 > as alloy_sol_types::SolType>::detokenize(token);
865 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
866 }
867 }
868 #[automatically_derived]
869 impl alloy_sol_types::SolStruct for OperatorKickParam {
870 const NAME: &'static str = "OperatorKickParam";
871 #[inline]
872 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
873 alloy_sol_types::private::Cow::Borrowed(
874 "OperatorKickParam(uint8 quorumNumber,address operator)",
875 )
876 }
877 #[inline]
878 fn eip712_components() -> alloy_sol_types::private::Vec<
879 alloy_sol_types::private::Cow<'static, str>,
880 > {
881 alloy_sol_types::private::Vec::new()
882 }
883 #[inline]
884 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
885 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
886 }
887 #[inline]
888 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
889 [
890 <alloy::sol_types::sol_data::Uint<
891 8,
892 > as alloy_sol_types::SolType>::eip712_data_word(&self.quorumNumber)
893 .0,
894 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
895 &self.operator,
896 )
897 .0,
898 ]
899 .concat()
900 }
901 }
902 #[automatically_derived]
903 impl alloy_sol_types::EventTopic for OperatorKickParam {
904 #[inline]
905 fn topic_preimage_length(rust: &Self::RustType) -> usize {
906 0usize
907 + <alloy::sol_types::sol_data::Uint<
908 8,
909 > as alloy_sol_types::EventTopic>::topic_preimage_length(
910 &rust.quorumNumber,
911 )
912 + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
913 &rust.operator,
914 )
915 }
916 #[inline]
917 fn encode_topic_preimage(
918 rust: &Self::RustType,
919 out: &mut alloy_sol_types::private::Vec<u8>,
920 ) {
921 out.reserve(
922 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
923 );
924 <alloy::sol_types::sol_data::Uint<
925 8,
926 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
927 &rust.quorumNumber,
928 out,
929 );
930 <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
931 &rust.operator,
932 out,
933 );
934 }
935 #[inline]
936 fn encode_topic(
937 rust: &Self::RustType,
938 ) -> alloy_sol_types::abi::token::WordToken {
939 let mut out = alloy_sol_types::private::Vec::new();
940 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
941 rust,
942 &mut out,
943 );
944 alloy_sol_types::abi::token::WordToken(
945 alloy_sol_types::private::keccak256(out),
946 )
947 }
948 }
949 };
950 #[derive(Default, Debug, PartialEq, Eq, Hash)]
951 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
955 #[derive(Clone)]
956 pub struct OperatorSetParam {
957 #[allow(missing_docs)]
958 pub maxOperatorCount: u32,
959 #[allow(missing_docs)]
960 pub kickBIPsOfOperatorStake: u16,
961 #[allow(missing_docs)]
962 pub kickBIPsOfTotalStake: u16,
963 }
964 #[allow(
965 non_camel_case_types,
966 non_snake_case,
967 clippy::pub_underscore_fields,
968 clippy::style
969 )]
970 const _: () = {
971 use alloy::sol_types as alloy_sol_types;
972 #[doc(hidden)]
973 type UnderlyingSolTuple<'a> = (
974 alloy::sol_types::sol_data::Uint<32>,
975 alloy::sol_types::sol_data::Uint<16>,
976 alloy::sol_types::sol_data::Uint<16>,
977 );
978 #[doc(hidden)]
979 type UnderlyingRustTuple<'a> = (u32, u16, u16);
980 #[cfg(test)]
981 #[allow(dead_code, unreachable_patterns)]
982 fn _type_assertion(
983 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
984 ) {
985 match _t {
986 alloy_sol_types::private::AssertTypeEq::<
987 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
988 >(_) => {}
989 }
990 }
991 #[automatically_derived]
992 #[doc(hidden)]
993 impl ::core::convert::From<OperatorSetParam> for UnderlyingRustTuple<'_> {
994 fn from(value: OperatorSetParam) -> Self {
995 (
996 value.maxOperatorCount,
997 value.kickBIPsOfOperatorStake,
998 value.kickBIPsOfTotalStake,
999 )
1000 }
1001 }
1002 #[automatically_derived]
1003 #[doc(hidden)]
1004 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorSetParam {
1005 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1006 Self {
1007 maxOperatorCount: tuple.0,
1008 kickBIPsOfOperatorStake: tuple.1,
1009 kickBIPsOfTotalStake: tuple.2,
1010 }
1011 }
1012 }
1013 #[automatically_derived]
1014 impl alloy_sol_types::SolValue for OperatorSetParam {
1015 type SolType = Self;
1016 }
1017 #[automatically_derived]
1018 impl alloy_sol_types::private::SolTypeValue<Self> for OperatorSetParam {
1019 #[inline]
1020 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1021 (
1022 <alloy::sol_types::sol_data::Uint<
1023 32,
1024 > as alloy_sol_types::SolType>::tokenize(&self.maxOperatorCount),
1025 <alloy::sol_types::sol_data::Uint<
1026 16,
1027 > as alloy_sol_types::SolType>::tokenize(
1028 &self.kickBIPsOfOperatorStake,
1029 ),
1030 <alloy::sol_types::sol_data::Uint<
1031 16,
1032 > as alloy_sol_types::SolType>::tokenize(&self.kickBIPsOfTotalStake),
1033 )
1034 }
1035 #[inline]
1036 fn stv_abi_encoded_size(&self) -> usize {
1037 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1038 return size;
1039 }
1040 let tuple = <UnderlyingRustTuple<
1041 '_,
1042 > as ::core::convert::From<Self>>::from(self.clone());
1043 <UnderlyingSolTuple<
1044 '_,
1045 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1046 }
1047 #[inline]
1048 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1049 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1050 }
1051 #[inline]
1052 fn stv_abi_encode_packed_to(
1053 &self,
1054 out: &mut alloy_sol_types::private::Vec<u8>,
1055 ) {
1056 let tuple = <UnderlyingRustTuple<
1057 '_,
1058 > as ::core::convert::From<Self>>::from(self.clone());
1059 <UnderlyingSolTuple<
1060 '_,
1061 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1062 }
1063 #[inline]
1064 fn stv_abi_packed_encoded_size(&self) -> usize {
1065 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1066 return size;
1067 }
1068 let tuple = <UnderlyingRustTuple<
1069 '_,
1070 > as ::core::convert::From<Self>>::from(self.clone());
1071 <UnderlyingSolTuple<
1072 '_,
1073 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1074 }
1075 }
1076 #[automatically_derived]
1077 impl alloy_sol_types::SolType for OperatorSetParam {
1078 type RustType = Self;
1079 type Token<'a> = <UnderlyingSolTuple<
1080 'a,
1081 > as alloy_sol_types::SolType>::Token<'a>;
1082 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1083 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1084 '_,
1085 > as alloy_sol_types::SolType>::ENCODED_SIZE;
1086 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1087 '_,
1088 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1089 #[inline]
1090 fn valid_token(token: &Self::Token<'_>) -> bool {
1091 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1092 }
1093 #[inline]
1094 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1095 let tuple = <UnderlyingSolTuple<
1096 '_,
1097 > as alloy_sol_types::SolType>::detokenize(token);
1098 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1099 }
1100 }
1101 #[automatically_derived]
1102 impl alloy_sol_types::SolStruct for OperatorSetParam {
1103 const NAME: &'static str = "OperatorSetParam";
1104 #[inline]
1105 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1106 alloy_sol_types::private::Cow::Borrowed(
1107 "OperatorSetParam(uint32 maxOperatorCount,uint16 kickBIPsOfOperatorStake,uint16 kickBIPsOfTotalStake)",
1108 )
1109 }
1110 #[inline]
1111 fn eip712_components() -> alloy_sol_types::private::Vec<
1112 alloy_sol_types::private::Cow<'static, str>,
1113 > {
1114 alloy_sol_types::private::Vec::new()
1115 }
1116 #[inline]
1117 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1118 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1119 }
1120 #[inline]
1121 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1122 [
1123 <alloy::sol_types::sol_data::Uint<
1124 32,
1125 > as alloy_sol_types::SolType>::eip712_data_word(
1126 &self.maxOperatorCount,
1127 )
1128 .0,
1129 <alloy::sol_types::sol_data::Uint<
1130 16,
1131 > as alloy_sol_types::SolType>::eip712_data_word(
1132 &self.kickBIPsOfOperatorStake,
1133 )
1134 .0,
1135 <alloy::sol_types::sol_data::Uint<
1136 16,
1137 > as alloy_sol_types::SolType>::eip712_data_word(
1138 &self.kickBIPsOfTotalStake,
1139 )
1140 .0,
1141 ]
1142 .concat()
1143 }
1144 }
1145 #[automatically_derived]
1146 impl alloy_sol_types::EventTopic for OperatorSetParam {
1147 #[inline]
1148 fn topic_preimage_length(rust: &Self::RustType) -> usize {
1149 0usize
1150 + <alloy::sol_types::sol_data::Uint<
1151 32,
1152 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1153 &rust.maxOperatorCount,
1154 )
1155 + <alloy::sol_types::sol_data::Uint<
1156 16,
1157 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1158 &rust.kickBIPsOfOperatorStake,
1159 )
1160 + <alloy::sol_types::sol_data::Uint<
1161 16,
1162 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1163 &rust.kickBIPsOfTotalStake,
1164 )
1165 }
1166 #[inline]
1167 fn encode_topic_preimage(
1168 rust: &Self::RustType,
1169 out: &mut alloy_sol_types::private::Vec<u8>,
1170 ) {
1171 out.reserve(
1172 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1173 );
1174 <alloy::sol_types::sol_data::Uint<
1175 32,
1176 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1177 &rust.maxOperatorCount,
1178 out,
1179 );
1180 <alloy::sol_types::sol_data::Uint<
1181 16,
1182 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1183 &rust.kickBIPsOfOperatorStake,
1184 out,
1185 );
1186 <alloy::sol_types::sol_data::Uint<
1187 16,
1188 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1189 &rust.kickBIPsOfTotalStake,
1190 out,
1191 );
1192 }
1193 #[inline]
1194 fn encode_topic(
1195 rust: &Self::RustType,
1196 ) -> alloy_sol_types::abi::token::WordToken {
1197 let mut out = alloy_sol_types::private::Vec::new();
1198 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1199 rust,
1200 &mut out,
1201 );
1202 alloy_sol_types::abi::token::WordToken(
1203 alloy_sol_types::private::keccak256(out),
1204 )
1205 }
1206 }
1207 };
1208 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1209 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1213 #[derive(Clone)]
1214 pub struct QuorumBitmapUpdate {
1215 #[allow(missing_docs)]
1216 pub updateBlockNumber: u32,
1217 #[allow(missing_docs)]
1218 pub nextUpdateBlockNumber: u32,
1219 #[allow(missing_docs)]
1220 pub quorumBitmap: alloy::sol_types::private::primitives::aliases::U192,
1221 }
1222 #[allow(
1223 non_camel_case_types,
1224 non_snake_case,
1225 clippy::pub_underscore_fields,
1226 clippy::style
1227 )]
1228 const _: () = {
1229 use alloy::sol_types as alloy_sol_types;
1230 #[doc(hidden)]
1231 type UnderlyingSolTuple<'a> = (
1232 alloy::sol_types::sol_data::Uint<32>,
1233 alloy::sol_types::sol_data::Uint<32>,
1234 alloy::sol_types::sol_data::Uint<192>,
1235 );
1236 #[doc(hidden)]
1237 type UnderlyingRustTuple<'a> = (
1238 u32,
1239 u32,
1240 alloy::sol_types::private::primitives::aliases::U192,
1241 );
1242 #[cfg(test)]
1243 #[allow(dead_code, unreachable_patterns)]
1244 fn _type_assertion(
1245 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1246 ) {
1247 match _t {
1248 alloy_sol_types::private::AssertTypeEq::<
1249 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1250 >(_) => {}
1251 }
1252 }
1253 #[automatically_derived]
1254 #[doc(hidden)]
1255 impl ::core::convert::From<QuorumBitmapUpdate> for UnderlyingRustTuple<'_> {
1256 fn from(value: QuorumBitmapUpdate) -> Self {
1257 (
1258 value.updateBlockNumber,
1259 value.nextUpdateBlockNumber,
1260 value.quorumBitmap,
1261 )
1262 }
1263 }
1264 #[automatically_derived]
1265 #[doc(hidden)]
1266 impl ::core::convert::From<UnderlyingRustTuple<'_>> for QuorumBitmapUpdate {
1267 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1268 Self {
1269 updateBlockNumber: tuple.0,
1270 nextUpdateBlockNumber: tuple.1,
1271 quorumBitmap: tuple.2,
1272 }
1273 }
1274 }
1275 #[automatically_derived]
1276 impl alloy_sol_types::SolValue for QuorumBitmapUpdate {
1277 type SolType = Self;
1278 }
1279 #[automatically_derived]
1280 impl alloy_sol_types::private::SolTypeValue<Self> for QuorumBitmapUpdate {
1281 #[inline]
1282 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1283 (
1284 <alloy::sol_types::sol_data::Uint<
1285 32,
1286 > as alloy_sol_types::SolType>::tokenize(&self.updateBlockNumber),
1287 <alloy::sol_types::sol_data::Uint<
1288 32,
1289 > as alloy_sol_types::SolType>::tokenize(
1290 &self.nextUpdateBlockNumber,
1291 ),
1292 <alloy::sol_types::sol_data::Uint<
1293 192,
1294 > as alloy_sol_types::SolType>::tokenize(&self.quorumBitmap),
1295 )
1296 }
1297 #[inline]
1298 fn stv_abi_encoded_size(&self) -> usize {
1299 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1300 return size;
1301 }
1302 let tuple = <UnderlyingRustTuple<
1303 '_,
1304 > as ::core::convert::From<Self>>::from(self.clone());
1305 <UnderlyingSolTuple<
1306 '_,
1307 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1308 }
1309 #[inline]
1310 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1311 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1312 }
1313 #[inline]
1314 fn stv_abi_encode_packed_to(
1315 &self,
1316 out: &mut alloy_sol_types::private::Vec<u8>,
1317 ) {
1318 let tuple = <UnderlyingRustTuple<
1319 '_,
1320 > as ::core::convert::From<Self>>::from(self.clone());
1321 <UnderlyingSolTuple<
1322 '_,
1323 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1324 }
1325 #[inline]
1326 fn stv_abi_packed_encoded_size(&self) -> usize {
1327 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1328 return size;
1329 }
1330 let tuple = <UnderlyingRustTuple<
1331 '_,
1332 > as ::core::convert::From<Self>>::from(self.clone());
1333 <UnderlyingSolTuple<
1334 '_,
1335 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1336 }
1337 }
1338 #[automatically_derived]
1339 impl alloy_sol_types::SolType for QuorumBitmapUpdate {
1340 type RustType = Self;
1341 type Token<'a> = <UnderlyingSolTuple<
1342 'a,
1343 > as alloy_sol_types::SolType>::Token<'a>;
1344 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1345 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1346 '_,
1347 > as alloy_sol_types::SolType>::ENCODED_SIZE;
1348 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1349 '_,
1350 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1351 #[inline]
1352 fn valid_token(token: &Self::Token<'_>) -> bool {
1353 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1354 }
1355 #[inline]
1356 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1357 let tuple = <UnderlyingSolTuple<
1358 '_,
1359 > as alloy_sol_types::SolType>::detokenize(token);
1360 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1361 }
1362 }
1363 #[automatically_derived]
1364 impl alloy_sol_types::SolStruct for QuorumBitmapUpdate {
1365 const NAME: &'static str = "QuorumBitmapUpdate";
1366 #[inline]
1367 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1368 alloy_sol_types::private::Cow::Borrowed(
1369 "QuorumBitmapUpdate(uint32 updateBlockNumber,uint32 nextUpdateBlockNumber,uint192 quorumBitmap)",
1370 )
1371 }
1372 #[inline]
1373 fn eip712_components() -> alloy_sol_types::private::Vec<
1374 alloy_sol_types::private::Cow<'static, str>,
1375 > {
1376 alloy_sol_types::private::Vec::new()
1377 }
1378 #[inline]
1379 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1380 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1381 }
1382 #[inline]
1383 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1384 [
1385 <alloy::sol_types::sol_data::Uint<
1386 32,
1387 > as alloy_sol_types::SolType>::eip712_data_word(
1388 &self.updateBlockNumber,
1389 )
1390 .0,
1391 <alloy::sol_types::sol_data::Uint<
1392 32,
1393 > as alloy_sol_types::SolType>::eip712_data_word(
1394 &self.nextUpdateBlockNumber,
1395 )
1396 .0,
1397 <alloy::sol_types::sol_data::Uint<
1398 192,
1399 > as alloy_sol_types::SolType>::eip712_data_word(&self.quorumBitmap)
1400 .0,
1401 ]
1402 .concat()
1403 }
1404 }
1405 #[automatically_derived]
1406 impl alloy_sol_types::EventTopic for QuorumBitmapUpdate {
1407 #[inline]
1408 fn topic_preimage_length(rust: &Self::RustType) -> usize {
1409 0usize
1410 + <alloy::sol_types::sol_data::Uint<
1411 32,
1412 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1413 &rust.updateBlockNumber,
1414 )
1415 + <alloy::sol_types::sol_data::Uint<
1416 32,
1417 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1418 &rust.nextUpdateBlockNumber,
1419 )
1420 + <alloy::sol_types::sol_data::Uint<
1421 192,
1422 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1423 &rust.quorumBitmap,
1424 )
1425 }
1426 #[inline]
1427 fn encode_topic_preimage(
1428 rust: &Self::RustType,
1429 out: &mut alloy_sol_types::private::Vec<u8>,
1430 ) {
1431 out.reserve(
1432 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1433 );
1434 <alloy::sol_types::sol_data::Uint<
1435 32,
1436 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1437 &rust.updateBlockNumber,
1438 out,
1439 );
1440 <alloy::sol_types::sol_data::Uint<
1441 32,
1442 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1443 &rust.nextUpdateBlockNumber,
1444 out,
1445 );
1446 <alloy::sol_types::sol_data::Uint<
1447 192,
1448 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1449 &rust.quorumBitmap,
1450 out,
1451 );
1452 }
1453 #[inline]
1454 fn encode_topic(
1455 rust: &Self::RustType,
1456 ) -> alloy_sol_types::abi::token::WordToken {
1457 let mut out = alloy_sol_types::private::Vec::new();
1458 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1459 rust,
1460 &mut out,
1461 );
1462 alloy_sol_types::abi::token::WordToken(
1463 alloy_sol_types::private::keccak256(out),
1464 )
1465 }
1466 }
1467 };
1468 use alloy::contract as alloy_contract;
1469 #[inline]
1473 pub const fn new<
1474 T: alloy_contract::private::Transport + ::core::clone::Clone,
1475 P: alloy_contract::private::Provider<T, N>,
1476 N: alloy_contract::private::Network,
1477 >(
1478 address: alloy_sol_types::private::Address,
1479 provider: P,
1480 ) -> ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
1481 ISlashingRegistryCoordinatorTypesInstance::<T, P, N>::new(address, provider)
1482 }
1483 #[derive(Clone)]
1495 pub struct ISlashingRegistryCoordinatorTypesInstance<
1496 T,
1497 P,
1498 N = alloy_contract::private::Ethereum,
1499 > {
1500 address: alloy_sol_types::private::Address,
1501 provider: P,
1502 _network_transport: ::core::marker::PhantomData<(N, T)>,
1503 }
1504 #[automatically_derived]
1505 impl<T, P, N> ::core::fmt::Debug
1506 for ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
1507 #[inline]
1508 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1509 f.debug_tuple("ISlashingRegistryCoordinatorTypesInstance")
1510 .field(&self.address)
1511 .finish()
1512 }
1513 }
1514 #[automatically_derived]
1516 impl<
1517 T: alloy_contract::private::Transport + ::core::clone::Clone,
1518 P: alloy_contract::private::Provider<T, N>,
1519 N: alloy_contract::private::Network,
1520 > ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
1521 #[inline]
1525 pub const fn new(
1526 address: alloy_sol_types::private::Address,
1527 provider: P,
1528 ) -> Self {
1529 Self {
1530 address,
1531 provider,
1532 _network_transport: ::core::marker::PhantomData,
1533 }
1534 }
1535 #[inline]
1537 pub const fn address(&self) -> &alloy_sol_types::private::Address {
1538 &self.address
1539 }
1540 #[inline]
1542 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1543 self.address = address;
1544 }
1545 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1547 self.set_address(address);
1548 self
1549 }
1550 #[inline]
1552 pub const fn provider(&self) -> &P {
1553 &self.provider
1554 }
1555 }
1556 impl<
1557 T,
1558 P: ::core::clone::Clone,
1559 N,
1560 > ISlashingRegistryCoordinatorTypesInstance<T, &P, N> {
1561 #[inline]
1563 pub fn with_cloned_provider(
1564 self,
1565 ) -> ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
1566 ISlashingRegistryCoordinatorTypesInstance {
1567 address: self.address,
1568 provider: ::core::clone::Clone::clone(&self.provider),
1569 _network_transport: ::core::marker::PhantomData,
1570 }
1571 }
1572 }
1573 #[automatically_derived]
1575 impl<
1576 T: alloy_contract::private::Transport + ::core::clone::Clone,
1577 P: alloy_contract::private::Provider<T, N>,
1578 N: alloy_contract::private::Network,
1579 > ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
1580 pub fn call_builder<C: alloy_sol_types::SolCall>(
1585 &self,
1586 call: &C,
1587 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
1588 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1589 }
1590 }
1591 #[automatically_derived]
1593 impl<
1594 T: alloy_contract::private::Transport + ::core::clone::Clone,
1595 P: alloy_contract::private::Provider<T, N>,
1596 N: alloy_contract::private::Network,
1597 > ISlashingRegistryCoordinatorTypesInstance<T, P, N> {
1598 pub fn event_filter<E: alloy_sol_types::SolEvent>(
1603 &self,
1604 ) -> alloy_contract::Event<T, &P, E, N> {
1605 alloy_contract::Event::new_sol(&self.provider, &self.address)
1606 }
1607 }
1608}
1609#[allow(
1619 non_camel_case_types,
1620 non_snake_case,
1621 clippy::pub_underscore_fields,
1622 clippy::style,
1623 clippy::empty_structs_with_brackets
1624)]
1625pub mod IStakeRegistryTypes {
1626 use super::*;
1627 use alloy::sol_types as alloy_sol_types;
1628 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1629 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1630 #[derive(Clone)]
1631 pub struct StakeType(u8);
1632 const _: () = {
1633 use alloy::sol_types as alloy_sol_types;
1634 #[automatically_derived]
1635 impl alloy_sol_types::private::SolTypeValue<StakeType> for u8 {
1636 #[inline]
1637 fn stv_to_tokens(
1638 &self,
1639 ) -> <alloy::sol_types::sol_data::Uint<
1640 8,
1641 > as alloy_sol_types::SolType>::Token<'_> {
1642 alloy_sol_types::private::SolTypeValue::<
1643 alloy::sol_types::sol_data::Uint<8>,
1644 >::stv_to_tokens(self)
1645 }
1646 #[inline]
1647 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1648 <alloy::sol_types::sol_data::Uint<
1649 8,
1650 > as alloy_sol_types::SolType>::tokenize(self)
1651 .0
1652 }
1653 #[inline]
1654 fn stv_abi_encode_packed_to(
1655 &self,
1656 out: &mut alloy_sol_types::private::Vec<u8>,
1657 ) {
1658 <alloy::sol_types::sol_data::Uint<
1659 8,
1660 > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
1661 }
1662 #[inline]
1663 fn stv_abi_packed_encoded_size(&self) -> usize {
1664 <alloy::sol_types::sol_data::Uint<
1665 8,
1666 > as alloy_sol_types::SolType>::abi_encoded_size(self)
1667 }
1668 }
1669 #[automatically_derived]
1670 impl StakeType {
1671 pub const NAME: &'static str = stringify!(@ name);
1673 #[inline]
1675 pub const fn from(value: u8) -> Self {
1676 Self(value)
1677 }
1678 #[inline]
1680 pub const fn into(self) -> u8 {
1681 self.0
1682 }
1683 #[inline]
1686 pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
1687 <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
1688 }
1689 #[inline]
1692 pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
1693 <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
1694 }
1695 }
1696 #[automatically_derived]
1697 impl alloy_sol_types::SolType for StakeType {
1698 type RustType = u8;
1699 type Token<'a> = <alloy::sol_types::sol_data::Uint<
1700 8,
1701 > as alloy_sol_types::SolType>::Token<'a>;
1702 const SOL_NAME: &'static str = Self::NAME;
1703 const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
1704 8,
1705 > as alloy_sol_types::SolType>::ENCODED_SIZE;
1706 const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
1707 8,
1708 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1709 #[inline]
1710 fn valid_token(token: &Self::Token<'_>) -> bool {
1711 Self::type_check(token).is_ok()
1712 }
1713 #[inline]
1714 fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
1715 <alloy::sol_types::sol_data::Uint<
1716 8,
1717 > as alloy_sol_types::SolType>::type_check(token)
1718 }
1719 #[inline]
1720 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1721 <alloy::sol_types::sol_data::Uint<
1722 8,
1723 > as alloy_sol_types::SolType>::detokenize(token)
1724 }
1725 }
1726 #[automatically_derived]
1727 impl alloy_sol_types::EventTopic for StakeType {
1728 #[inline]
1729 fn topic_preimage_length(rust: &Self::RustType) -> usize {
1730 <alloy::sol_types::sol_data::Uint<
1731 8,
1732 > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
1733 }
1734 #[inline]
1735 fn encode_topic_preimage(
1736 rust: &Self::RustType,
1737 out: &mut alloy_sol_types::private::Vec<u8>,
1738 ) {
1739 <alloy::sol_types::sol_data::Uint<
1740 8,
1741 > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
1742 }
1743 #[inline]
1744 fn encode_topic(
1745 rust: &Self::RustType,
1746 ) -> alloy_sol_types::abi::token::WordToken {
1747 <alloy::sol_types::sol_data::Uint<
1748 8,
1749 > as alloy_sol_types::EventTopic>::encode_topic(rust)
1750 }
1751 }
1752 };
1753 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1754 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1758 #[derive(Clone)]
1759 pub struct StrategyParams {
1760 #[allow(missing_docs)]
1761 pub strategy: alloy::sol_types::private::Address,
1762 #[allow(missing_docs)]
1763 pub multiplier: alloy::sol_types::private::primitives::aliases::U96,
1764 }
1765 #[allow(
1766 non_camel_case_types,
1767 non_snake_case,
1768 clippy::pub_underscore_fields,
1769 clippy::style
1770 )]
1771 const _: () = {
1772 use alloy::sol_types as alloy_sol_types;
1773 #[doc(hidden)]
1774 type UnderlyingSolTuple<'a> = (
1775 alloy::sol_types::sol_data::Address,
1776 alloy::sol_types::sol_data::Uint<96>,
1777 );
1778 #[doc(hidden)]
1779 type UnderlyingRustTuple<'a> = (
1780 alloy::sol_types::private::Address,
1781 alloy::sol_types::private::primitives::aliases::U96,
1782 );
1783 #[cfg(test)]
1784 #[allow(dead_code, unreachable_patterns)]
1785 fn _type_assertion(
1786 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1787 ) {
1788 match _t {
1789 alloy_sol_types::private::AssertTypeEq::<
1790 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1791 >(_) => {}
1792 }
1793 }
1794 #[automatically_derived]
1795 #[doc(hidden)]
1796 impl ::core::convert::From<StrategyParams> for UnderlyingRustTuple<'_> {
1797 fn from(value: StrategyParams) -> Self {
1798 (value.strategy, value.multiplier)
1799 }
1800 }
1801 #[automatically_derived]
1802 #[doc(hidden)]
1803 impl ::core::convert::From<UnderlyingRustTuple<'_>> for StrategyParams {
1804 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1805 Self {
1806 strategy: tuple.0,
1807 multiplier: tuple.1,
1808 }
1809 }
1810 }
1811 #[automatically_derived]
1812 impl alloy_sol_types::SolValue for StrategyParams {
1813 type SolType = Self;
1814 }
1815 #[automatically_derived]
1816 impl alloy_sol_types::private::SolTypeValue<Self> for StrategyParams {
1817 #[inline]
1818 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1819 (
1820 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1821 &self.strategy,
1822 ),
1823 <alloy::sol_types::sol_data::Uint<
1824 96,
1825 > as alloy_sol_types::SolType>::tokenize(&self.multiplier),
1826 )
1827 }
1828 #[inline]
1829 fn stv_abi_encoded_size(&self) -> usize {
1830 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1831 return size;
1832 }
1833 let tuple = <UnderlyingRustTuple<
1834 '_,
1835 > as ::core::convert::From<Self>>::from(self.clone());
1836 <UnderlyingSolTuple<
1837 '_,
1838 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1839 }
1840 #[inline]
1841 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1842 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1843 }
1844 #[inline]
1845 fn stv_abi_encode_packed_to(
1846 &self,
1847 out: &mut alloy_sol_types::private::Vec<u8>,
1848 ) {
1849 let tuple = <UnderlyingRustTuple<
1850 '_,
1851 > as ::core::convert::From<Self>>::from(self.clone());
1852 <UnderlyingSolTuple<
1853 '_,
1854 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1855 }
1856 #[inline]
1857 fn stv_abi_packed_encoded_size(&self) -> usize {
1858 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1859 return size;
1860 }
1861 let tuple = <UnderlyingRustTuple<
1862 '_,
1863 > as ::core::convert::From<Self>>::from(self.clone());
1864 <UnderlyingSolTuple<
1865 '_,
1866 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1867 }
1868 }
1869 #[automatically_derived]
1870 impl alloy_sol_types::SolType for StrategyParams {
1871 type RustType = Self;
1872 type Token<'a> = <UnderlyingSolTuple<
1873 'a,
1874 > as alloy_sol_types::SolType>::Token<'a>;
1875 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1876 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1877 '_,
1878 > as alloy_sol_types::SolType>::ENCODED_SIZE;
1879 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1880 '_,
1881 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1882 #[inline]
1883 fn valid_token(token: &Self::Token<'_>) -> bool {
1884 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1885 }
1886 #[inline]
1887 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1888 let tuple = <UnderlyingSolTuple<
1889 '_,
1890 > as alloy_sol_types::SolType>::detokenize(token);
1891 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1892 }
1893 }
1894 #[automatically_derived]
1895 impl alloy_sol_types::SolStruct for StrategyParams {
1896 const NAME: &'static str = "StrategyParams";
1897 #[inline]
1898 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1899 alloy_sol_types::private::Cow::Borrowed(
1900 "StrategyParams(address strategy,uint96 multiplier)",
1901 )
1902 }
1903 #[inline]
1904 fn eip712_components() -> alloy_sol_types::private::Vec<
1905 alloy_sol_types::private::Cow<'static, str>,
1906 > {
1907 alloy_sol_types::private::Vec::new()
1908 }
1909 #[inline]
1910 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1911 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1912 }
1913 #[inline]
1914 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1915 [
1916 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1917 &self.strategy,
1918 )
1919 .0,
1920 <alloy::sol_types::sol_data::Uint<
1921 96,
1922 > as alloy_sol_types::SolType>::eip712_data_word(&self.multiplier)
1923 .0,
1924 ]
1925 .concat()
1926 }
1927 }
1928 #[automatically_derived]
1929 impl alloy_sol_types::EventTopic for StrategyParams {
1930 #[inline]
1931 fn topic_preimage_length(rust: &Self::RustType) -> usize {
1932 0usize
1933 + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1934 &rust.strategy,
1935 )
1936 + <alloy::sol_types::sol_data::Uint<
1937 96,
1938 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1939 &rust.multiplier,
1940 )
1941 }
1942 #[inline]
1943 fn encode_topic_preimage(
1944 rust: &Self::RustType,
1945 out: &mut alloy_sol_types::private::Vec<u8>,
1946 ) {
1947 out.reserve(
1948 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1949 );
1950 <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1951 &rust.strategy,
1952 out,
1953 );
1954 <alloy::sol_types::sol_data::Uint<
1955 96,
1956 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1957 &rust.multiplier,
1958 out,
1959 );
1960 }
1961 #[inline]
1962 fn encode_topic(
1963 rust: &Self::RustType,
1964 ) -> alloy_sol_types::abi::token::WordToken {
1965 let mut out = alloy_sol_types::private::Vec::new();
1966 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1967 rust,
1968 &mut out,
1969 );
1970 alloy_sol_types::abi::token::WordToken(
1971 alloy_sol_types::private::keccak256(out),
1972 )
1973 }
1974 }
1975 };
1976 use alloy::contract as alloy_contract;
1977 #[inline]
1981 pub const fn new<
1982 T: alloy_contract::private::Transport + ::core::clone::Clone,
1983 P: alloy_contract::private::Provider<T, N>,
1984 N: alloy_contract::private::Network,
1985 >(
1986 address: alloy_sol_types::private::Address,
1987 provider: P,
1988 ) -> IStakeRegistryTypesInstance<T, P, N> {
1989 IStakeRegistryTypesInstance::<T, P, N>::new(address, provider)
1990 }
1991 #[derive(Clone)]
2003 pub struct IStakeRegistryTypesInstance<T, P, N = alloy_contract::private::Ethereum> {
2004 address: alloy_sol_types::private::Address,
2005 provider: P,
2006 _network_transport: ::core::marker::PhantomData<(N, T)>,
2007 }
2008 #[automatically_derived]
2009 impl<T, P, N> ::core::fmt::Debug for IStakeRegistryTypesInstance<T, P, N> {
2010 #[inline]
2011 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2012 f.debug_tuple("IStakeRegistryTypesInstance").field(&self.address).finish()
2013 }
2014 }
2015 #[automatically_derived]
2017 impl<
2018 T: alloy_contract::private::Transport + ::core::clone::Clone,
2019 P: alloy_contract::private::Provider<T, N>,
2020 N: alloy_contract::private::Network,
2021 > IStakeRegistryTypesInstance<T, P, N> {
2022 #[inline]
2026 pub const fn new(
2027 address: alloy_sol_types::private::Address,
2028 provider: P,
2029 ) -> Self {
2030 Self {
2031 address,
2032 provider,
2033 _network_transport: ::core::marker::PhantomData,
2034 }
2035 }
2036 #[inline]
2038 pub const fn address(&self) -> &alloy_sol_types::private::Address {
2039 &self.address
2040 }
2041 #[inline]
2043 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
2044 self.address = address;
2045 }
2046 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
2048 self.set_address(address);
2049 self
2050 }
2051 #[inline]
2053 pub const fn provider(&self) -> &P {
2054 &self.provider
2055 }
2056 }
2057 impl<T, P: ::core::clone::Clone, N> IStakeRegistryTypesInstance<T, &P, N> {
2058 #[inline]
2060 pub fn with_cloned_provider(self) -> IStakeRegistryTypesInstance<T, P, N> {
2061 IStakeRegistryTypesInstance {
2062 address: self.address,
2063 provider: ::core::clone::Clone::clone(&self.provider),
2064 _network_transport: ::core::marker::PhantomData,
2065 }
2066 }
2067 }
2068 #[automatically_derived]
2070 impl<
2071 T: alloy_contract::private::Transport + ::core::clone::Clone,
2072 P: alloy_contract::private::Provider<T, N>,
2073 N: alloy_contract::private::Network,
2074 > IStakeRegistryTypesInstance<T, P, N> {
2075 pub fn call_builder<C: alloy_sol_types::SolCall>(
2080 &self,
2081 call: &C,
2082 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
2083 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
2084 }
2085 }
2086 #[automatically_derived]
2088 impl<
2089 T: alloy_contract::private::Transport + ::core::clone::Clone,
2090 P: alloy_contract::private::Provider<T, N>,
2091 N: alloy_contract::private::Network,
2092 > IStakeRegistryTypesInstance<T, P, N> {
2093 pub fn event_filter<E: alloy_sol_types::SolEvent>(
2098 &self,
2099 ) -> alloy_contract::Event<T, &P, E, N> {
2100 alloy_contract::Event::new_sol(&self.provider, &self.address)
2101 }
2102 }
2103}
2104#[allow(
3499 non_camel_case_types,
3500 non_snake_case,
3501 clippy::pub_underscore_fields,
3502 clippy::style,
3503 clippy::empty_structs_with_brackets
3504)]
3505pub mod ISlashingRegistryCoordinator {
3506 use super::*;
3507 use alloy::sol_types as alloy_sol_types;
3508 #[rustfmt::skip]
3514 #[allow(clippy::all)]
3515 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
3516 b"",
3517 );
3518 #[rustfmt::skip]
3524 #[allow(clippy::all)]
3525 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
3526 b"",
3527 );
3528 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3529 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3534 #[derive(Clone)]
3535 pub struct AlreadyRegisteredForQuorums {}
3536 #[allow(
3537 non_camel_case_types,
3538 non_snake_case,
3539 clippy::pub_underscore_fields,
3540 clippy::style
3541 )]
3542 const _: () = {
3543 use alloy::sol_types as alloy_sol_types;
3544 #[doc(hidden)]
3545 type UnderlyingSolTuple<'a> = ();
3546 #[doc(hidden)]
3547 type UnderlyingRustTuple<'a> = ();
3548 #[cfg(test)]
3549 #[allow(dead_code, unreachable_patterns)]
3550 fn _type_assertion(
3551 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3552 ) {
3553 match _t {
3554 alloy_sol_types::private::AssertTypeEq::<
3555 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3556 >(_) => {}
3557 }
3558 }
3559 #[automatically_derived]
3560 #[doc(hidden)]
3561 impl ::core::convert::From<AlreadyRegisteredForQuorums>
3562 for UnderlyingRustTuple<'_> {
3563 fn from(value: AlreadyRegisteredForQuorums) -> Self {
3564 ()
3565 }
3566 }
3567 #[automatically_derived]
3568 #[doc(hidden)]
3569 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3570 for AlreadyRegisteredForQuorums {
3571 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3572 Self {}
3573 }
3574 }
3575 #[automatically_derived]
3576 impl alloy_sol_types::SolError for AlreadyRegisteredForQuorums {
3577 type Parameters<'a> = UnderlyingSolTuple<'a>;
3578 type Token<'a> = <Self::Parameters<
3579 'a,
3580 > as alloy_sol_types::SolType>::Token<'a>;
3581 const SIGNATURE: &'static str = "AlreadyRegisteredForQuorums()";
3582 const SELECTOR: [u8; 4] = [12u8, 104u8, 22u8, 205u8];
3583 #[inline]
3584 fn new<'a>(
3585 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3586 ) -> Self {
3587 tuple.into()
3588 }
3589 #[inline]
3590 fn tokenize(&self) -> Self::Token<'_> {
3591 ()
3592 }
3593 }
3594 };
3595 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3596 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3601 #[derive(Clone)]
3602 pub struct BitmapCannotBeZero {}
3603 #[allow(
3604 non_camel_case_types,
3605 non_snake_case,
3606 clippy::pub_underscore_fields,
3607 clippy::style
3608 )]
3609 const _: () = {
3610 use alloy::sol_types as alloy_sol_types;
3611 #[doc(hidden)]
3612 type UnderlyingSolTuple<'a> = ();
3613 #[doc(hidden)]
3614 type UnderlyingRustTuple<'a> = ();
3615 #[cfg(test)]
3616 #[allow(dead_code, unreachable_patterns)]
3617 fn _type_assertion(
3618 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3619 ) {
3620 match _t {
3621 alloy_sol_types::private::AssertTypeEq::<
3622 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3623 >(_) => {}
3624 }
3625 }
3626 #[automatically_derived]
3627 #[doc(hidden)]
3628 impl ::core::convert::From<BitmapCannotBeZero> for UnderlyingRustTuple<'_> {
3629 fn from(value: BitmapCannotBeZero) -> Self {
3630 ()
3631 }
3632 }
3633 #[automatically_derived]
3634 #[doc(hidden)]
3635 impl ::core::convert::From<UnderlyingRustTuple<'_>> for BitmapCannotBeZero {
3636 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3637 Self {}
3638 }
3639 }
3640 #[automatically_derived]
3641 impl alloy_sol_types::SolError for BitmapCannotBeZero {
3642 type Parameters<'a> = UnderlyingSolTuple<'a>;
3643 type Token<'a> = <Self::Parameters<
3644 'a,
3645 > as alloy_sol_types::SolType>::Token<'a>;
3646 const SIGNATURE: &'static str = "BitmapCannotBeZero()";
3647 const SELECTOR: [u8; 4] = [209u8, 109u8, 80u8, 234u8];
3648 #[inline]
3649 fn new<'a>(
3650 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3651 ) -> Self {
3652 tuple.into()
3653 }
3654 #[inline]
3655 fn tokenize(&self) -> Self::Token<'_> {
3656 ()
3657 }
3658 }
3659 };
3660 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3661 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3666 #[derive(Clone)]
3667 pub struct BitmapEmpty {}
3668 #[allow(
3669 non_camel_case_types,
3670 non_snake_case,
3671 clippy::pub_underscore_fields,
3672 clippy::style
3673 )]
3674 const _: () = {
3675 use alloy::sol_types as alloy_sol_types;
3676 #[doc(hidden)]
3677 type UnderlyingSolTuple<'a> = ();
3678 #[doc(hidden)]
3679 type UnderlyingRustTuple<'a> = ();
3680 #[cfg(test)]
3681 #[allow(dead_code, unreachable_patterns)]
3682 fn _type_assertion(
3683 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3684 ) {
3685 match _t {
3686 alloy_sol_types::private::AssertTypeEq::<
3687 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3688 >(_) => {}
3689 }
3690 }
3691 #[automatically_derived]
3692 #[doc(hidden)]
3693 impl ::core::convert::From<BitmapEmpty> for UnderlyingRustTuple<'_> {
3694 fn from(value: BitmapEmpty) -> Self {
3695 ()
3696 }
3697 }
3698 #[automatically_derived]
3699 #[doc(hidden)]
3700 impl ::core::convert::From<UnderlyingRustTuple<'_>> for BitmapEmpty {
3701 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3702 Self {}
3703 }
3704 }
3705 #[automatically_derived]
3706 impl alloy_sol_types::SolError for BitmapEmpty {
3707 type Parameters<'a> = UnderlyingSolTuple<'a>;
3708 type Token<'a> = <Self::Parameters<
3709 'a,
3710 > as alloy_sol_types::SolType>::Token<'a>;
3711 const SIGNATURE: &'static str = "BitmapEmpty()";
3712 const SELECTOR: [u8; 4] = [19u8, 202u8, 70u8, 87u8];
3713 #[inline]
3714 fn new<'a>(
3715 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3716 ) -> Self {
3717 tuple.into()
3718 }
3719 #[inline]
3720 fn tokenize(&self) -> Self::Token<'_> {
3721 ()
3722 }
3723 }
3724 };
3725 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3726 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3731 #[derive(Clone)]
3732 pub struct CannotChurnSelf {}
3733 #[allow(
3734 non_camel_case_types,
3735 non_snake_case,
3736 clippy::pub_underscore_fields,
3737 clippy::style
3738 )]
3739 const _: () = {
3740 use alloy::sol_types as alloy_sol_types;
3741 #[doc(hidden)]
3742 type UnderlyingSolTuple<'a> = ();
3743 #[doc(hidden)]
3744 type UnderlyingRustTuple<'a> = ();
3745 #[cfg(test)]
3746 #[allow(dead_code, unreachable_patterns)]
3747 fn _type_assertion(
3748 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3749 ) {
3750 match _t {
3751 alloy_sol_types::private::AssertTypeEq::<
3752 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3753 >(_) => {}
3754 }
3755 }
3756 #[automatically_derived]
3757 #[doc(hidden)]
3758 impl ::core::convert::From<CannotChurnSelf> for UnderlyingRustTuple<'_> {
3759 fn from(value: CannotChurnSelf) -> Self {
3760 ()
3761 }
3762 }
3763 #[automatically_derived]
3764 #[doc(hidden)]
3765 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CannotChurnSelf {
3766 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3767 Self {}
3768 }
3769 }
3770 #[automatically_derived]
3771 impl alloy_sol_types::SolError for CannotChurnSelf {
3772 type Parameters<'a> = UnderlyingSolTuple<'a>;
3773 type Token<'a> = <Self::Parameters<
3774 'a,
3775 > as alloy_sol_types::SolType>::Token<'a>;
3776 const SIGNATURE: &'static str = "CannotChurnSelf()";
3777 const SELECTOR: [u8; 4] = [172u8, 45u8, 22u8, 130u8];
3778 #[inline]
3779 fn new<'a>(
3780 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3781 ) -> Self {
3782 tuple.into()
3783 }
3784 #[inline]
3785 fn tokenize(&self) -> Self::Token<'_> {
3786 ()
3787 }
3788 }
3789 };
3790 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3791 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3796 #[derive(Clone)]
3797 pub struct CannotKickOperatorAboveThreshold {}
3798 #[allow(
3799 non_camel_case_types,
3800 non_snake_case,
3801 clippy::pub_underscore_fields,
3802 clippy::style
3803 )]
3804 const _: () = {
3805 use alloy::sol_types as alloy_sol_types;
3806 #[doc(hidden)]
3807 type UnderlyingSolTuple<'a> = ();
3808 #[doc(hidden)]
3809 type UnderlyingRustTuple<'a> = ();
3810 #[cfg(test)]
3811 #[allow(dead_code, unreachable_patterns)]
3812 fn _type_assertion(
3813 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3814 ) {
3815 match _t {
3816 alloy_sol_types::private::AssertTypeEq::<
3817 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3818 >(_) => {}
3819 }
3820 }
3821 #[automatically_derived]
3822 #[doc(hidden)]
3823 impl ::core::convert::From<CannotKickOperatorAboveThreshold>
3824 for UnderlyingRustTuple<'_> {
3825 fn from(value: CannotKickOperatorAboveThreshold) -> Self {
3826 ()
3827 }
3828 }
3829 #[automatically_derived]
3830 #[doc(hidden)]
3831 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3832 for CannotKickOperatorAboveThreshold {
3833 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3834 Self {}
3835 }
3836 }
3837 #[automatically_derived]
3838 impl alloy_sol_types::SolError for CannotKickOperatorAboveThreshold {
3839 type Parameters<'a> = UnderlyingSolTuple<'a>;
3840 type Token<'a> = <Self::Parameters<
3841 'a,
3842 > as alloy_sol_types::SolType>::Token<'a>;
3843 const SIGNATURE: &'static str = "CannotKickOperatorAboveThreshold()";
3844 const SELECTOR: [u8; 4] = [177u8, 135u8, 232u8, 105u8];
3845 #[inline]
3846 fn new<'a>(
3847 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3848 ) -> Self {
3849 tuple.into()
3850 }
3851 #[inline]
3852 fn tokenize(&self) -> Self::Token<'_> {
3853 ()
3854 }
3855 }
3856 };
3857 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3858 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3863 #[derive(Clone)]
3864 pub struct CannotReregisterYet {}
3865 #[allow(
3866 non_camel_case_types,
3867 non_snake_case,
3868 clippy::pub_underscore_fields,
3869 clippy::style
3870 )]
3871 const _: () = {
3872 use alloy::sol_types as alloy_sol_types;
3873 #[doc(hidden)]
3874 type UnderlyingSolTuple<'a> = ();
3875 #[doc(hidden)]
3876 type UnderlyingRustTuple<'a> = ();
3877 #[cfg(test)]
3878 #[allow(dead_code, unreachable_patterns)]
3879 fn _type_assertion(
3880 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3881 ) {
3882 match _t {
3883 alloy_sol_types::private::AssertTypeEq::<
3884 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3885 >(_) => {}
3886 }
3887 }
3888 #[automatically_derived]
3889 #[doc(hidden)]
3890 impl ::core::convert::From<CannotReregisterYet> for UnderlyingRustTuple<'_> {
3891 fn from(value: CannotReregisterYet) -> Self {
3892 ()
3893 }
3894 }
3895 #[automatically_derived]
3896 #[doc(hidden)]
3897 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CannotReregisterYet {
3898 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3899 Self {}
3900 }
3901 }
3902 #[automatically_derived]
3903 impl alloy_sol_types::SolError for CannotReregisterYet {
3904 type Parameters<'a> = UnderlyingSolTuple<'a>;
3905 type Token<'a> = <Self::Parameters<
3906 'a,
3907 > as alloy_sol_types::SolType>::Token<'a>;
3908 const SIGNATURE: &'static str = "CannotReregisterYet()";
3909 const SELECTOR: [u8; 4] = [50u8, 208u8, 206u8, 250u8];
3910 #[inline]
3911 fn new<'a>(
3912 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3913 ) -> Self {
3914 tuple.into()
3915 }
3916 #[inline]
3917 fn tokenize(&self) -> Self::Token<'_> {
3918 ()
3919 }
3920 }
3921 };
3922 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3923 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3928 #[derive(Clone)]
3929 pub struct ChurnApproverSaltUsed {}
3930 #[allow(
3931 non_camel_case_types,
3932 non_snake_case,
3933 clippy::pub_underscore_fields,
3934 clippy::style
3935 )]
3936 const _: () = {
3937 use alloy::sol_types as alloy_sol_types;
3938 #[doc(hidden)]
3939 type UnderlyingSolTuple<'a> = ();
3940 #[doc(hidden)]
3941 type UnderlyingRustTuple<'a> = ();
3942 #[cfg(test)]
3943 #[allow(dead_code, unreachable_patterns)]
3944 fn _type_assertion(
3945 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3946 ) {
3947 match _t {
3948 alloy_sol_types::private::AssertTypeEq::<
3949 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3950 >(_) => {}
3951 }
3952 }
3953 #[automatically_derived]
3954 #[doc(hidden)]
3955 impl ::core::convert::From<ChurnApproverSaltUsed> for UnderlyingRustTuple<'_> {
3956 fn from(value: ChurnApproverSaltUsed) -> Self {
3957 ()
3958 }
3959 }
3960 #[automatically_derived]
3961 #[doc(hidden)]
3962 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ChurnApproverSaltUsed {
3963 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3964 Self {}
3965 }
3966 }
3967 #[automatically_derived]
3968 impl alloy_sol_types::SolError for ChurnApproverSaltUsed {
3969 type Parameters<'a> = UnderlyingSolTuple<'a>;
3970 type Token<'a> = <Self::Parameters<
3971 'a,
3972 > as alloy_sol_types::SolType>::Token<'a>;
3973 const SIGNATURE: &'static str = "ChurnApproverSaltUsed()";
3974 const SELECTOR: [u8; 4] = [223u8, 125u8, 253u8, 134u8];
3975 #[inline]
3976 fn new<'a>(
3977 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3978 ) -> Self {
3979 tuple.into()
3980 }
3981 #[inline]
3982 fn tokenize(&self) -> Self::Token<'_> {
3983 ()
3984 }
3985 }
3986 };
3987 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3988 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3993 #[derive(Clone)]
3994 pub struct InputLengthMismatch {}
3995 #[allow(
3996 non_camel_case_types,
3997 non_snake_case,
3998 clippy::pub_underscore_fields,
3999 clippy::style
4000 )]
4001 const _: () = {
4002 use alloy::sol_types as alloy_sol_types;
4003 #[doc(hidden)]
4004 type UnderlyingSolTuple<'a> = ();
4005 #[doc(hidden)]
4006 type UnderlyingRustTuple<'a> = ();
4007 #[cfg(test)]
4008 #[allow(dead_code, unreachable_patterns)]
4009 fn _type_assertion(
4010 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4011 ) {
4012 match _t {
4013 alloy_sol_types::private::AssertTypeEq::<
4014 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4015 >(_) => {}
4016 }
4017 }
4018 #[automatically_derived]
4019 #[doc(hidden)]
4020 impl ::core::convert::From<InputLengthMismatch> for UnderlyingRustTuple<'_> {
4021 fn from(value: InputLengthMismatch) -> Self {
4022 ()
4023 }
4024 }
4025 #[automatically_derived]
4026 #[doc(hidden)]
4027 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputLengthMismatch {
4028 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4029 Self {}
4030 }
4031 }
4032 #[automatically_derived]
4033 impl alloy_sol_types::SolError for InputLengthMismatch {
4034 type Parameters<'a> = UnderlyingSolTuple<'a>;
4035 type Token<'a> = <Self::Parameters<
4036 'a,
4037 > as alloy_sol_types::SolType>::Token<'a>;
4038 const SIGNATURE: &'static str = "InputLengthMismatch()";
4039 const SELECTOR: [u8; 4] = [170u8, 173u8, 19u8, 247u8];
4040 #[inline]
4041 fn new<'a>(
4042 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4043 ) -> Self {
4044 tuple.into()
4045 }
4046 #[inline]
4047 fn tokenize(&self) -> Self::Token<'_> {
4048 ()
4049 }
4050 }
4051 };
4052 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4053 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4058 #[derive(Clone)]
4059 pub struct InsufficientStakeForChurn {}
4060 #[allow(
4061 non_camel_case_types,
4062 non_snake_case,
4063 clippy::pub_underscore_fields,
4064 clippy::style
4065 )]
4066 const _: () = {
4067 use alloy::sol_types as alloy_sol_types;
4068 #[doc(hidden)]
4069 type UnderlyingSolTuple<'a> = ();
4070 #[doc(hidden)]
4071 type UnderlyingRustTuple<'a> = ();
4072 #[cfg(test)]
4073 #[allow(dead_code, unreachable_patterns)]
4074 fn _type_assertion(
4075 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4076 ) {
4077 match _t {
4078 alloy_sol_types::private::AssertTypeEq::<
4079 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4080 >(_) => {}
4081 }
4082 }
4083 #[automatically_derived]
4084 #[doc(hidden)]
4085 impl ::core::convert::From<InsufficientStakeForChurn>
4086 for UnderlyingRustTuple<'_> {
4087 fn from(value: InsufficientStakeForChurn) -> Self {
4088 ()
4089 }
4090 }
4091 #[automatically_derived]
4092 #[doc(hidden)]
4093 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4094 for InsufficientStakeForChurn {
4095 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4096 Self {}
4097 }
4098 }
4099 #[automatically_derived]
4100 impl alloy_sol_types::SolError for InsufficientStakeForChurn {
4101 type Parameters<'a> = UnderlyingSolTuple<'a>;
4102 type Token<'a> = <Self::Parameters<
4103 'a,
4104 > as alloy_sol_types::SolType>::Token<'a>;
4105 const SIGNATURE: &'static str = "InsufficientStakeForChurn()";
4106 const SELECTOR: [u8; 4] = [76u8, 68u8, 153u8, 93u8];
4107 #[inline]
4108 fn new<'a>(
4109 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4110 ) -> Self {
4111 tuple.into()
4112 }
4113 #[inline]
4114 fn tokenize(&self) -> Self::Token<'_> {
4115 ()
4116 }
4117 }
4118 };
4119 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4120 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4125 #[derive(Clone)]
4126 pub struct InvalidAVS {}
4127 #[allow(
4128 non_camel_case_types,
4129 non_snake_case,
4130 clippy::pub_underscore_fields,
4131 clippy::style
4132 )]
4133 const _: () = {
4134 use alloy::sol_types as alloy_sol_types;
4135 #[doc(hidden)]
4136 type UnderlyingSolTuple<'a> = ();
4137 #[doc(hidden)]
4138 type UnderlyingRustTuple<'a> = ();
4139 #[cfg(test)]
4140 #[allow(dead_code, unreachable_patterns)]
4141 fn _type_assertion(
4142 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4143 ) {
4144 match _t {
4145 alloy_sol_types::private::AssertTypeEq::<
4146 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4147 >(_) => {}
4148 }
4149 }
4150 #[automatically_derived]
4151 #[doc(hidden)]
4152 impl ::core::convert::From<InvalidAVS> for UnderlyingRustTuple<'_> {
4153 fn from(value: InvalidAVS) -> Self {
4154 ()
4155 }
4156 }
4157 #[automatically_derived]
4158 #[doc(hidden)]
4159 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAVS {
4160 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4161 Self {}
4162 }
4163 }
4164 #[automatically_derived]
4165 impl alloy_sol_types::SolError for InvalidAVS {
4166 type Parameters<'a> = UnderlyingSolTuple<'a>;
4167 type Token<'a> = <Self::Parameters<
4168 'a,
4169 > as alloy_sol_types::SolType>::Token<'a>;
4170 const SIGNATURE: &'static str = "InvalidAVS()";
4171 const SELECTOR: [u8; 4] = [102u8, 229u8, 101u8, 223u8];
4172 #[inline]
4173 fn new<'a>(
4174 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4175 ) -> Self {
4176 tuple.into()
4177 }
4178 #[inline]
4179 fn tokenize(&self) -> Self::Token<'_> {
4180 ()
4181 }
4182 }
4183 };
4184 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4185 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4190 #[derive(Clone)]
4191 pub struct InvalidRegistrationType {}
4192 #[allow(
4193 non_camel_case_types,
4194 non_snake_case,
4195 clippy::pub_underscore_fields,
4196 clippy::style
4197 )]
4198 const _: () = {
4199 use alloy::sol_types as alloy_sol_types;
4200 #[doc(hidden)]
4201 type UnderlyingSolTuple<'a> = ();
4202 #[doc(hidden)]
4203 type UnderlyingRustTuple<'a> = ();
4204 #[cfg(test)]
4205 #[allow(dead_code, unreachable_patterns)]
4206 fn _type_assertion(
4207 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4208 ) {
4209 match _t {
4210 alloy_sol_types::private::AssertTypeEq::<
4211 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4212 >(_) => {}
4213 }
4214 }
4215 #[automatically_derived]
4216 #[doc(hidden)]
4217 impl ::core::convert::From<InvalidRegistrationType> for UnderlyingRustTuple<'_> {
4218 fn from(value: InvalidRegistrationType) -> Self {
4219 ()
4220 }
4221 }
4222 #[automatically_derived]
4223 #[doc(hidden)]
4224 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidRegistrationType {
4225 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4226 Self {}
4227 }
4228 }
4229 #[automatically_derived]
4230 impl alloy_sol_types::SolError for InvalidRegistrationType {
4231 type Parameters<'a> = UnderlyingSolTuple<'a>;
4232 type Token<'a> = <Self::Parameters<
4233 'a,
4234 > as alloy_sol_types::SolType>::Token<'a>;
4235 const SIGNATURE: &'static str = "InvalidRegistrationType()";
4236 const SELECTOR: [u8; 4] = [53u8, 75u8, 184u8, 171u8];
4237 #[inline]
4238 fn new<'a>(
4239 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4240 ) -> Self {
4241 tuple.into()
4242 }
4243 #[inline]
4244 fn tokenize(&self) -> Self::Token<'_> {
4245 ()
4246 }
4247 }
4248 };
4249 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4250 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4255 #[derive(Clone)]
4256 pub struct LookAheadPeriodTooLong {}
4257 #[allow(
4258 non_camel_case_types,
4259 non_snake_case,
4260 clippy::pub_underscore_fields,
4261 clippy::style
4262 )]
4263 const _: () = {
4264 use alloy::sol_types as alloy_sol_types;
4265 #[doc(hidden)]
4266 type UnderlyingSolTuple<'a> = ();
4267 #[doc(hidden)]
4268 type UnderlyingRustTuple<'a> = ();
4269 #[cfg(test)]
4270 #[allow(dead_code, unreachable_patterns)]
4271 fn _type_assertion(
4272 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4273 ) {
4274 match _t {
4275 alloy_sol_types::private::AssertTypeEq::<
4276 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4277 >(_) => {}
4278 }
4279 }
4280 #[automatically_derived]
4281 #[doc(hidden)]
4282 impl ::core::convert::From<LookAheadPeriodTooLong> for UnderlyingRustTuple<'_> {
4283 fn from(value: LookAheadPeriodTooLong) -> Self {
4284 ()
4285 }
4286 }
4287 #[automatically_derived]
4288 #[doc(hidden)]
4289 impl ::core::convert::From<UnderlyingRustTuple<'_>> for LookAheadPeriodTooLong {
4290 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4291 Self {}
4292 }
4293 }
4294 #[automatically_derived]
4295 impl alloy_sol_types::SolError for LookAheadPeriodTooLong {
4296 type Parameters<'a> = UnderlyingSolTuple<'a>;
4297 type Token<'a> = <Self::Parameters<
4298 'a,
4299 > as alloy_sol_types::SolType>::Token<'a>;
4300 const SIGNATURE: &'static str = "LookAheadPeriodTooLong()";
4301 const SELECTOR: [u8; 4] = [47u8, 81u8, 6u8, 228u8];
4302 #[inline]
4303 fn new<'a>(
4304 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4305 ) -> Self {
4306 tuple.into()
4307 }
4308 #[inline]
4309 fn tokenize(&self) -> Self::Token<'_> {
4310 ()
4311 }
4312 }
4313 };
4314 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4315 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4320 #[derive(Clone)]
4321 pub struct MaxOperatorCountReached {}
4322 #[allow(
4323 non_camel_case_types,
4324 non_snake_case,
4325 clippy::pub_underscore_fields,
4326 clippy::style
4327 )]
4328 const _: () = {
4329 use alloy::sol_types as alloy_sol_types;
4330 #[doc(hidden)]
4331 type UnderlyingSolTuple<'a> = ();
4332 #[doc(hidden)]
4333 type UnderlyingRustTuple<'a> = ();
4334 #[cfg(test)]
4335 #[allow(dead_code, unreachable_patterns)]
4336 fn _type_assertion(
4337 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4338 ) {
4339 match _t {
4340 alloy_sol_types::private::AssertTypeEq::<
4341 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4342 >(_) => {}
4343 }
4344 }
4345 #[automatically_derived]
4346 #[doc(hidden)]
4347 impl ::core::convert::From<MaxOperatorCountReached> for UnderlyingRustTuple<'_> {
4348 fn from(value: MaxOperatorCountReached) -> Self {
4349 ()
4350 }
4351 }
4352 #[automatically_derived]
4353 #[doc(hidden)]
4354 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MaxOperatorCountReached {
4355 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4356 Self {}
4357 }
4358 }
4359 #[automatically_derived]
4360 impl alloy_sol_types::SolError for MaxOperatorCountReached {
4361 type Parameters<'a> = UnderlyingSolTuple<'a>;
4362 type Token<'a> = <Self::Parameters<
4363 'a,
4364 > as alloy_sol_types::SolType>::Token<'a>;
4365 const SIGNATURE: &'static str = "MaxOperatorCountReached()";
4366 const SELECTOR: [u8; 4] = [198u8, 185u8, 231u8, 103u8];
4367 #[inline]
4368 fn new<'a>(
4369 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4370 ) -> Self {
4371 tuple.into()
4372 }
4373 #[inline]
4374 fn tokenize(&self) -> Self::Token<'_> {
4375 ()
4376 }
4377 }
4378 };
4379 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4380 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4385 #[derive(Clone)]
4386 pub struct MaxQuorumsReached {}
4387 #[allow(
4388 non_camel_case_types,
4389 non_snake_case,
4390 clippy::pub_underscore_fields,
4391 clippy::style
4392 )]
4393 const _: () = {
4394 use alloy::sol_types as alloy_sol_types;
4395 #[doc(hidden)]
4396 type UnderlyingSolTuple<'a> = ();
4397 #[doc(hidden)]
4398 type UnderlyingRustTuple<'a> = ();
4399 #[cfg(test)]
4400 #[allow(dead_code, unreachable_patterns)]
4401 fn _type_assertion(
4402 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4403 ) {
4404 match _t {
4405 alloy_sol_types::private::AssertTypeEq::<
4406 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4407 >(_) => {}
4408 }
4409 }
4410 #[automatically_derived]
4411 #[doc(hidden)]
4412 impl ::core::convert::From<MaxQuorumsReached> for UnderlyingRustTuple<'_> {
4413 fn from(value: MaxQuorumsReached) -> Self {
4414 ()
4415 }
4416 }
4417 #[automatically_derived]
4418 #[doc(hidden)]
4419 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MaxQuorumsReached {
4420 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4421 Self {}
4422 }
4423 }
4424 #[automatically_derived]
4425 impl alloy_sol_types::SolError for MaxQuorumsReached {
4426 type Parameters<'a> = UnderlyingSolTuple<'a>;
4427 type Token<'a> = <Self::Parameters<
4428 'a,
4429 > as alloy_sol_types::SolType>::Token<'a>;
4430 const SIGNATURE: &'static str = "MaxQuorumsReached()";
4431 const SELECTOR: [u8; 4] = [60u8, 184u8, 156u8, 151u8];
4432 #[inline]
4433 fn new<'a>(
4434 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4435 ) -> Self {
4436 tuple.into()
4437 }
4438 #[inline]
4439 fn tokenize(&self) -> Self::Token<'_> {
4440 ()
4441 }
4442 }
4443 };
4444 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4445 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4450 #[derive(Clone)]
4451 pub struct NotRegistered {}
4452 #[allow(
4453 non_camel_case_types,
4454 non_snake_case,
4455 clippy::pub_underscore_fields,
4456 clippy::style
4457 )]
4458 const _: () = {
4459 use alloy::sol_types as alloy_sol_types;
4460 #[doc(hidden)]
4461 type UnderlyingSolTuple<'a> = ();
4462 #[doc(hidden)]
4463 type UnderlyingRustTuple<'a> = ();
4464 #[cfg(test)]
4465 #[allow(dead_code, unreachable_patterns)]
4466 fn _type_assertion(
4467 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4468 ) {
4469 match _t {
4470 alloy_sol_types::private::AssertTypeEq::<
4471 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4472 >(_) => {}
4473 }
4474 }
4475 #[automatically_derived]
4476 #[doc(hidden)]
4477 impl ::core::convert::From<NotRegistered> for UnderlyingRustTuple<'_> {
4478 fn from(value: NotRegistered) -> Self {
4479 ()
4480 }
4481 }
4482 #[automatically_derived]
4483 #[doc(hidden)]
4484 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotRegistered {
4485 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4486 Self {}
4487 }
4488 }
4489 #[automatically_derived]
4490 impl alloy_sol_types::SolError for NotRegistered {
4491 type Parameters<'a> = UnderlyingSolTuple<'a>;
4492 type Token<'a> = <Self::Parameters<
4493 'a,
4494 > as alloy_sol_types::SolType>::Token<'a>;
4495 const SIGNATURE: &'static str = "NotRegistered()";
4496 const SELECTOR: [u8; 4] = [171u8, 164u8, 115u8, 57u8];
4497 #[inline]
4498 fn new<'a>(
4499 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4500 ) -> Self {
4501 tuple.into()
4502 }
4503 #[inline]
4504 fn tokenize(&self) -> Self::Token<'_> {
4505 ()
4506 }
4507 }
4508 };
4509 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4510 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4515 #[derive(Clone)]
4516 pub struct NotRegisteredForQuorum {}
4517 #[allow(
4518 non_camel_case_types,
4519 non_snake_case,
4520 clippy::pub_underscore_fields,
4521 clippy::style
4522 )]
4523 const _: () = {
4524 use alloy::sol_types as alloy_sol_types;
4525 #[doc(hidden)]
4526 type UnderlyingSolTuple<'a> = ();
4527 #[doc(hidden)]
4528 type UnderlyingRustTuple<'a> = ();
4529 #[cfg(test)]
4530 #[allow(dead_code, unreachable_patterns)]
4531 fn _type_assertion(
4532 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4533 ) {
4534 match _t {
4535 alloy_sol_types::private::AssertTypeEq::<
4536 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4537 >(_) => {}
4538 }
4539 }
4540 #[automatically_derived]
4541 #[doc(hidden)]
4542 impl ::core::convert::From<NotRegisteredForQuorum> for UnderlyingRustTuple<'_> {
4543 fn from(value: NotRegisteredForQuorum) -> Self {
4544 ()
4545 }
4546 }
4547 #[automatically_derived]
4548 #[doc(hidden)]
4549 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotRegisteredForQuorum {
4550 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4551 Self {}
4552 }
4553 }
4554 #[automatically_derived]
4555 impl alloy_sol_types::SolError for NotRegisteredForQuorum {
4556 type Parameters<'a> = UnderlyingSolTuple<'a>;
4557 type Token<'a> = <Self::Parameters<
4558 'a,
4559 > as alloy_sol_types::SolType>::Token<'a>;
4560 const SIGNATURE: &'static str = "NotRegisteredForQuorum()";
4561 const SELECTOR: [u8; 4] = [208u8, 83u8, 170u8, 33u8];
4562 #[inline]
4563 fn new<'a>(
4564 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4565 ) -> Self {
4566 tuple.into()
4567 }
4568 #[inline]
4569 fn tokenize(&self) -> Self::Token<'_> {
4570 ()
4571 }
4572 }
4573 };
4574 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4575 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4580 #[derive(Clone)]
4581 pub struct NotSorted {}
4582 #[allow(
4583 non_camel_case_types,
4584 non_snake_case,
4585 clippy::pub_underscore_fields,
4586 clippy::style
4587 )]
4588 const _: () = {
4589 use alloy::sol_types as alloy_sol_types;
4590 #[doc(hidden)]
4591 type UnderlyingSolTuple<'a> = ();
4592 #[doc(hidden)]
4593 type UnderlyingRustTuple<'a> = ();
4594 #[cfg(test)]
4595 #[allow(dead_code, unreachable_patterns)]
4596 fn _type_assertion(
4597 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4598 ) {
4599 match _t {
4600 alloy_sol_types::private::AssertTypeEq::<
4601 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4602 >(_) => {}
4603 }
4604 }
4605 #[automatically_derived]
4606 #[doc(hidden)]
4607 impl ::core::convert::From<NotSorted> for UnderlyingRustTuple<'_> {
4608 fn from(value: NotSorted) -> Self {
4609 ()
4610 }
4611 }
4612 #[automatically_derived]
4613 #[doc(hidden)]
4614 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotSorted {
4615 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4616 Self {}
4617 }
4618 }
4619 #[automatically_derived]
4620 impl alloy_sol_types::SolError for NotSorted {
4621 type Parameters<'a> = UnderlyingSolTuple<'a>;
4622 type Token<'a> = <Self::Parameters<
4623 'a,
4624 > as alloy_sol_types::SolType>::Token<'a>;
4625 const SIGNATURE: &'static str = "NotSorted()";
4626 const SELECTOR: [u8; 4] = [186u8, 80u8, 249u8, 17u8];
4627 #[inline]
4628 fn new<'a>(
4629 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4630 ) -> Self {
4631 tuple.into()
4632 }
4633 #[inline]
4634 fn tokenize(&self) -> Self::Token<'_> {
4635 ()
4636 }
4637 }
4638 };
4639 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4640 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4645 #[derive(Clone)]
4646 pub struct OnlyAllocationManager {}
4647 #[allow(
4648 non_camel_case_types,
4649 non_snake_case,
4650 clippy::pub_underscore_fields,
4651 clippy::style
4652 )]
4653 const _: () = {
4654 use alloy::sol_types as alloy_sol_types;
4655 #[doc(hidden)]
4656 type UnderlyingSolTuple<'a> = ();
4657 #[doc(hidden)]
4658 type UnderlyingRustTuple<'a> = ();
4659 #[cfg(test)]
4660 #[allow(dead_code, unreachable_patterns)]
4661 fn _type_assertion(
4662 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4663 ) {
4664 match _t {
4665 alloy_sol_types::private::AssertTypeEq::<
4666 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4667 >(_) => {}
4668 }
4669 }
4670 #[automatically_derived]
4671 #[doc(hidden)]
4672 impl ::core::convert::From<OnlyAllocationManager> for UnderlyingRustTuple<'_> {
4673 fn from(value: OnlyAllocationManager) -> Self {
4674 ()
4675 }
4676 }
4677 #[automatically_derived]
4678 #[doc(hidden)]
4679 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyAllocationManager {
4680 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4681 Self {}
4682 }
4683 }
4684 #[automatically_derived]
4685 impl alloy_sol_types::SolError for OnlyAllocationManager {
4686 type Parameters<'a> = UnderlyingSolTuple<'a>;
4687 type Token<'a> = <Self::Parameters<
4688 'a,
4689 > as alloy_sol_types::SolType>::Token<'a>;
4690 const SIGNATURE: &'static str = "OnlyAllocationManager()";
4691 const SELECTOR: [u8; 4] = [35u8, 216u8, 113u8, 165u8];
4692 #[inline]
4693 fn new<'a>(
4694 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4695 ) -> Self {
4696 tuple.into()
4697 }
4698 #[inline]
4699 fn tokenize(&self) -> Self::Token<'_> {
4700 ()
4701 }
4702 }
4703 };
4704 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4705 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4710 #[derive(Clone)]
4711 pub struct OnlyEjector {}
4712 #[allow(
4713 non_camel_case_types,
4714 non_snake_case,
4715 clippy::pub_underscore_fields,
4716 clippy::style
4717 )]
4718 const _: () = {
4719 use alloy::sol_types as alloy_sol_types;
4720 #[doc(hidden)]
4721 type UnderlyingSolTuple<'a> = ();
4722 #[doc(hidden)]
4723 type UnderlyingRustTuple<'a> = ();
4724 #[cfg(test)]
4725 #[allow(dead_code, unreachable_patterns)]
4726 fn _type_assertion(
4727 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4728 ) {
4729 match _t {
4730 alloy_sol_types::private::AssertTypeEq::<
4731 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4732 >(_) => {}
4733 }
4734 }
4735 #[automatically_derived]
4736 #[doc(hidden)]
4737 impl ::core::convert::From<OnlyEjector> for UnderlyingRustTuple<'_> {
4738 fn from(value: OnlyEjector) -> Self {
4739 ()
4740 }
4741 }
4742 #[automatically_derived]
4743 #[doc(hidden)]
4744 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyEjector {
4745 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4746 Self {}
4747 }
4748 }
4749 #[automatically_derived]
4750 impl alloy_sol_types::SolError for OnlyEjector {
4751 type Parameters<'a> = UnderlyingSolTuple<'a>;
4752 type Token<'a> = <Self::Parameters<
4753 'a,
4754 > as alloy_sol_types::SolType>::Token<'a>;
4755 const SIGNATURE: &'static str = "OnlyEjector()";
4756 const SELECTOR: [u8; 4] = [237u8, 177u8, 86u8, 46u8];
4757 #[inline]
4758 fn new<'a>(
4759 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4760 ) -> Self {
4761 tuple.into()
4762 }
4763 #[inline]
4764 fn tokenize(&self) -> Self::Token<'_> {
4765 ()
4766 }
4767 }
4768 };
4769 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4770 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4775 #[derive(Clone)]
4776 pub struct OperatorNotRegistered {}
4777 #[allow(
4778 non_camel_case_types,
4779 non_snake_case,
4780 clippy::pub_underscore_fields,
4781 clippy::style
4782 )]
4783 const _: () = {
4784 use alloy::sol_types as alloy_sol_types;
4785 #[doc(hidden)]
4786 type UnderlyingSolTuple<'a> = ();
4787 #[doc(hidden)]
4788 type UnderlyingRustTuple<'a> = ();
4789 #[cfg(test)]
4790 #[allow(dead_code, unreachable_patterns)]
4791 fn _type_assertion(
4792 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4793 ) {
4794 match _t {
4795 alloy_sol_types::private::AssertTypeEq::<
4796 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4797 >(_) => {}
4798 }
4799 }
4800 #[automatically_derived]
4801 #[doc(hidden)]
4802 impl ::core::convert::From<OperatorNotRegistered> for UnderlyingRustTuple<'_> {
4803 fn from(value: OperatorNotRegistered) -> Self {
4804 ()
4805 }
4806 }
4807 #[automatically_derived]
4808 #[doc(hidden)]
4809 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorNotRegistered {
4810 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4811 Self {}
4812 }
4813 }
4814 #[automatically_derived]
4815 impl alloy_sol_types::SolError for OperatorNotRegistered {
4816 type Parameters<'a> = UnderlyingSolTuple<'a>;
4817 type Token<'a> = <Self::Parameters<
4818 'a,
4819 > as alloy_sol_types::SolType>::Token<'a>;
4820 const SIGNATURE: &'static str = "OperatorNotRegistered()";
4821 const SELECTOR: [u8; 4] = [37u8, 236u8, 108u8, 31u8];
4822 #[inline]
4823 fn new<'a>(
4824 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4825 ) -> Self {
4826 tuple.into()
4827 }
4828 #[inline]
4829 fn tokenize(&self) -> Self::Token<'_> {
4830 ()
4831 }
4832 }
4833 };
4834 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4835 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4840 #[derive(Clone)]
4841 pub struct QuorumDoesNotExist {}
4842 #[allow(
4843 non_camel_case_types,
4844 non_snake_case,
4845 clippy::pub_underscore_fields,
4846 clippy::style
4847 )]
4848 const _: () = {
4849 use alloy::sol_types as alloy_sol_types;
4850 #[doc(hidden)]
4851 type UnderlyingSolTuple<'a> = ();
4852 #[doc(hidden)]
4853 type UnderlyingRustTuple<'a> = ();
4854 #[cfg(test)]
4855 #[allow(dead_code, unreachable_patterns)]
4856 fn _type_assertion(
4857 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4858 ) {
4859 match _t {
4860 alloy_sol_types::private::AssertTypeEq::<
4861 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4862 >(_) => {}
4863 }
4864 }
4865 #[automatically_derived]
4866 #[doc(hidden)]
4867 impl ::core::convert::From<QuorumDoesNotExist> for UnderlyingRustTuple<'_> {
4868 fn from(value: QuorumDoesNotExist) -> Self {
4869 ()
4870 }
4871 }
4872 #[automatically_derived]
4873 #[doc(hidden)]
4874 impl ::core::convert::From<UnderlyingRustTuple<'_>> for QuorumDoesNotExist {
4875 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4876 Self {}
4877 }
4878 }
4879 #[automatically_derived]
4880 impl alloy_sol_types::SolError for QuorumDoesNotExist {
4881 type Parameters<'a> = UnderlyingSolTuple<'a>;
4882 type Token<'a> = <Self::Parameters<
4883 'a,
4884 > as alloy_sol_types::SolType>::Token<'a>;
4885 const SIGNATURE: &'static str = "QuorumDoesNotExist()";
4886 const SELECTOR: [u8; 4] = [230u8, 33u8, 159u8, 234u8];
4887 #[inline]
4888 fn new<'a>(
4889 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4890 ) -> Self {
4891 tuple.into()
4892 }
4893 #[inline]
4894 fn tokenize(&self) -> Self::Token<'_> {
4895 ()
4896 }
4897 }
4898 };
4899 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4900 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4905 #[derive(Clone)]
4906 pub struct QuorumOperatorCountMismatch {}
4907 #[allow(
4908 non_camel_case_types,
4909 non_snake_case,
4910 clippy::pub_underscore_fields,
4911 clippy::style
4912 )]
4913 const _: () = {
4914 use alloy::sol_types as alloy_sol_types;
4915 #[doc(hidden)]
4916 type UnderlyingSolTuple<'a> = ();
4917 #[doc(hidden)]
4918 type UnderlyingRustTuple<'a> = ();
4919 #[cfg(test)]
4920 #[allow(dead_code, unreachable_patterns)]
4921 fn _type_assertion(
4922 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4923 ) {
4924 match _t {
4925 alloy_sol_types::private::AssertTypeEq::<
4926 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4927 >(_) => {}
4928 }
4929 }
4930 #[automatically_derived]
4931 #[doc(hidden)]
4932 impl ::core::convert::From<QuorumOperatorCountMismatch>
4933 for UnderlyingRustTuple<'_> {
4934 fn from(value: QuorumOperatorCountMismatch) -> Self {
4935 ()
4936 }
4937 }
4938 #[automatically_derived]
4939 #[doc(hidden)]
4940 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4941 for QuorumOperatorCountMismatch {
4942 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4943 Self {}
4944 }
4945 }
4946 #[automatically_derived]
4947 impl alloy_sol_types::SolError for QuorumOperatorCountMismatch {
4948 type Parameters<'a> = UnderlyingSolTuple<'a>;
4949 type Token<'a> = <Self::Parameters<
4950 'a,
4951 > as alloy_sol_types::SolType>::Token<'a>;
4952 const SIGNATURE: &'static str = "QuorumOperatorCountMismatch()";
4953 const SELECTOR: [u8; 4] = [142u8, 90u8, 238u8, 231u8];
4954 #[inline]
4955 fn new<'a>(
4956 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4957 ) -> Self {
4958 tuple.into()
4959 }
4960 #[inline]
4961 fn tokenize(&self) -> Self::Token<'_> {
4962 ()
4963 }
4964 }
4965 };
4966 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4967 #[allow(
4972 non_camel_case_types,
4973 non_snake_case,
4974 clippy::pub_underscore_fields,
4975 clippy::style
4976 )]
4977 #[derive(Clone)]
4978 pub struct AVSUpdated {
4979 #[allow(missing_docs)]
4980 pub prevAVS: alloy::sol_types::private::Address,
4981 #[allow(missing_docs)]
4982 pub newAVS: alloy::sol_types::private::Address,
4983 }
4984 #[allow(
4985 non_camel_case_types,
4986 non_snake_case,
4987 clippy::pub_underscore_fields,
4988 clippy::style
4989 )]
4990 const _: () = {
4991 use alloy::sol_types as alloy_sol_types;
4992 #[automatically_derived]
4993 impl alloy_sol_types::SolEvent for AVSUpdated {
4994 type DataTuple<'a> = (
4995 alloy::sol_types::sol_data::Address,
4996 alloy::sol_types::sol_data::Address,
4997 );
4998 type DataToken<'a> = <Self::DataTuple<
4999 'a,
5000 > as alloy_sol_types::SolType>::Token<'a>;
5001 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5002 const SIGNATURE: &'static str = "AVSUpdated(address,address)";
5003 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5004 151u8, 112u8, 243u8, 202u8, 223u8, 220u8, 187u8, 111u8, 147u8, 175u8,
5005 147u8, 94u8, 134u8, 4u8, 113u8, 17u8, 89u8, 12u8, 55u8, 104u8, 39u8,
5006 29u8, 35u8, 126u8, 74u8, 43u8, 192u8, 184u8, 116u8, 190u8, 214u8, 147u8,
5007 ]);
5008 const ANONYMOUS: bool = false;
5009 #[allow(unused_variables)]
5010 #[inline]
5011 fn new(
5012 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5013 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5014 ) -> Self {
5015 Self {
5016 prevAVS: data.0,
5017 newAVS: data.1,
5018 }
5019 }
5020 #[inline]
5021 fn check_signature(
5022 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5023 ) -> alloy_sol_types::Result<()> {
5024 if topics.0 != Self::SIGNATURE_HASH {
5025 return Err(
5026 alloy_sol_types::Error::invalid_event_signature_hash(
5027 Self::SIGNATURE,
5028 topics.0,
5029 Self::SIGNATURE_HASH,
5030 ),
5031 );
5032 }
5033 Ok(())
5034 }
5035 #[inline]
5036 fn tokenize_body(&self) -> Self::DataToken<'_> {
5037 (
5038 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5039 &self.prevAVS,
5040 ),
5041 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5042 &self.newAVS,
5043 ),
5044 )
5045 }
5046 #[inline]
5047 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5048 (Self::SIGNATURE_HASH.into(),)
5049 }
5050 #[inline]
5051 fn encode_topics_raw(
5052 &self,
5053 out: &mut [alloy_sol_types::abi::token::WordToken],
5054 ) -> alloy_sol_types::Result<()> {
5055 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5056 return Err(alloy_sol_types::Error::Overrun);
5057 }
5058 out[0usize] = alloy_sol_types::abi::token::WordToken(
5059 Self::SIGNATURE_HASH,
5060 );
5061 Ok(())
5062 }
5063 }
5064 #[automatically_derived]
5065 impl alloy_sol_types::private::IntoLogData for AVSUpdated {
5066 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5067 From::from(self)
5068 }
5069 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5070 From::from(&self)
5071 }
5072 }
5073 #[automatically_derived]
5074 impl From<&AVSUpdated> for alloy_sol_types::private::LogData {
5075 #[inline]
5076 fn from(this: &AVSUpdated) -> alloy_sol_types::private::LogData {
5077 alloy_sol_types::SolEvent::encode_log_data(this)
5078 }
5079 }
5080 };
5081 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5082 #[allow(
5087 non_camel_case_types,
5088 non_snake_case,
5089 clippy::pub_underscore_fields,
5090 clippy::style
5091 )]
5092 #[derive(Clone)]
5093 pub struct ChurnApproverUpdated {
5094 #[allow(missing_docs)]
5095 pub prevChurnApprover: alloy::sol_types::private::Address,
5096 #[allow(missing_docs)]
5097 pub newChurnApprover: alloy::sol_types::private::Address,
5098 }
5099 #[allow(
5100 non_camel_case_types,
5101 non_snake_case,
5102 clippy::pub_underscore_fields,
5103 clippy::style
5104 )]
5105 const _: () = {
5106 use alloy::sol_types as alloy_sol_types;
5107 #[automatically_derived]
5108 impl alloy_sol_types::SolEvent for ChurnApproverUpdated {
5109 type DataTuple<'a> = (
5110 alloy::sol_types::sol_data::Address,
5111 alloy::sol_types::sol_data::Address,
5112 );
5113 type DataToken<'a> = <Self::DataTuple<
5114 'a,
5115 > as alloy_sol_types::SolType>::Token<'a>;
5116 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5117 const SIGNATURE: &'static str = "ChurnApproverUpdated(address,address)";
5118 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5119 49u8, 84u8, 87u8, 216u8, 168u8, 254u8, 96u8, 240u8, 74u8, 241u8, 124u8,
5120 22u8, 226u8, 245u8, 165u8, 225u8, 219u8, 97u8, 43u8, 49u8, 100u8, 142u8,
5121 88u8, 3u8, 3u8, 96u8, 117u8, 158u8, 248u8, 243u8, 82u8, 140u8,
5122 ]);
5123 const ANONYMOUS: bool = false;
5124 #[allow(unused_variables)]
5125 #[inline]
5126 fn new(
5127 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5128 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5129 ) -> Self {
5130 Self {
5131 prevChurnApprover: data.0,
5132 newChurnApprover: data.1,
5133 }
5134 }
5135 #[inline]
5136 fn check_signature(
5137 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5138 ) -> alloy_sol_types::Result<()> {
5139 if topics.0 != Self::SIGNATURE_HASH {
5140 return Err(
5141 alloy_sol_types::Error::invalid_event_signature_hash(
5142 Self::SIGNATURE,
5143 topics.0,
5144 Self::SIGNATURE_HASH,
5145 ),
5146 );
5147 }
5148 Ok(())
5149 }
5150 #[inline]
5151 fn tokenize_body(&self) -> Self::DataToken<'_> {
5152 (
5153 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5154 &self.prevChurnApprover,
5155 ),
5156 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5157 &self.newChurnApprover,
5158 ),
5159 )
5160 }
5161 #[inline]
5162 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5163 (Self::SIGNATURE_HASH.into(),)
5164 }
5165 #[inline]
5166 fn encode_topics_raw(
5167 &self,
5168 out: &mut [alloy_sol_types::abi::token::WordToken],
5169 ) -> alloy_sol_types::Result<()> {
5170 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5171 return Err(alloy_sol_types::Error::Overrun);
5172 }
5173 out[0usize] = alloy_sol_types::abi::token::WordToken(
5174 Self::SIGNATURE_HASH,
5175 );
5176 Ok(())
5177 }
5178 }
5179 #[automatically_derived]
5180 impl alloy_sol_types::private::IntoLogData for ChurnApproverUpdated {
5181 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5182 From::from(self)
5183 }
5184 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5185 From::from(&self)
5186 }
5187 }
5188 #[automatically_derived]
5189 impl From<&ChurnApproverUpdated> for alloy_sol_types::private::LogData {
5190 #[inline]
5191 fn from(this: &ChurnApproverUpdated) -> alloy_sol_types::private::LogData {
5192 alloy_sol_types::SolEvent::encode_log_data(this)
5193 }
5194 }
5195 };
5196 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5197 #[allow(
5202 non_camel_case_types,
5203 non_snake_case,
5204 clippy::pub_underscore_fields,
5205 clippy::style
5206 )]
5207 #[derive(Clone)]
5208 pub struct EjectionCooldownUpdated {
5209 #[allow(missing_docs)]
5210 pub prevEjectionCooldown: alloy::sol_types::private::primitives::aliases::U256,
5211 #[allow(missing_docs)]
5212 pub newEjectionCooldown: alloy::sol_types::private::primitives::aliases::U256,
5213 }
5214 #[allow(
5215 non_camel_case_types,
5216 non_snake_case,
5217 clippy::pub_underscore_fields,
5218 clippy::style
5219 )]
5220 const _: () = {
5221 use alloy::sol_types as alloy_sol_types;
5222 #[automatically_derived]
5223 impl alloy_sol_types::SolEvent for EjectionCooldownUpdated {
5224 type DataTuple<'a> = (
5225 alloy::sol_types::sol_data::Uint<256>,
5226 alloy::sol_types::sol_data::Uint<256>,
5227 );
5228 type DataToken<'a> = <Self::DataTuple<
5229 'a,
5230 > as alloy_sol_types::SolType>::Token<'a>;
5231 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5232 const SIGNATURE: &'static str = "EjectionCooldownUpdated(uint256,uint256)";
5233 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5234 167u8, 122u8, 145u8, 190u8, 167u8, 182u8, 217u8, 90u8, 142u8, 181u8,
5235 165u8, 72u8, 120u8, 161u8, 217u8, 227u8, 200u8, 117u8, 226u8, 108u8,
5236 134u8, 169u8, 183u8, 14u8, 52u8, 32u8, 197u8, 197u8, 219u8, 25u8, 59u8,
5237 98u8,
5238 ]);
5239 const ANONYMOUS: bool = false;
5240 #[allow(unused_variables)]
5241 #[inline]
5242 fn new(
5243 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5244 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5245 ) -> Self {
5246 Self {
5247 prevEjectionCooldown: data.0,
5248 newEjectionCooldown: data.1,
5249 }
5250 }
5251 #[inline]
5252 fn check_signature(
5253 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5254 ) -> alloy_sol_types::Result<()> {
5255 if topics.0 != Self::SIGNATURE_HASH {
5256 return Err(
5257 alloy_sol_types::Error::invalid_event_signature_hash(
5258 Self::SIGNATURE,
5259 topics.0,
5260 Self::SIGNATURE_HASH,
5261 ),
5262 );
5263 }
5264 Ok(())
5265 }
5266 #[inline]
5267 fn tokenize_body(&self) -> Self::DataToken<'_> {
5268 (
5269 <alloy::sol_types::sol_data::Uint<
5270 256,
5271 > as alloy_sol_types::SolType>::tokenize(&self.prevEjectionCooldown),
5272 <alloy::sol_types::sol_data::Uint<
5273 256,
5274 > as alloy_sol_types::SolType>::tokenize(&self.newEjectionCooldown),
5275 )
5276 }
5277 #[inline]
5278 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5279 (Self::SIGNATURE_HASH.into(),)
5280 }
5281 #[inline]
5282 fn encode_topics_raw(
5283 &self,
5284 out: &mut [alloy_sol_types::abi::token::WordToken],
5285 ) -> alloy_sol_types::Result<()> {
5286 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5287 return Err(alloy_sol_types::Error::Overrun);
5288 }
5289 out[0usize] = alloy_sol_types::abi::token::WordToken(
5290 Self::SIGNATURE_HASH,
5291 );
5292 Ok(())
5293 }
5294 }
5295 #[automatically_derived]
5296 impl alloy_sol_types::private::IntoLogData for EjectionCooldownUpdated {
5297 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5298 From::from(self)
5299 }
5300 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5301 From::from(&self)
5302 }
5303 }
5304 #[automatically_derived]
5305 impl From<&EjectionCooldownUpdated> for alloy_sol_types::private::LogData {
5306 #[inline]
5307 fn from(
5308 this: &EjectionCooldownUpdated,
5309 ) -> alloy_sol_types::private::LogData {
5310 alloy_sol_types::SolEvent::encode_log_data(this)
5311 }
5312 }
5313 };
5314 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5315 #[allow(
5320 non_camel_case_types,
5321 non_snake_case,
5322 clippy::pub_underscore_fields,
5323 clippy::style
5324 )]
5325 #[derive(Clone)]
5326 pub struct EjectorUpdated {
5327 #[allow(missing_docs)]
5328 pub prevEjector: alloy::sol_types::private::Address,
5329 #[allow(missing_docs)]
5330 pub newEjector: alloy::sol_types::private::Address,
5331 }
5332 #[allow(
5333 non_camel_case_types,
5334 non_snake_case,
5335 clippy::pub_underscore_fields,
5336 clippy::style
5337 )]
5338 const _: () = {
5339 use alloy::sol_types as alloy_sol_types;
5340 #[automatically_derived]
5341 impl alloy_sol_types::SolEvent for EjectorUpdated {
5342 type DataTuple<'a> = (
5343 alloy::sol_types::sol_data::Address,
5344 alloy::sol_types::sol_data::Address,
5345 );
5346 type DataToken<'a> = <Self::DataTuple<
5347 'a,
5348 > as alloy_sol_types::SolType>::Token<'a>;
5349 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5350 const SIGNATURE: &'static str = "EjectorUpdated(address,address)";
5351 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5352 143u8, 48u8, 171u8, 9u8, 244u8, 58u8, 108u8, 21u8, 125u8, 127u8, 206u8,
5353 126u8, 10u8, 19u8, 192u8, 3u8, 4u8, 44u8, 28u8, 149u8, 232u8, 167u8,
5354 46u8, 122u8, 20u8, 106u8, 33u8, 192u8, 202u8, 162u8, 77u8, 201u8,
5355 ]);
5356 const ANONYMOUS: bool = false;
5357 #[allow(unused_variables)]
5358 #[inline]
5359 fn new(
5360 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5361 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5362 ) -> Self {
5363 Self {
5364 prevEjector: data.0,
5365 newEjector: data.1,
5366 }
5367 }
5368 #[inline]
5369 fn check_signature(
5370 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5371 ) -> alloy_sol_types::Result<()> {
5372 if topics.0 != Self::SIGNATURE_HASH {
5373 return Err(
5374 alloy_sol_types::Error::invalid_event_signature_hash(
5375 Self::SIGNATURE,
5376 topics.0,
5377 Self::SIGNATURE_HASH,
5378 ),
5379 );
5380 }
5381 Ok(())
5382 }
5383 #[inline]
5384 fn tokenize_body(&self) -> Self::DataToken<'_> {
5385 (
5386 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5387 &self.prevEjector,
5388 ),
5389 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5390 &self.newEjector,
5391 ),
5392 )
5393 }
5394 #[inline]
5395 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5396 (Self::SIGNATURE_HASH.into(),)
5397 }
5398 #[inline]
5399 fn encode_topics_raw(
5400 &self,
5401 out: &mut [alloy_sol_types::abi::token::WordToken],
5402 ) -> alloy_sol_types::Result<()> {
5403 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5404 return Err(alloy_sol_types::Error::Overrun);
5405 }
5406 out[0usize] = alloy_sol_types::abi::token::WordToken(
5407 Self::SIGNATURE_HASH,
5408 );
5409 Ok(())
5410 }
5411 }
5412 #[automatically_derived]
5413 impl alloy_sol_types::private::IntoLogData for EjectorUpdated {
5414 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5415 From::from(self)
5416 }
5417 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5418 From::from(&self)
5419 }
5420 }
5421 #[automatically_derived]
5422 impl From<&EjectorUpdated> for alloy_sol_types::private::LogData {
5423 #[inline]
5424 fn from(this: &EjectorUpdated) -> alloy_sol_types::private::LogData {
5425 alloy_sol_types::SolEvent::encode_log_data(this)
5426 }
5427 }
5428 };
5429 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5430 #[allow(
5435 non_camel_case_types,
5436 non_snake_case,
5437 clippy::pub_underscore_fields,
5438 clippy::style
5439 )]
5440 #[derive(Clone)]
5441 pub struct OperatorDeregistered {
5442 #[allow(missing_docs)]
5443 pub operator: alloy::sol_types::private::Address,
5444 #[allow(missing_docs)]
5445 pub operatorId: alloy::sol_types::private::FixedBytes<32>,
5446 }
5447 #[allow(
5448 non_camel_case_types,
5449 non_snake_case,
5450 clippy::pub_underscore_fields,
5451 clippy::style
5452 )]
5453 const _: () = {
5454 use alloy::sol_types as alloy_sol_types;
5455 #[automatically_derived]
5456 impl alloy_sol_types::SolEvent for OperatorDeregistered {
5457 type DataTuple<'a> = ();
5458 type DataToken<'a> = <Self::DataTuple<
5459 'a,
5460 > as alloy_sol_types::SolType>::Token<'a>;
5461 type TopicList = (
5462 alloy_sol_types::sol_data::FixedBytes<32>,
5463 alloy::sol_types::sol_data::Address,
5464 alloy::sol_types::sol_data::FixedBytes<32>,
5465 );
5466 const SIGNATURE: &'static str = "OperatorDeregistered(address,bytes32)";
5467 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5468 57u8, 111u8, 220u8, 177u8, 128u8, 203u8, 15u8, 234u8, 38u8, 146u8, 129u8,
5469 19u8, 251u8, 15u8, 209u8, 195u8, 84u8, 152u8, 99u8, 249u8, 205u8, 86u8,
5470 62u8, 106u8, 24u8, 79u8, 29u8, 87u8, 129u8, 22u8, 200u8, 228u8,
5471 ]);
5472 const ANONYMOUS: bool = false;
5473 #[allow(unused_variables)]
5474 #[inline]
5475 fn new(
5476 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5477 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5478 ) -> Self {
5479 Self {
5480 operator: topics.1,
5481 operatorId: topics.2,
5482 }
5483 }
5484 #[inline]
5485 fn check_signature(
5486 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5487 ) -> alloy_sol_types::Result<()> {
5488 if topics.0 != Self::SIGNATURE_HASH {
5489 return Err(
5490 alloy_sol_types::Error::invalid_event_signature_hash(
5491 Self::SIGNATURE,
5492 topics.0,
5493 Self::SIGNATURE_HASH,
5494 ),
5495 );
5496 }
5497 Ok(())
5498 }
5499 #[inline]
5500 fn tokenize_body(&self) -> Self::DataToken<'_> {
5501 ()
5502 }
5503 #[inline]
5504 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5505 (
5506 Self::SIGNATURE_HASH.into(),
5507 self.operator.clone(),
5508 self.operatorId.clone(),
5509 )
5510 }
5511 #[inline]
5512 fn encode_topics_raw(
5513 &self,
5514 out: &mut [alloy_sol_types::abi::token::WordToken],
5515 ) -> alloy_sol_types::Result<()> {
5516 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5517 return Err(alloy_sol_types::Error::Overrun);
5518 }
5519 out[0usize] = alloy_sol_types::abi::token::WordToken(
5520 Self::SIGNATURE_HASH,
5521 );
5522 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5523 &self.operator,
5524 );
5525 out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
5526 32,
5527 > as alloy_sol_types::EventTopic>::encode_topic(&self.operatorId);
5528 Ok(())
5529 }
5530 }
5531 #[automatically_derived]
5532 impl alloy_sol_types::private::IntoLogData for OperatorDeregistered {
5533 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5534 From::from(self)
5535 }
5536 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5537 From::from(&self)
5538 }
5539 }
5540 #[automatically_derived]
5541 impl From<&OperatorDeregistered> for alloy_sol_types::private::LogData {
5542 #[inline]
5543 fn from(this: &OperatorDeregistered) -> alloy_sol_types::private::LogData {
5544 alloy_sol_types::SolEvent::encode_log_data(this)
5545 }
5546 }
5547 };
5548 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5549 #[allow(
5554 non_camel_case_types,
5555 non_snake_case,
5556 clippy::pub_underscore_fields,
5557 clippy::style
5558 )]
5559 #[derive(Clone)]
5560 pub struct OperatorRegistered {
5561 #[allow(missing_docs)]
5562 pub operator: alloy::sol_types::private::Address,
5563 #[allow(missing_docs)]
5564 pub operatorId: alloy::sol_types::private::FixedBytes<32>,
5565 }
5566 #[allow(
5567 non_camel_case_types,
5568 non_snake_case,
5569 clippy::pub_underscore_fields,
5570 clippy::style
5571 )]
5572 const _: () = {
5573 use alloy::sol_types as alloy_sol_types;
5574 #[automatically_derived]
5575 impl alloy_sol_types::SolEvent for OperatorRegistered {
5576 type DataTuple<'a> = ();
5577 type DataToken<'a> = <Self::DataTuple<
5578 'a,
5579 > as alloy_sol_types::SolType>::Token<'a>;
5580 type TopicList = (
5581 alloy_sol_types::sol_data::FixedBytes<32>,
5582 alloy::sol_types::sol_data::Address,
5583 alloy::sol_types::sol_data::FixedBytes<32>,
5584 );
5585 const SIGNATURE: &'static str = "OperatorRegistered(address,bytes32)";
5586 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5587 232u8, 230u8, 140u8, 239u8, 28u8, 58u8, 118u8, 30u8, 215u8, 190u8, 126u8,
5588 132u8, 99u8, 163u8, 117u8, 242u8, 127u8, 123u8, 195u8, 53u8, 229u8, 24u8,
5589 36u8, 34u8, 60u8, 172u8, 206u8, 99u8, 110u8, 197u8, 195u8, 254u8,
5590 ]);
5591 const ANONYMOUS: bool = false;
5592 #[allow(unused_variables)]
5593 #[inline]
5594 fn new(
5595 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5596 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5597 ) -> Self {
5598 Self {
5599 operator: topics.1,
5600 operatorId: topics.2,
5601 }
5602 }
5603 #[inline]
5604 fn check_signature(
5605 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5606 ) -> alloy_sol_types::Result<()> {
5607 if topics.0 != Self::SIGNATURE_HASH {
5608 return Err(
5609 alloy_sol_types::Error::invalid_event_signature_hash(
5610 Self::SIGNATURE,
5611 topics.0,
5612 Self::SIGNATURE_HASH,
5613 ),
5614 );
5615 }
5616 Ok(())
5617 }
5618 #[inline]
5619 fn tokenize_body(&self) -> Self::DataToken<'_> {
5620 ()
5621 }
5622 #[inline]
5623 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5624 (
5625 Self::SIGNATURE_HASH.into(),
5626 self.operator.clone(),
5627 self.operatorId.clone(),
5628 )
5629 }
5630 #[inline]
5631 fn encode_topics_raw(
5632 &self,
5633 out: &mut [alloy_sol_types::abi::token::WordToken],
5634 ) -> alloy_sol_types::Result<()> {
5635 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5636 return Err(alloy_sol_types::Error::Overrun);
5637 }
5638 out[0usize] = alloy_sol_types::abi::token::WordToken(
5639 Self::SIGNATURE_HASH,
5640 );
5641 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5642 &self.operator,
5643 );
5644 out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
5645 32,
5646 > as alloy_sol_types::EventTopic>::encode_topic(&self.operatorId);
5647 Ok(())
5648 }
5649 }
5650 #[automatically_derived]
5651 impl alloy_sol_types::private::IntoLogData for OperatorRegistered {
5652 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5653 From::from(self)
5654 }
5655 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5656 From::from(&self)
5657 }
5658 }
5659 #[automatically_derived]
5660 impl From<&OperatorRegistered> for alloy_sol_types::private::LogData {
5661 #[inline]
5662 fn from(this: &OperatorRegistered) -> alloy_sol_types::private::LogData {
5663 alloy_sol_types::SolEvent::encode_log_data(this)
5664 }
5665 }
5666 };
5667 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5668 #[allow(
5673 non_camel_case_types,
5674 non_snake_case,
5675 clippy::pub_underscore_fields,
5676 clippy::style
5677 )]
5678 #[derive(Clone)]
5679 pub struct OperatorSetParamsUpdated {
5680 #[allow(missing_docs)]
5681 pub quorumNumber: u8,
5682 #[allow(missing_docs)]
5683 pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
5684 }
5685 #[allow(
5686 non_camel_case_types,
5687 non_snake_case,
5688 clippy::pub_underscore_fields,
5689 clippy::style
5690 )]
5691 const _: () = {
5692 use alloy::sol_types as alloy_sol_types;
5693 #[automatically_derived]
5694 impl alloy_sol_types::SolEvent for OperatorSetParamsUpdated {
5695 type DataTuple<'a> = (ISlashingRegistryCoordinatorTypes::OperatorSetParam,);
5696 type DataToken<'a> = <Self::DataTuple<
5697 'a,
5698 > as alloy_sol_types::SolType>::Token<'a>;
5699 type TopicList = (
5700 alloy_sol_types::sol_data::FixedBytes<32>,
5701 alloy::sol_types::sol_data::Uint<8>,
5702 );
5703 const SIGNATURE: &'static str = "OperatorSetParamsUpdated(uint8,(uint32,uint16,uint16))";
5704 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5705 62u8, 230u8, 254u8, 141u8, 84u8, 97u8, 2u8, 68u8, 195u8, 233u8, 211u8,
5706 192u8, 102u8, 174u8, 74u8, 238u8, 153u8, 120u8, 132u8, 170u8, 40u8,
5707 241u8, 6u8, 22u8, 174u8, 130u8, 25u8, 37u8, 64u8, 19u8, 24u8, 172u8,
5708 ]);
5709 const ANONYMOUS: bool = false;
5710 #[allow(unused_variables)]
5711 #[inline]
5712 fn new(
5713 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5714 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5715 ) -> Self {
5716 Self {
5717 quorumNumber: topics.1,
5718 operatorSetParams: data.0,
5719 }
5720 }
5721 #[inline]
5722 fn check_signature(
5723 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5724 ) -> alloy_sol_types::Result<()> {
5725 if topics.0 != Self::SIGNATURE_HASH {
5726 return Err(
5727 alloy_sol_types::Error::invalid_event_signature_hash(
5728 Self::SIGNATURE,
5729 topics.0,
5730 Self::SIGNATURE_HASH,
5731 ),
5732 );
5733 }
5734 Ok(())
5735 }
5736 #[inline]
5737 fn tokenize_body(&self) -> Self::DataToken<'_> {
5738 (
5739 <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
5740 &self.operatorSetParams,
5741 ),
5742 )
5743 }
5744 #[inline]
5745 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5746 (Self::SIGNATURE_HASH.into(), self.quorumNumber.clone())
5747 }
5748 #[inline]
5749 fn encode_topics_raw(
5750 &self,
5751 out: &mut [alloy_sol_types::abi::token::WordToken],
5752 ) -> alloy_sol_types::Result<()> {
5753 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5754 return Err(alloy_sol_types::Error::Overrun);
5755 }
5756 out[0usize] = alloy_sol_types::abi::token::WordToken(
5757 Self::SIGNATURE_HASH,
5758 );
5759 out[1usize] = <alloy::sol_types::sol_data::Uint<
5760 8,
5761 > as alloy_sol_types::EventTopic>::encode_topic(&self.quorumNumber);
5762 Ok(())
5763 }
5764 }
5765 #[automatically_derived]
5766 impl alloy_sol_types::private::IntoLogData for OperatorSetParamsUpdated {
5767 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5768 From::from(self)
5769 }
5770 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5771 From::from(&self)
5772 }
5773 }
5774 #[automatically_derived]
5775 impl From<&OperatorSetParamsUpdated> for alloy_sol_types::private::LogData {
5776 #[inline]
5777 fn from(
5778 this: &OperatorSetParamsUpdated,
5779 ) -> alloy_sol_types::private::LogData {
5780 alloy_sol_types::SolEvent::encode_log_data(this)
5781 }
5782 }
5783 };
5784 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5785 #[allow(
5790 non_camel_case_types,
5791 non_snake_case,
5792 clippy::pub_underscore_fields,
5793 clippy::style
5794 )]
5795 #[derive(Clone)]
5796 pub struct OperatorSocketUpdate {
5797 #[allow(missing_docs)]
5798 pub operatorId: alloy::sol_types::private::FixedBytes<32>,
5799 #[allow(missing_docs)]
5800 pub socket: alloy::sol_types::private::String,
5801 }
5802 #[allow(
5803 non_camel_case_types,
5804 non_snake_case,
5805 clippy::pub_underscore_fields,
5806 clippy::style
5807 )]
5808 const _: () = {
5809 use alloy::sol_types as alloy_sol_types;
5810 #[automatically_derived]
5811 impl alloy_sol_types::SolEvent for OperatorSocketUpdate {
5812 type DataTuple<'a> = (alloy::sol_types::sol_data::String,);
5813 type DataToken<'a> = <Self::DataTuple<
5814 'a,
5815 > as alloy_sol_types::SolType>::Token<'a>;
5816 type TopicList = (
5817 alloy_sol_types::sol_data::FixedBytes<32>,
5818 alloy::sol_types::sol_data::FixedBytes<32>,
5819 );
5820 const SIGNATURE: &'static str = "OperatorSocketUpdate(bytes32,string)";
5821 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5822 236u8, 41u8, 99u8, 171u8, 33u8, 193u8, 229u8, 14u8, 30u8, 88u8, 42u8,
5823 165u8, 66u8, 175u8, 46u8, 75u8, 247u8, 191u8, 56u8, 230u8, 225u8, 64u8,
5824 60u8, 39u8, 180u8, 46u8, 28u8, 93u8, 110u8, 98u8, 30u8, 170u8,
5825 ]);
5826 const ANONYMOUS: bool = false;
5827 #[allow(unused_variables)]
5828 #[inline]
5829 fn new(
5830 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5831 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5832 ) -> Self {
5833 Self {
5834 operatorId: topics.1,
5835 socket: data.0,
5836 }
5837 }
5838 #[inline]
5839 fn check_signature(
5840 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5841 ) -> alloy_sol_types::Result<()> {
5842 if topics.0 != Self::SIGNATURE_HASH {
5843 return Err(
5844 alloy_sol_types::Error::invalid_event_signature_hash(
5845 Self::SIGNATURE,
5846 topics.0,
5847 Self::SIGNATURE_HASH,
5848 ),
5849 );
5850 }
5851 Ok(())
5852 }
5853 #[inline]
5854 fn tokenize_body(&self) -> Self::DataToken<'_> {
5855 (
5856 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
5857 &self.socket,
5858 ),
5859 )
5860 }
5861 #[inline]
5862 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5863 (Self::SIGNATURE_HASH.into(), self.operatorId.clone())
5864 }
5865 #[inline]
5866 fn encode_topics_raw(
5867 &self,
5868 out: &mut [alloy_sol_types::abi::token::WordToken],
5869 ) -> alloy_sol_types::Result<()> {
5870 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5871 return Err(alloy_sol_types::Error::Overrun);
5872 }
5873 out[0usize] = alloy_sol_types::abi::token::WordToken(
5874 Self::SIGNATURE_HASH,
5875 );
5876 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
5877 32,
5878 > as alloy_sol_types::EventTopic>::encode_topic(&self.operatorId);
5879 Ok(())
5880 }
5881 }
5882 #[automatically_derived]
5883 impl alloy_sol_types::private::IntoLogData for OperatorSocketUpdate {
5884 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5885 From::from(self)
5886 }
5887 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5888 From::from(&self)
5889 }
5890 }
5891 #[automatically_derived]
5892 impl From<&OperatorSocketUpdate> for alloy_sol_types::private::LogData {
5893 #[inline]
5894 fn from(this: &OperatorSocketUpdate) -> alloy_sol_types::private::LogData {
5895 alloy_sol_types::SolEvent::encode_log_data(this)
5896 }
5897 }
5898 };
5899 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5900 #[allow(
5905 non_camel_case_types,
5906 non_snake_case,
5907 clippy::pub_underscore_fields,
5908 clippy::style
5909 )]
5910 #[derive(Clone)]
5911 pub struct QuorumBlockNumberUpdated {
5912 #[allow(missing_docs)]
5913 pub quorumNumber: u8,
5914 #[allow(missing_docs)]
5915 pub blocknumber: alloy::sol_types::private::primitives::aliases::U256,
5916 }
5917 #[allow(
5918 non_camel_case_types,
5919 non_snake_case,
5920 clippy::pub_underscore_fields,
5921 clippy::style
5922 )]
5923 const _: () = {
5924 use alloy::sol_types as alloy_sol_types;
5925 #[automatically_derived]
5926 impl alloy_sol_types::SolEvent for QuorumBlockNumberUpdated {
5927 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5928 type DataToken<'a> = <Self::DataTuple<
5929 'a,
5930 > as alloy_sol_types::SolType>::Token<'a>;
5931 type TopicList = (
5932 alloy_sol_types::sol_data::FixedBytes<32>,
5933 alloy::sol_types::sol_data::Uint<8>,
5934 );
5935 const SIGNATURE: &'static str = "QuorumBlockNumberUpdated(uint8,uint256)";
5936 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5937 70u8, 7u8, 125u8, 85u8, 51u8, 7u8, 99u8, 241u8, 98u8, 105u8, 253u8,
5938 117u8, 229u8, 118u8, 22u8, 99u8, 244u8, 25u8, 45u8, 39u8, 145u8, 116u8,
5939 124u8, 1u8, 137u8, 177u8, 106u8, 211u8, 29u8, 176u8, 125u8, 180u8,
5940 ]);
5941 const ANONYMOUS: bool = false;
5942 #[allow(unused_variables)]
5943 #[inline]
5944 fn new(
5945 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5946 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5947 ) -> Self {
5948 Self {
5949 quorumNumber: topics.1,
5950 blocknumber: data.0,
5951 }
5952 }
5953 #[inline]
5954 fn check_signature(
5955 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5956 ) -> alloy_sol_types::Result<()> {
5957 if topics.0 != Self::SIGNATURE_HASH {
5958 return Err(
5959 alloy_sol_types::Error::invalid_event_signature_hash(
5960 Self::SIGNATURE,
5961 topics.0,
5962 Self::SIGNATURE_HASH,
5963 ),
5964 );
5965 }
5966 Ok(())
5967 }
5968 #[inline]
5969 fn tokenize_body(&self) -> Self::DataToken<'_> {
5970 (
5971 <alloy::sol_types::sol_data::Uint<
5972 256,
5973 > as alloy_sol_types::SolType>::tokenize(&self.blocknumber),
5974 )
5975 }
5976 #[inline]
5977 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5978 (Self::SIGNATURE_HASH.into(), self.quorumNumber.clone())
5979 }
5980 #[inline]
5981 fn encode_topics_raw(
5982 &self,
5983 out: &mut [alloy_sol_types::abi::token::WordToken],
5984 ) -> alloy_sol_types::Result<()> {
5985 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5986 return Err(alloy_sol_types::Error::Overrun);
5987 }
5988 out[0usize] = alloy_sol_types::abi::token::WordToken(
5989 Self::SIGNATURE_HASH,
5990 );
5991 out[1usize] = <alloy::sol_types::sol_data::Uint<
5992 8,
5993 > as alloy_sol_types::EventTopic>::encode_topic(&self.quorumNumber);
5994 Ok(())
5995 }
5996 }
5997 #[automatically_derived]
5998 impl alloy_sol_types::private::IntoLogData for QuorumBlockNumberUpdated {
5999 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6000 From::from(self)
6001 }
6002 fn into_log_data(self) -> alloy_sol_types::private::LogData {
6003 From::from(&self)
6004 }
6005 }
6006 #[automatically_derived]
6007 impl From<&QuorumBlockNumberUpdated> for alloy_sol_types::private::LogData {
6008 #[inline]
6009 fn from(
6010 this: &QuorumBlockNumberUpdated,
6011 ) -> alloy_sol_types::private::LogData {
6012 alloy_sol_types::SolEvent::encode_log_data(this)
6013 }
6014 }
6015 };
6016 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6017 #[allow(
6022 non_camel_case_types,
6023 non_snake_case,
6024 clippy::pub_underscore_fields,
6025 clippy::style
6026 )]
6027 #[derive(Clone)]
6028 pub struct QuorumCreated {
6029 #[allow(missing_docs)]
6030 pub quorumNumber: u8,
6031 #[allow(missing_docs)]
6032 pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
6033 #[allow(missing_docs)]
6034 pub minimumStake: alloy::sol_types::private::primitives::aliases::U96,
6035 #[allow(missing_docs)]
6036 pub strategyParams: alloy::sol_types::private::Vec<
6037 <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
6038 >,
6039 #[allow(missing_docs)]
6040 pub stakeType: <IStakeRegistryTypes::StakeType as alloy::sol_types::SolType>::RustType,
6041 #[allow(missing_docs)]
6042 pub lookAheadPeriod: u32,
6043 }
6044 #[allow(
6045 non_camel_case_types,
6046 non_snake_case,
6047 clippy::pub_underscore_fields,
6048 clippy::style
6049 )]
6050 const _: () = {
6051 use alloy::sol_types as alloy_sol_types;
6052 #[automatically_derived]
6053 impl alloy_sol_types::SolEvent for QuorumCreated {
6054 type DataTuple<'a> = (
6055 ISlashingRegistryCoordinatorTypes::OperatorSetParam,
6056 alloy::sol_types::sol_data::Uint<96>,
6057 alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
6058 IStakeRegistryTypes::StakeType,
6059 alloy::sol_types::sol_data::Uint<32>,
6060 );
6061 type DataToken<'a> = <Self::DataTuple<
6062 'a,
6063 > as alloy_sol_types::SolType>::Token<'a>;
6064 type TopicList = (
6065 alloy_sol_types::sol_data::FixedBytes<32>,
6066 alloy::sol_types::sol_data::Uint<8>,
6067 );
6068 const SIGNATURE: &'static str = "QuorumCreated(uint8,(uint32,uint16,uint16),uint96,(address,uint96)[],uint8,uint32)";
6069 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
6070 163u8, 72u8, 53u8, 188u8, 43u8, 103u8, 62u8, 195u8, 127u8, 207u8, 21u8,
6071 145u8, 169u8, 18u8, 149u8, 177u8, 99u8, 252u8, 46u8, 24u8, 30u8, 78u8,
6072 164u8, 231u8, 51u8, 190u8, 178u8, 125u8, 225u8, 206u8, 172u8, 76u8,
6073 ]);
6074 const ANONYMOUS: bool = false;
6075 #[allow(unused_variables)]
6076 #[inline]
6077 fn new(
6078 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6079 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6080 ) -> Self {
6081 Self {
6082 quorumNumber: topics.1,
6083 operatorSetParams: data.0,
6084 minimumStake: data.1,
6085 strategyParams: data.2,
6086 stakeType: data.3,
6087 lookAheadPeriod: data.4,
6088 }
6089 }
6090 #[inline]
6091 fn check_signature(
6092 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6093 ) -> alloy_sol_types::Result<()> {
6094 if topics.0 != Self::SIGNATURE_HASH {
6095 return Err(
6096 alloy_sol_types::Error::invalid_event_signature_hash(
6097 Self::SIGNATURE,
6098 topics.0,
6099 Self::SIGNATURE_HASH,
6100 ),
6101 );
6102 }
6103 Ok(())
6104 }
6105 #[inline]
6106 fn tokenize_body(&self) -> Self::DataToken<'_> {
6107 (
6108 <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
6109 &self.operatorSetParams,
6110 ),
6111 <alloy::sol_types::sol_data::Uint<
6112 96,
6113 > as alloy_sol_types::SolType>::tokenize(&self.minimumStake),
6114 <alloy::sol_types::sol_data::Array<
6115 IStakeRegistryTypes::StrategyParams,
6116 > as alloy_sol_types::SolType>::tokenize(&self.strategyParams),
6117 <IStakeRegistryTypes::StakeType as alloy_sol_types::SolType>::tokenize(
6118 &self.stakeType,
6119 ),
6120 <alloy::sol_types::sol_data::Uint<
6121 32,
6122 > as alloy_sol_types::SolType>::tokenize(&self.lookAheadPeriod),
6123 )
6124 }
6125 #[inline]
6126 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6127 (Self::SIGNATURE_HASH.into(), self.quorumNumber.clone())
6128 }
6129 #[inline]
6130 fn encode_topics_raw(
6131 &self,
6132 out: &mut [alloy_sol_types::abi::token::WordToken],
6133 ) -> alloy_sol_types::Result<()> {
6134 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6135 return Err(alloy_sol_types::Error::Overrun);
6136 }
6137 out[0usize] = alloy_sol_types::abi::token::WordToken(
6138 Self::SIGNATURE_HASH,
6139 );
6140 out[1usize] = <alloy::sol_types::sol_data::Uint<
6141 8,
6142 > as alloy_sol_types::EventTopic>::encode_topic(&self.quorumNumber);
6143 Ok(())
6144 }
6145 }
6146 #[automatically_derived]
6147 impl alloy_sol_types::private::IntoLogData for QuorumCreated {
6148 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6149 From::from(self)
6150 }
6151 fn into_log_data(self) -> alloy_sol_types::private::LogData {
6152 From::from(&self)
6153 }
6154 }
6155 #[automatically_derived]
6156 impl From<&QuorumCreated> for alloy_sol_types::private::LogData {
6157 #[inline]
6158 fn from(this: &QuorumCreated) -> alloy_sol_types::private::LogData {
6159 alloy_sol_types::SolEvent::encode_log_data(this)
6160 }
6161 }
6162 };
6163 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6164 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6169 #[derive(Clone)]
6170 pub struct OPERATOR_CHURN_APPROVAL_TYPEHASHCall {}
6171 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6172 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6174 #[derive(Clone)]
6175 pub struct OPERATOR_CHURN_APPROVAL_TYPEHASHReturn {
6176 #[allow(missing_docs)]
6177 pub _0: alloy::sol_types::private::FixedBytes<32>,
6178 }
6179 #[allow(
6180 non_camel_case_types,
6181 non_snake_case,
6182 clippy::pub_underscore_fields,
6183 clippy::style
6184 )]
6185 const _: () = {
6186 use alloy::sol_types as alloy_sol_types;
6187 {
6188 #[doc(hidden)]
6189 type UnderlyingSolTuple<'a> = ();
6190 #[doc(hidden)]
6191 type UnderlyingRustTuple<'a> = ();
6192 #[cfg(test)]
6193 #[allow(dead_code, unreachable_patterns)]
6194 fn _type_assertion(
6195 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6196 ) {
6197 match _t {
6198 alloy_sol_types::private::AssertTypeEq::<
6199 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6200 >(_) => {}
6201 }
6202 }
6203 #[automatically_derived]
6204 #[doc(hidden)]
6205 impl ::core::convert::From<OPERATOR_CHURN_APPROVAL_TYPEHASHCall>
6206 for UnderlyingRustTuple<'_> {
6207 fn from(value: OPERATOR_CHURN_APPROVAL_TYPEHASHCall) -> Self {
6208 ()
6209 }
6210 }
6211 #[automatically_derived]
6212 #[doc(hidden)]
6213 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6214 for OPERATOR_CHURN_APPROVAL_TYPEHASHCall {
6215 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6216 Self {}
6217 }
6218 }
6219 }
6220 {
6221 #[doc(hidden)]
6222 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6223 #[doc(hidden)]
6224 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
6225 #[cfg(test)]
6226 #[allow(dead_code, unreachable_patterns)]
6227 fn _type_assertion(
6228 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6229 ) {
6230 match _t {
6231 alloy_sol_types::private::AssertTypeEq::<
6232 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6233 >(_) => {}
6234 }
6235 }
6236 #[automatically_derived]
6237 #[doc(hidden)]
6238 impl ::core::convert::From<OPERATOR_CHURN_APPROVAL_TYPEHASHReturn>
6239 for UnderlyingRustTuple<'_> {
6240 fn from(value: OPERATOR_CHURN_APPROVAL_TYPEHASHReturn) -> Self {
6241 (value._0,)
6242 }
6243 }
6244 #[automatically_derived]
6245 #[doc(hidden)]
6246 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6247 for OPERATOR_CHURN_APPROVAL_TYPEHASHReturn {
6248 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6249 Self { _0: tuple.0 }
6250 }
6251 }
6252 }
6253 #[automatically_derived]
6254 impl alloy_sol_types::SolCall for OPERATOR_CHURN_APPROVAL_TYPEHASHCall {
6255 type Parameters<'a> = ();
6256 type Token<'a> = <Self::Parameters<
6257 'a,
6258 > as alloy_sol_types::SolType>::Token<'a>;
6259 type Return = OPERATOR_CHURN_APPROVAL_TYPEHASHReturn;
6260 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6261 type ReturnToken<'a> = <Self::ReturnTuple<
6262 'a,
6263 > as alloy_sol_types::SolType>::Token<'a>;
6264 const SIGNATURE: &'static str = "OPERATOR_CHURN_APPROVAL_TYPEHASH()";
6265 const SELECTOR: [u8; 4] = [202u8, 13u8, 232u8, 130u8];
6266 #[inline]
6267 fn new<'a>(
6268 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6269 ) -> Self {
6270 tuple.into()
6271 }
6272 #[inline]
6273 fn tokenize(&self) -> Self::Token<'_> {
6274 ()
6275 }
6276 #[inline]
6277 fn abi_decode_returns(
6278 data: &[u8],
6279 validate: bool,
6280 ) -> alloy_sol_types::Result<Self::Return> {
6281 <Self::ReturnTuple<
6282 '_,
6283 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6284 .map(Into::into)
6285 }
6286 }
6287 };
6288 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6289 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6294 #[derive(Clone)]
6295 pub struct PUBKEY_REGISTRATION_TYPEHASHCall {}
6296 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6297 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6299 #[derive(Clone)]
6300 pub struct PUBKEY_REGISTRATION_TYPEHASHReturn {
6301 #[allow(missing_docs)]
6302 pub _0: alloy::sol_types::private::FixedBytes<32>,
6303 }
6304 #[allow(
6305 non_camel_case_types,
6306 non_snake_case,
6307 clippy::pub_underscore_fields,
6308 clippy::style
6309 )]
6310 const _: () = {
6311 use alloy::sol_types as alloy_sol_types;
6312 {
6313 #[doc(hidden)]
6314 type UnderlyingSolTuple<'a> = ();
6315 #[doc(hidden)]
6316 type UnderlyingRustTuple<'a> = ();
6317 #[cfg(test)]
6318 #[allow(dead_code, unreachable_patterns)]
6319 fn _type_assertion(
6320 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6321 ) {
6322 match _t {
6323 alloy_sol_types::private::AssertTypeEq::<
6324 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6325 >(_) => {}
6326 }
6327 }
6328 #[automatically_derived]
6329 #[doc(hidden)]
6330 impl ::core::convert::From<PUBKEY_REGISTRATION_TYPEHASHCall>
6331 for UnderlyingRustTuple<'_> {
6332 fn from(value: PUBKEY_REGISTRATION_TYPEHASHCall) -> Self {
6333 ()
6334 }
6335 }
6336 #[automatically_derived]
6337 #[doc(hidden)]
6338 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6339 for PUBKEY_REGISTRATION_TYPEHASHCall {
6340 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6341 Self {}
6342 }
6343 }
6344 }
6345 {
6346 #[doc(hidden)]
6347 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6348 #[doc(hidden)]
6349 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
6350 #[cfg(test)]
6351 #[allow(dead_code, unreachable_patterns)]
6352 fn _type_assertion(
6353 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6354 ) {
6355 match _t {
6356 alloy_sol_types::private::AssertTypeEq::<
6357 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6358 >(_) => {}
6359 }
6360 }
6361 #[automatically_derived]
6362 #[doc(hidden)]
6363 impl ::core::convert::From<PUBKEY_REGISTRATION_TYPEHASHReturn>
6364 for UnderlyingRustTuple<'_> {
6365 fn from(value: PUBKEY_REGISTRATION_TYPEHASHReturn) -> Self {
6366 (value._0,)
6367 }
6368 }
6369 #[automatically_derived]
6370 #[doc(hidden)]
6371 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6372 for PUBKEY_REGISTRATION_TYPEHASHReturn {
6373 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6374 Self { _0: tuple.0 }
6375 }
6376 }
6377 }
6378 #[automatically_derived]
6379 impl alloy_sol_types::SolCall for PUBKEY_REGISTRATION_TYPEHASHCall {
6380 type Parameters<'a> = ();
6381 type Token<'a> = <Self::Parameters<
6382 'a,
6383 > as alloy_sol_types::SolType>::Token<'a>;
6384 type Return = PUBKEY_REGISTRATION_TYPEHASHReturn;
6385 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6386 type ReturnToken<'a> = <Self::ReturnTuple<
6387 'a,
6388 > as alloy_sol_types::SolType>::Token<'a>;
6389 const SIGNATURE: &'static str = "PUBKEY_REGISTRATION_TYPEHASH()";
6390 const SELECTOR: [u8; 4] = [159u8, 234u8, 184u8, 89u8];
6391 #[inline]
6392 fn new<'a>(
6393 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6394 ) -> Self {
6395 tuple.into()
6396 }
6397 #[inline]
6398 fn tokenize(&self) -> Self::Token<'_> {
6399 ()
6400 }
6401 #[inline]
6402 fn abi_decode_returns(
6403 data: &[u8],
6404 validate: bool,
6405 ) -> alloy_sol_types::Result<Self::Return> {
6406 <Self::ReturnTuple<
6407 '_,
6408 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6409 .map(Into::into)
6410 }
6411 }
6412 };
6413 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6414 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6419 #[derive(Clone)]
6420 pub struct allocationManagerCall {}
6421 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6422 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6424 #[derive(Clone)]
6425 pub struct allocationManagerReturn {
6426 #[allow(missing_docs)]
6427 pub _0: alloy::sol_types::private::Address,
6428 }
6429 #[allow(
6430 non_camel_case_types,
6431 non_snake_case,
6432 clippy::pub_underscore_fields,
6433 clippy::style
6434 )]
6435 const _: () = {
6436 use alloy::sol_types as alloy_sol_types;
6437 {
6438 #[doc(hidden)]
6439 type UnderlyingSolTuple<'a> = ();
6440 #[doc(hidden)]
6441 type UnderlyingRustTuple<'a> = ();
6442 #[cfg(test)]
6443 #[allow(dead_code, unreachable_patterns)]
6444 fn _type_assertion(
6445 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6446 ) {
6447 match _t {
6448 alloy_sol_types::private::AssertTypeEq::<
6449 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6450 >(_) => {}
6451 }
6452 }
6453 #[automatically_derived]
6454 #[doc(hidden)]
6455 impl ::core::convert::From<allocationManagerCall>
6456 for UnderlyingRustTuple<'_> {
6457 fn from(value: allocationManagerCall) -> Self {
6458 ()
6459 }
6460 }
6461 #[automatically_derived]
6462 #[doc(hidden)]
6463 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6464 for allocationManagerCall {
6465 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6466 Self {}
6467 }
6468 }
6469 }
6470 {
6471 #[doc(hidden)]
6472 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6473 #[doc(hidden)]
6474 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6475 #[cfg(test)]
6476 #[allow(dead_code, unreachable_patterns)]
6477 fn _type_assertion(
6478 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6479 ) {
6480 match _t {
6481 alloy_sol_types::private::AssertTypeEq::<
6482 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6483 >(_) => {}
6484 }
6485 }
6486 #[automatically_derived]
6487 #[doc(hidden)]
6488 impl ::core::convert::From<allocationManagerReturn>
6489 for UnderlyingRustTuple<'_> {
6490 fn from(value: allocationManagerReturn) -> Self {
6491 (value._0,)
6492 }
6493 }
6494 #[automatically_derived]
6495 #[doc(hidden)]
6496 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6497 for allocationManagerReturn {
6498 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6499 Self { _0: tuple.0 }
6500 }
6501 }
6502 }
6503 #[automatically_derived]
6504 impl alloy_sol_types::SolCall for allocationManagerCall {
6505 type Parameters<'a> = ();
6506 type Token<'a> = <Self::Parameters<
6507 'a,
6508 > as alloy_sol_types::SolType>::Token<'a>;
6509 type Return = allocationManagerReturn;
6510 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
6511 type ReturnToken<'a> = <Self::ReturnTuple<
6512 'a,
6513 > as alloy_sol_types::SolType>::Token<'a>;
6514 const SIGNATURE: &'static str = "allocationManager()";
6515 const SELECTOR: [u8; 4] = [202u8, 138u8, 167u8, 199u8];
6516 #[inline]
6517 fn new<'a>(
6518 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6519 ) -> Self {
6520 tuple.into()
6521 }
6522 #[inline]
6523 fn tokenize(&self) -> Self::Token<'_> {
6524 ()
6525 }
6526 #[inline]
6527 fn abi_decode_returns(
6528 data: &[u8],
6529 validate: bool,
6530 ) -> alloy_sol_types::Result<Self::Return> {
6531 <Self::ReturnTuple<
6532 '_,
6533 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6534 .map(Into::into)
6535 }
6536 }
6537 };
6538 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6539 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6544 #[derive(Clone)]
6545 pub struct avsCall {}
6546 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6547 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6549 #[derive(Clone)]
6550 pub struct avsReturn {
6551 #[allow(missing_docs)]
6552 pub _0: alloy::sol_types::private::Address,
6553 }
6554 #[allow(
6555 non_camel_case_types,
6556 non_snake_case,
6557 clippy::pub_underscore_fields,
6558 clippy::style
6559 )]
6560 const _: () = {
6561 use alloy::sol_types as alloy_sol_types;
6562 {
6563 #[doc(hidden)]
6564 type UnderlyingSolTuple<'a> = ();
6565 #[doc(hidden)]
6566 type UnderlyingRustTuple<'a> = ();
6567 #[cfg(test)]
6568 #[allow(dead_code, unreachable_patterns)]
6569 fn _type_assertion(
6570 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6571 ) {
6572 match _t {
6573 alloy_sol_types::private::AssertTypeEq::<
6574 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6575 >(_) => {}
6576 }
6577 }
6578 #[automatically_derived]
6579 #[doc(hidden)]
6580 impl ::core::convert::From<avsCall> for UnderlyingRustTuple<'_> {
6581 fn from(value: avsCall) -> Self {
6582 ()
6583 }
6584 }
6585 #[automatically_derived]
6586 #[doc(hidden)]
6587 impl ::core::convert::From<UnderlyingRustTuple<'_>> for avsCall {
6588 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6589 Self {}
6590 }
6591 }
6592 }
6593 {
6594 #[doc(hidden)]
6595 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6596 #[doc(hidden)]
6597 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6598 #[cfg(test)]
6599 #[allow(dead_code, unreachable_patterns)]
6600 fn _type_assertion(
6601 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6602 ) {
6603 match _t {
6604 alloy_sol_types::private::AssertTypeEq::<
6605 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6606 >(_) => {}
6607 }
6608 }
6609 #[automatically_derived]
6610 #[doc(hidden)]
6611 impl ::core::convert::From<avsReturn> for UnderlyingRustTuple<'_> {
6612 fn from(value: avsReturn) -> Self {
6613 (value._0,)
6614 }
6615 }
6616 #[automatically_derived]
6617 #[doc(hidden)]
6618 impl ::core::convert::From<UnderlyingRustTuple<'_>> for avsReturn {
6619 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6620 Self { _0: tuple.0 }
6621 }
6622 }
6623 }
6624 #[automatically_derived]
6625 impl alloy_sol_types::SolCall for avsCall {
6626 type Parameters<'a> = ();
6627 type Token<'a> = <Self::Parameters<
6628 'a,
6629 > as alloy_sol_types::SolType>::Token<'a>;
6630 type Return = avsReturn;
6631 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
6632 type ReturnToken<'a> = <Self::ReturnTuple<
6633 'a,
6634 > as alloy_sol_types::SolType>::Token<'a>;
6635 const SIGNATURE: &'static str = "avs()";
6636 const SELECTOR: [u8; 4] = [222u8, 17u8, 100u8, 187u8];
6637 #[inline]
6638 fn new<'a>(
6639 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6640 ) -> Self {
6641 tuple.into()
6642 }
6643 #[inline]
6644 fn tokenize(&self) -> Self::Token<'_> {
6645 ()
6646 }
6647 #[inline]
6648 fn abi_decode_returns(
6649 data: &[u8],
6650 validate: bool,
6651 ) -> alloy_sol_types::Result<Self::Return> {
6652 <Self::ReturnTuple<
6653 '_,
6654 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6655 .map(Into::into)
6656 }
6657 }
6658 };
6659 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6660 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6665 #[derive(Clone)]
6666 pub struct blsApkRegistryCall {}
6667 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6668 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6670 #[derive(Clone)]
6671 pub struct blsApkRegistryReturn {
6672 #[allow(missing_docs)]
6673 pub _0: alloy::sol_types::private::Address,
6674 }
6675 #[allow(
6676 non_camel_case_types,
6677 non_snake_case,
6678 clippy::pub_underscore_fields,
6679 clippy::style
6680 )]
6681 const _: () = {
6682 use alloy::sol_types as alloy_sol_types;
6683 {
6684 #[doc(hidden)]
6685 type UnderlyingSolTuple<'a> = ();
6686 #[doc(hidden)]
6687 type UnderlyingRustTuple<'a> = ();
6688 #[cfg(test)]
6689 #[allow(dead_code, unreachable_patterns)]
6690 fn _type_assertion(
6691 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6692 ) {
6693 match _t {
6694 alloy_sol_types::private::AssertTypeEq::<
6695 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6696 >(_) => {}
6697 }
6698 }
6699 #[automatically_derived]
6700 #[doc(hidden)]
6701 impl ::core::convert::From<blsApkRegistryCall> for UnderlyingRustTuple<'_> {
6702 fn from(value: blsApkRegistryCall) -> Self {
6703 ()
6704 }
6705 }
6706 #[automatically_derived]
6707 #[doc(hidden)]
6708 impl ::core::convert::From<UnderlyingRustTuple<'_>> for blsApkRegistryCall {
6709 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6710 Self {}
6711 }
6712 }
6713 }
6714 {
6715 #[doc(hidden)]
6716 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6717 #[doc(hidden)]
6718 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6719 #[cfg(test)]
6720 #[allow(dead_code, unreachable_patterns)]
6721 fn _type_assertion(
6722 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6723 ) {
6724 match _t {
6725 alloy_sol_types::private::AssertTypeEq::<
6726 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6727 >(_) => {}
6728 }
6729 }
6730 #[automatically_derived]
6731 #[doc(hidden)]
6732 impl ::core::convert::From<blsApkRegistryReturn>
6733 for UnderlyingRustTuple<'_> {
6734 fn from(value: blsApkRegistryReturn) -> Self {
6735 (value._0,)
6736 }
6737 }
6738 #[automatically_derived]
6739 #[doc(hidden)]
6740 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6741 for blsApkRegistryReturn {
6742 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6743 Self { _0: tuple.0 }
6744 }
6745 }
6746 }
6747 #[automatically_derived]
6748 impl alloy_sol_types::SolCall for blsApkRegistryCall {
6749 type Parameters<'a> = ();
6750 type Token<'a> = <Self::Parameters<
6751 'a,
6752 > as alloy_sol_types::SolType>::Token<'a>;
6753 type Return = blsApkRegistryReturn;
6754 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
6755 type ReturnToken<'a> = <Self::ReturnTuple<
6756 'a,
6757 > as alloy_sol_types::SolType>::Token<'a>;
6758 const SIGNATURE: &'static str = "blsApkRegistry()";
6759 const SELECTOR: [u8; 4] = [93u8, 244u8, 89u8, 70u8];
6760 #[inline]
6761 fn new<'a>(
6762 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6763 ) -> Self {
6764 tuple.into()
6765 }
6766 #[inline]
6767 fn tokenize(&self) -> Self::Token<'_> {
6768 ()
6769 }
6770 #[inline]
6771 fn abi_decode_returns(
6772 data: &[u8],
6773 validate: bool,
6774 ) -> alloy_sol_types::Result<Self::Return> {
6775 <Self::ReturnTuple<
6776 '_,
6777 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6778 .map(Into::into)
6779 }
6780 }
6781 };
6782 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6783 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6788 #[derive(Clone)]
6789 pub struct calculateOperatorChurnApprovalDigestHashCall {
6790 #[allow(missing_docs)]
6791 pub registeringOperator: alloy::sol_types::private::Address,
6792 #[allow(missing_docs)]
6793 pub registeringOperatorId: alloy::sol_types::private::FixedBytes<32>,
6794 #[allow(missing_docs)]
6795 pub operatorKickParams: alloy::sol_types::private::Vec<
6796 <ISlashingRegistryCoordinatorTypes::OperatorKickParam as alloy::sol_types::SolType>::RustType,
6797 >,
6798 #[allow(missing_docs)]
6799 pub salt: alloy::sol_types::private::FixedBytes<32>,
6800 #[allow(missing_docs)]
6801 pub expiry: alloy::sol_types::private::primitives::aliases::U256,
6802 }
6803 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6804 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6806 #[derive(Clone)]
6807 pub struct calculateOperatorChurnApprovalDigestHashReturn {
6808 #[allow(missing_docs)]
6809 pub _0: alloy::sol_types::private::FixedBytes<32>,
6810 }
6811 #[allow(
6812 non_camel_case_types,
6813 non_snake_case,
6814 clippy::pub_underscore_fields,
6815 clippy::style
6816 )]
6817 const _: () = {
6818 use alloy::sol_types as alloy_sol_types;
6819 {
6820 #[doc(hidden)]
6821 type UnderlyingSolTuple<'a> = (
6822 alloy::sol_types::sol_data::Address,
6823 alloy::sol_types::sol_data::FixedBytes<32>,
6824 alloy::sol_types::sol_data::Array<
6825 ISlashingRegistryCoordinatorTypes::OperatorKickParam,
6826 >,
6827 alloy::sol_types::sol_data::FixedBytes<32>,
6828 alloy::sol_types::sol_data::Uint<256>,
6829 );
6830 #[doc(hidden)]
6831 type UnderlyingRustTuple<'a> = (
6832 alloy::sol_types::private::Address,
6833 alloy::sol_types::private::FixedBytes<32>,
6834 alloy::sol_types::private::Vec<
6835 <ISlashingRegistryCoordinatorTypes::OperatorKickParam as alloy::sol_types::SolType>::RustType,
6836 >,
6837 alloy::sol_types::private::FixedBytes<32>,
6838 alloy::sol_types::private::primitives::aliases::U256,
6839 );
6840 #[cfg(test)]
6841 #[allow(dead_code, unreachable_patterns)]
6842 fn _type_assertion(
6843 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6844 ) {
6845 match _t {
6846 alloy_sol_types::private::AssertTypeEq::<
6847 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6848 >(_) => {}
6849 }
6850 }
6851 #[automatically_derived]
6852 #[doc(hidden)]
6853 impl ::core::convert::From<calculateOperatorChurnApprovalDigestHashCall>
6854 for UnderlyingRustTuple<'_> {
6855 fn from(value: calculateOperatorChurnApprovalDigestHashCall) -> Self {
6856 (
6857 value.registeringOperator,
6858 value.registeringOperatorId,
6859 value.operatorKickParams,
6860 value.salt,
6861 value.expiry,
6862 )
6863 }
6864 }
6865 #[automatically_derived]
6866 #[doc(hidden)]
6867 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6868 for calculateOperatorChurnApprovalDigestHashCall {
6869 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6870 Self {
6871 registeringOperator: tuple.0,
6872 registeringOperatorId: tuple.1,
6873 operatorKickParams: tuple.2,
6874 salt: tuple.3,
6875 expiry: tuple.4,
6876 }
6877 }
6878 }
6879 }
6880 {
6881 #[doc(hidden)]
6882 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6883 #[doc(hidden)]
6884 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
6885 #[cfg(test)]
6886 #[allow(dead_code, unreachable_patterns)]
6887 fn _type_assertion(
6888 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6889 ) {
6890 match _t {
6891 alloy_sol_types::private::AssertTypeEq::<
6892 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6893 >(_) => {}
6894 }
6895 }
6896 #[automatically_derived]
6897 #[doc(hidden)]
6898 impl ::core::convert::From<calculateOperatorChurnApprovalDigestHashReturn>
6899 for UnderlyingRustTuple<'_> {
6900 fn from(value: calculateOperatorChurnApprovalDigestHashReturn) -> Self {
6901 (value._0,)
6902 }
6903 }
6904 #[automatically_derived]
6905 #[doc(hidden)]
6906 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6907 for calculateOperatorChurnApprovalDigestHashReturn {
6908 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6909 Self { _0: tuple.0 }
6910 }
6911 }
6912 }
6913 #[automatically_derived]
6914 impl alloy_sol_types::SolCall for calculateOperatorChurnApprovalDigestHashCall {
6915 type Parameters<'a> = (
6916 alloy::sol_types::sol_data::Address,
6917 alloy::sol_types::sol_data::FixedBytes<32>,
6918 alloy::sol_types::sol_data::Array<
6919 ISlashingRegistryCoordinatorTypes::OperatorKickParam,
6920 >,
6921 alloy::sol_types::sol_data::FixedBytes<32>,
6922 alloy::sol_types::sol_data::Uint<256>,
6923 );
6924 type Token<'a> = <Self::Parameters<
6925 'a,
6926 > as alloy_sol_types::SolType>::Token<'a>;
6927 type Return = calculateOperatorChurnApprovalDigestHashReturn;
6928 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6929 type ReturnToken<'a> = <Self::ReturnTuple<
6930 'a,
6931 > as alloy_sol_types::SolType>::Token<'a>;
6932 const SIGNATURE: &'static str = "calculateOperatorChurnApprovalDigestHash(address,bytes32,(uint8,address)[],bytes32,uint256)";
6933 const SELECTOR: [u8; 4] = [132u8, 202u8, 82u8, 19u8];
6934 #[inline]
6935 fn new<'a>(
6936 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6937 ) -> Self {
6938 tuple.into()
6939 }
6940 #[inline]
6941 fn tokenize(&self) -> Self::Token<'_> {
6942 (
6943 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6944 &self.registeringOperator,
6945 ),
6946 <alloy::sol_types::sol_data::FixedBytes<
6947 32,
6948 > as alloy_sol_types::SolType>::tokenize(
6949 &self.registeringOperatorId,
6950 ),
6951 <alloy::sol_types::sol_data::Array<
6952 ISlashingRegistryCoordinatorTypes::OperatorKickParam,
6953 > as alloy_sol_types::SolType>::tokenize(&self.operatorKickParams),
6954 <alloy::sol_types::sol_data::FixedBytes<
6955 32,
6956 > as alloy_sol_types::SolType>::tokenize(&self.salt),
6957 <alloy::sol_types::sol_data::Uint<
6958 256,
6959 > as alloy_sol_types::SolType>::tokenize(&self.expiry),
6960 )
6961 }
6962 #[inline]
6963 fn abi_decode_returns(
6964 data: &[u8],
6965 validate: bool,
6966 ) -> alloy_sol_types::Result<Self::Return> {
6967 <Self::ReturnTuple<
6968 '_,
6969 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6970 .map(Into::into)
6971 }
6972 }
6973 };
6974 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6975 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6980 #[derive(Clone)]
6981 pub struct calculatePubkeyRegistrationMessageHashCall {
6982 #[allow(missing_docs)]
6983 pub operator: alloy::sol_types::private::Address,
6984 }
6985 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6986 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6988 #[derive(Clone)]
6989 pub struct calculatePubkeyRegistrationMessageHashReturn {
6990 #[allow(missing_docs)]
6991 pub _0: alloy::sol_types::private::FixedBytes<32>,
6992 }
6993 #[allow(
6994 non_camel_case_types,
6995 non_snake_case,
6996 clippy::pub_underscore_fields,
6997 clippy::style
6998 )]
6999 const _: () = {
7000 use alloy::sol_types as alloy_sol_types;
7001 {
7002 #[doc(hidden)]
7003 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7004 #[doc(hidden)]
7005 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7006 #[cfg(test)]
7007 #[allow(dead_code, unreachable_patterns)]
7008 fn _type_assertion(
7009 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7010 ) {
7011 match _t {
7012 alloy_sol_types::private::AssertTypeEq::<
7013 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7014 >(_) => {}
7015 }
7016 }
7017 #[automatically_derived]
7018 #[doc(hidden)]
7019 impl ::core::convert::From<calculatePubkeyRegistrationMessageHashCall>
7020 for UnderlyingRustTuple<'_> {
7021 fn from(value: calculatePubkeyRegistrationMessageHashCall) -> Self {
7022 (value.operator,)
7023 }
7024 }
7025 #[automatically_derived]
7026 #[doc(hidden)]
7027 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7028 for calculatePubkeyRegistrationMessageHashCall {
7029 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7030 Self { operator: tuple.0 }
7031 }
7032 }
7033 }
7034 {
7035 #[doc(hidden)]
7036 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
7037 #[doc(hidden)]
7038 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
7039 #[cfg(test)]
7040 #[allow(dead_code, unreachable_patterns)]
7041 fn _type_assertion(
7042 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7043 ) {
7044 match _t {
7045 alloy_sol_types::private::AssertTypeEq::<
7046 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7047 >(_) => {}
7048 }
7049 }
7050 #[automatically_derived]
7051 #[doc(hidden)]
7052 impl ::core::convert::From<calculatePubkeyRegistrationMessageHashReturn>
7053 for UnderlyingRustTuple<'_> {
7054 fn from(value: calculatePubkeyRegistrationMessageHashReturn) -> Self {
7055 (value._0,)
7056 }
7057 }
7058 #[automatically_derived]
7059 #[doc(hidden)]
7060 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7061 for calculatePubkeyRegistrationMessageHashReturn {
7062 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7063 Self { _0: tuple.0 }
7064 }
7065 }
7066 }
7067 #[automatically_derived]
7068 impl alloy_sol_types::SolCall for calculatePubkeyRegistrationMessageHashCall {
7069 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
7070 type Token<'a> = <Self::Parameters<
7071 'a,
7072 > as alloy_sol_types::SolType>::Token<'a>;
7073 type Return = calculatePubkeyRegistrationMessageHashReturn;
7074 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
7075 type ReturnToken<'a> = <Self::ReturnTuple<
7076 'a,
7077 > as alloy_sol_types::SolType>::Token<'a>;
7078 const SIGNATURE: &'static str = "calculatePubkeyRegistrationMessageHash(address)";
7079 const SELECTOR: [u8; 4] = [115u8, 68u8, 121u8, 146u8];
7080 #[inline]
7081 fn new<'a>(
7082 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7083 ) -> Self {
7084 tuple.into()
7085 }
7086 #[inline]
7087 fn tokenize(&self) -> Self::Token<'_> {
7088 (
7089 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7090 &self.operator,
7091 ),
7092 )
7093 }
7094 #[inline]
7095 fn abi_decode_returns(
7096 data: &[u8],
7097 validate: bool,
7098 ) -> alloy_sol_types::Result<Self::Return> {
7099 <Self::ReturnTuple<
7100 '_,
7101 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7102 .map(Into::into)
7103 }
7104 }
7105 };
7106 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7107 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7112 #[derive(Clone)]
7113 pub struct churnApproverCall {}
7114 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7115 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7117 #[derive(Clone)]
7118 pub struct churnApproverReturn {
7119 #[allow(missing_docs)]
7120 pub _0: alloy::sol_types::private::Address,
7121 }
7122 #[allow(
7123 non_camel_case_types,
7124 non_snake_case,
7125 clippy::pub_underscore_fields,
7126 clippy::style
7127 )]
7128 const _: () = {
7129 use alloy::sol_types as alloy_sol_types;
7130 {
7131 #[doc(hidden)]
7132 type UnderlyingSolTuple<'a> = ();
7133 #[doc(hidden)]
7134 type UnderlyingRustTuple<'a> = ();
7135 #[cfg(test)]
7136 #[allow(dead_code, unreachable_patterns)]
7137 fn _type_assertion(
7138 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7139 ) {
7140 match _t {
7141 alloy_sol_types::private::AssertTypeEq::<
7142 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7143 >(_) => {}
7144 }
7145 }
7146 #[automatically_derived]
7147 #[doc(hidden)]
7148 impl ::core::convert::From<churnApproverCall> for UnderlyingRustTuple<'_> {
7149 fn from(value: churnApproverCall) -> Self {
7150 ()
7151 }
7152 }
7153 #[automatically_derived]
7154 #[doc(hidden)]
7155 impl ::core::convert::From<UnderlyingRustTuple<'_>> for churnApproverCall {
7156 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7157 Self {}
7158 }
7159 }
7160 }
7161 {
7162 #[doc(hidden)]
7163 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7164 #[doc(hidden)]
7165 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7166 #[cfg(test)]
7167 #[allow(dead_code, unreachable_patterns)]
7168 fn _type_assertion(
7169 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7170 ) {
7171 match _t {
7172 alloy_sol_types::private::AssertTypeEq::<
7173 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7174 >(_) => {}
7175 }
7176 }
7177 #[automatically_derived]
7178 #[doc(hidden)]
7179 impl ::core::convert::From<churnApproverReturn> for UnderlyingRustTuple<'_> {
7180 fn from(value: churnApproverReturn) -> Self {
7181 (value._0,)
7182 }
7183 }
7184 #[automatically_derived]
7185 #[doc(hidden)]
7186 impl ::core::convert::From<UnderlyingRustTuple<'_>> for churnApproverReturn {
7187 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7188 Self { _0: tuple.0 }
7189 }
7190 }
7191 }
7192 #[automatically_derived]
7193 impl alloy_sol_types::SolCall for churnApproverCall {
7194 type Parameters<'a> = ();
7195 type Token<'a> = <Self::Parameters<
7196 'a,
7197 > as alloy_sol_types::SolType>::Token<'a>;
7198 type Return = churnApproverReturn;
7199 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
7200 type ReturnToken<'a> = <Self::ReturnTuple<
7201 'a,
7202 > as alloy_sol_types::SolType>::Token<'a>;
7203 const SIGNATURE: &'static str = "churnApprover()";
7204 const SELECTOR: [u8; 4] = [5u8, 67u8, 16u8, 230u8];
7205 #[inline]
7206 fn new<'a>(
7207 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7208 ) -> Self {
7209 tuple.into()
7210 }
7211 #[inline]
7212 fn tokenize(&self) -> Self::Token<'_> {
7213 ()
7214 }
7215 #[inline]
7216 fn abi_decode_returns(
7217 data: &[u8],
7218 validate: bool,
7219 ) -> alloy_sol_types::Result<Self::Return> {
7220 <Self::ReturnTuple<
7221 '_,
7222 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7223 .map(Into::into)
7224 }
7225 }
7226 };
7227 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7228 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7233 #[derive(Clone)]
7234 pub struct createSlashableStakeQuorumCall {
7235 #[allow(missing_docs)]
7236 pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
7237 #[allow(missing_docs)]
7238 pub minimumStake: alloy::sol_types::private::primitives::aliases::U96,
7239 #[allow(missing_docs)]
7240 pub strategyParams: alloy::sol_types::private::Vec<
7241 <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
7242 >,
7243 #[allow(missing_docs)]
7244 pub lookAheadPeriod: u32,
7245 }
7246 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7248 #[derive(Clone)]
7249 pub struct createSlashableStakeQuorumReturn {}
7250 #[allow(
7251 non_camel_case_types,
7252 non_snake_case,
7253 clippy::pub_underscore_fields,
7254 clippy::style
7255 )]
7256 const _: () = {
7257 use alloy::sol_types as alloy_sol_types;
7258 {
7259 #[doc(hidden)]
7260 type UnderlyingSolTuple<'a> = (
7261 ISlashingRegistryCoordinatorTypes::OperatorSetParam,
7262 alloy::sol_types::sol_data::Uint<96>,
7263 alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
7264 alloy::sol_types::sol_data::Uint<32>,
7265 );
7266 #[doc(hidden)]
7267 type UnderlyingRustTuple<'a> = (
7268 <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
7269 alloy::sol_types::private::primitives::aliases::U96,
7270 alloy::sol_types::private::Vec<
7271 <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
7272 >,
7273 u32,
7274 );
7275 #[cfg(test)]
7276 #[allow(dead_code, unreachable_patterns)]
7277 fn _type_assertion(
7278 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7279 ) {
7280 match _t {
7281 alloy_sol_types::private::AssertTypeEq::<
7282 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7283 >(_) => {}
7284 }
7285 }
7286 #[automatically_derived]
7287 #[doc(hidden)]
7288 impl ::core::convert::From<createSlashableStakeQuorumCall>
7289 for UnderlyingRustTuple<'_> {
7290 fn from(value: createSlashableStakeQuorumCall) -> Self {
7291 (
7292 value.operatorSetParams,
7293 value.minimumStake,
7294 value.strategyParams,
7295 value.lookAheadPeriod,
7296 )
7297 }
7298 }
7299 #[automatically_derived]
7300 #[doc(hidden)]
7301 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7302 for createSlashableStakeQuorumCall {
7303 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7304 Self {
7305 operatorSetParams: tuple.0,
7306 minimumStake: tuple.1,
7307 strategyParams: tuple.2,
7308 lookAheadPeriod: tuple.3,
7309 }
7310 }
7311 }
7312 }
7313 {
7314 #[doc(hidden)]
7315 type UnderlyingSolTuple<'a> = ();
7316 #[doc(hidden)]
7317 type UnderlyingRustTuple<'a> = ();
7318 #[cfg(test)]
7319 #[allow(dead_code, unreachable_patterns)]
7320 fn _type_assertion(
7321 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7322 ) {
7323 match _t {
7324 alloy_sol_types::private::AssertTypeEq::<
7325 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7326 >(_) => {}
7327 }
7328 }
7329 #[automatically_derived]
7330 #[doc(hidden)]
7331 impl ::core::convert::From<createSlashableStakeQuorumReturn>
7332 for UnderlyingRustTuple<'_> {
7333 fn from(value: createSlashableStakeQuorumReturn) -> Self {
7334 ()
7335 }
7336 }
7337 #[automatically_derived]
7338 #[doc(hidden)]
7339 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7340 for createSlashableStakeQuorumReturn {
7341 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7342 Self {}
7343 }
7344 }
7345 }
7346 #[automatically_derived]
7347 impl alloy_sol_types::SolCall for createSlashableStakeQuorumCall {
7348 type Parameters<'a> = (
7349 ISlashingRegistryCoordinatorTypes::OperatorSetParam,
7350 alloy::sol_types::sol_data::Uint<96>,
7351 alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
7352 alloy::sol_types::sol_data::Uint<32>,
7353 );
7354 type Token<'a> = <Self::Parameters<
7355 'a,
7356 > as alloy_sol_types::SolType>::Token<'a>;
7357 type Return = createSlashableStakeQuorumReturn;
7358 type ReturnTuple<'a> = ();
7359 type ReturnToken<'a> = <Self::ReturnTuple<
7360 'a,
7361 > as alloy_sol_types::SolType>::Token<'a>;
7362 const SIGNATURE: &'static str = "createSlashableStakeQuorum((uint32,uint16,uint16),uint96,(address,uint96)[],uint32)";
7363 const SELECTOR: [u8; 4] = [62u8, 239u8, 58u8, 81u8];
7364 #[inline]
7365 fn new<'a>(
7366 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7367 ) -> Self {
7368 tuple.into()
7369 }
7370 #[inline]
7371 fn tokenize(&self) -> Self::Token<'_> {
7372 (
7373 <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
7374 &self.operatorSetParams,
7375 ),
7376 <alloy::sol_types::sol_data::Uint<
7377 96,
7378 > as alloy_sol_types::SolType>::tokenize(&self.minimumStake),
7379 <alloy::sol_types::sol_data::Array<
7380 IStakeRegistryTypes::StrategyParams,
7381 > as alloy_sol_types::SolType>::tokenize(&self.strategyParams),
7382 <alloy::sol_types::sol_data::Uint<
7383 32,
7384 > as alloy_sol_types::SolType>::tokenize(&self.lookAheadPeriod),
7385 )
7386 }
7387 #[inline]
7388 fn abi_decode_returns(
7389 data: &[u8],
7390 validate: bool,
7391 ) -> alloy_sol_types::Result<Self::Return> {
7392 <Self::ReturnTuple<
7393 '_,
7394 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7395 .map(Into::into)
7396 }
7397 }
7398 };
7399 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7400 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7405 #[derive(Clone)]
7406 pub struct createTotalDelegatedStakeQuorumCall {
7407 #[allow(missing_docs)]
7408 pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
7409 #[allow(missing_docs)]
7410 pub minimumStake: alloy::sol_types::private::primitives::aliases::U96,
7411 #[allow(missing_docs)]
7412 pub strategyParams: alloy::sol_types::private::Vec<
7413 <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
7414 >,
7415 }
7416 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7418 #[derive(Clone)]
7419 pub struct createTotalDelegatedStakeQuorumReturn {}
7420 #[allow(
7421 non_camel_case_types,
7422 non_snake_case,
7423 clippy::pub_underscore_fields,
7424 clippy::style
7425 )]
7426 const _: () = {
7427 use alloy::sol_types as alloy_sol_types;
7428 {
7429 #[doc(hidden)]
7430 type UnderlyingSolTuple<'a> = (
7431 ISlashingRegistryCoordinatorTypes::OperatorSetParam,
7432 alloy::sol_types::sol_data::Uint<96>,
7433 alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
7434 );
7435 #[doc(hidden)]
7436 type UnderlyingRustTuple<'a> = (
7437 <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
7438 alloy::sol_types::private::primitives::aliases::U96,
7439 alloy::sol_types::private::Vec<
7440 <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
7441 >,
7442 );
7443 #[cfg(test)]
7444 #[allow(dead_code, unreachable_patterns)]
7445 fn _type_assertion(
7446 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7447 ) {
7448 match _t {
7449 alloy_sol_types::private::AssertTypeEq::<
7450 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7451 >(_) => {}
7452 }
7453 }
7454 #[automatically_derived]
7455 #[doc(hidden)]
7456 impl ::core::convert::From<createTotalDelegatedStakeQuorumCall>
7457 for UnderlyingRustTuple<'_> {
7458 fn from(value: createTotalDelegatedStakeQuorumCall) -> Self {
7459 (value.operatorSetParams, value.minimumStake, value.strategyParams)
7460 }
7461 }
7462 #[automatically_derived]
7463 #[doc(hidden)]
7464 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7465 for createTotalDelegatedStakeQuorumCall {
7466 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7467 Self {
7468 operatorSetParams: tuple.0,
7469 minimumStake: tuple.1,
7470 strategyParams: tuple.2,
7471 }
7472 }
7473 }
7474 }
7475 {
7476 #[doc(hidden)]
7477 type UnderlyingSolTuple<'a> = ();
7478 #[doc(hidden)]
7479 type UnderlyingRustTuple<'a> = ();
7480 #[cfg(test)]
7481 #[allow(dead_code, unreachable_patterns)]
7482 fn _type_assertion(
7483 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7484 ) {
7485 match _t {
7486 alloy_sol_types::private::AssertTypeEq::<
7487 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7488 >(_) => {}
7489 }
7490 }
7491 #[automatically_derived]
7492 #[doc(hidden)]
7493 impl ::core::convert::From<createTotalDelegatedStakeQuorumReturn>
7494 for UnderlyingRustTuple<'_> {
7495 fn from(value: createTotalDelegatedStakeQuorumReturn) -> Self {
7496 ()
7497 }
7498 }
7499 #[automatically_derived]
7500 #[doc(hidden)]
7501 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7502 for createTotalDelegatedStakeQuorumReturn {
7503 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7504 Self {}
7505 }
7506 }
7507 }
7508 #[automatically_derived]
7509 impl alloy_sol_types::SolCall for createTotalDelegatedStakeQuorumCall {
7510 type Parameters<'a> = (
7511 ISlashingRegistryCoordinatorTypes::OperatorSetParam,
7512 alloy::sol_types::sol_data::Uint<96>,
7513 alloy::sol_types::sol_data::Array<IStakeRegistryTypes::StrategyParams>,
7514 );
7515 type Token<'a> = <Self::Parameters<
7516 'a,
7517 > as alloy_sol_types::SolType>::Token<'a>;
7518 type Return = createTotalDelegatedStakeQuorumReturn;
7519 type ReturnTuple<'a> = ();
7520 type ReturnToken<'a> = <Self::ReturnTuple<
7521 'a,
7522 > as alloy_sol_types::SolType>::Token<'a>;
7523 const SIGNATURE: &'static str = "createTotalDelegatedStakeQuorum((uint32,uint16,uint16),uint96,(address,uint96)[])";
7524 const SELECTOR: [u8; 4] = [130u8, 129u8, 171u8, 117u8];
7525 #[inline]
7526 fn new<'a>(
7527 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7528 ) -> Self {
7529 tuple.into()
7530 }
7531 #[inline]
7532 fn tokenize(&self) -> Self::Token<'_> {
7533 (
7534 <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
7535 &self.operatorSetParams,
7536 ),
7537 <alloy::sol_types::sol_data::Uint<
7538 96,
7539 > as alloy_sol_types::SolType>::tokenize(&self.minimumStake),
7540 <alloy::sol_types::sol_data::Array<
7541 IStakeRegistryTypes::StrategyParams,
7542 > as alloy_sol_types::SolType>::tokenize(&self.strategyParams),
7543 )
7544 }
7545 #[inline]
7546 fn abi_decode_returns(
7547 data: &[u8],
7548 validate: bool,
7549 ) -> alloy_sol_types::Result<Self::Return> {
7550 <Self::ReturnTuple<
7551 '_,
7552 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7553 .map(Into::into)
7554 }
7555 }
7556 };
7557 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7558 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7563 #[derive(Clone)]
7564 pub struct deregisterOperatorCall {
7565 #[allow(missing_docs)]
7566 pub operator: alloy::sol_types::private::Address,
7567 #[allow(missing_docs)]
7568 pub avs: alloy::sol_types::private::Address,
7569 #[allow(missing_docs)]
7570 pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
7571 }
7572 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7574 #[derive(Clone)]
7575 pub struct deregisterOperatorReturn {}
7576 #[allow(
7577 non_camel_case_types,
7578 non_snake_case,
7579 clippy::pub_underscore_fields,
7580 clippy::style
7581 )]
7582 const _: () = {
7583 use alloy::sol_types as alloy_sol_types;
7584 {
7585 #[doc(hidden)]
7586 type UnderlyingSolTuple<'a> = (
7587 alloy::sol_types::sol_data::Address,
7588 alloy::sol_types::sol_data::Address,
7589 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
7590 );
7591 #[doc(hidden)]
7592 type UnderlyingRustTuple<'a> = (
7593 alloy::sol_types::private::Address,
7594 alloy::sol_types::private::Address,
7595 alloy::sol_types::private::Vec<u32>,
7596 );
7597 #[cfg(test)]
7598 #[allow(dead_code, unreachable_patterns)]
7599 fn _type_assertion(
7600 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7601 ) {
7602 match _t {
7603 alloy_sol_types::private::AssertTypeEq::<
7604 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7605 >(_) => {}
7606 }
7607 }
7608 #[automatically_derived]
7609 #[doc(hidden)]
7610 impl ::core::convert::From<deregisterOperatorCall>
7611 for UnderlyingRustTuple<'_> {
7612 fn from(value: deregisterOperatorCall) -> Self {
7613 (value.operator, value.avs, value.operatorSetIds)
7614 }
7615 }
7616 #[automatically_derived]
7617 #[doc(hidden)]
7618 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7619 for deregisterOperatorCall {
7620 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7621 Self {
7622 operator: tuple.0,
7623 avs: tuple.1,
7624 operatorSetIds: tuple.2,
7625 }
7626 }
7627 }
7628 }
7629 {
7630 #[doc(hidden)]
7631 type UnderlyingSolTuple<'a> = ();
7632 #[doc(hidden)]
7633 type UnderlyingRustTuple<'a> = ();
7634 #[cfg(test)]
7635 #[allow(dead_code, unreachable_patterns)]
7636 fn _type_assertion(
7637 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7638 ) {
7639 match _t {
7640 alloy_sol_types::private::AssertTypeEq::<
7641 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7642 >(_) => {}
7643 }
7644 }
7645 #[automatically_derived]
7646 #[doc(hidden)]
7647 impl ::core::convert::From<deregisterOperatorReturn>
7648 for UnderlyingRustTuple<'_> {
7649 fn from(value: deregisterOperatorReturn) -> Self {
7650 ()
7651 }
7652 }
7653 #[automatically_derived]
7654 #[doc(hidden)]
7655 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7656 for deregisterOperatorReturn {
7657 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7658 Self {}
7659 }
7660 }
7661 }
7662 #[automatically_derived]
7663 impl alloy_sol_types::SolCall for deregisterOperatorCall {
7664 type Parameters<'a> = (
7665 alloy::sol_types::sol_data::Address,
7666 alloy::sol_types::sol_data::Address,
7667 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
7668 );
7669 type Token<'a> = <Self::Parameters<
7670 'a,
7671 > as alloy_sol_types::SolType>::Token<'a>;
7672 type Return = deregisterOperatorReturn;
7673 type ReturnTuple<'a> = ();
7674 type ReturnToken<'a> = <Self::ReturnTuple<
7675 'a,
7676 > as alloy_sol_types::SolType>::Token<'a>;
7677 const SIGNATURE: &'static str = "deregisterOperator(address,address,uint32[])";
7678 const SELECTOR: [u8; 4] = [48u8, 60u8, 169u8, 86u8];
7679 #[inline]
7680 fn new<'a>(
7681 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7682 ) -> Self {
7683 tuple.into()
7684 }
7685 #[inline]
7686 fn tokenize(&self) -> Self::Token<'_> {
7687 (
7688 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7689 &self.operator,
7690 ),
7691 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7692 &self.avs,
7693 ),
7694 <alloy::sol_types::sol_data::Array<
7695 alloy::sol_types::sol_data::Uint<32>,
7696 > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
7697 )
7698 }
7699 #[inline]
7700 fn abi_decode_returns(
7701 data: &[u8],
7702 validate: bool,
7703 ) -> alloy_sol_types::Result<Self::Return> {
7704 <Self::ReturnTuple<
7705 '_,
7706 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7707 .map(Into::into)
7708 }
7709 }
7710 };
7711 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7712 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7717 #[derive(Clone)]
7718 pub struct ejectOperatorCall {
7719 #[allow(missing_docs)]
7720 pub operator: alloy::sol_types::private::Address,
7721 #[allow(missing_docs)]
7722 pub quorumNumbers: alloy::sol_types::private::Bytes,
7723 }
7724 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7726 #[derive(Clone)]
7727 pub struct ejectOperatorReturn {}
7728 #[allow(
7729 non_camel_case_types,
7730 non_snake_case,
7731 clippy::pub_underscore_fields,
7732 clippy::style
7733 )]
7734 const _: () = {
7735 use alloy::sol_types as alloy_sol_types;
7736 {
7737 #[doc(hidden)]
7738 type UnderlyingSolTuple<'a> = (
7739 alloy::sol_types::sol_data::Address,
7740 alloy::sol_types::sol_data::Bytes,
7741 );
7742 #[doc(hidden)]
7743 type UnderlyingRustTuple<'a> = (
7744 alloy::sol_types::private::Address,
7745 alloy::sol_types::private::Bytes,
7746 );
7747 #[cfg(test)]
7748 #[allow(dead_code, unreachable_patterns)]
7749 fn _type_assertion(
7750 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7751 ) {
7752 match _t {
7753 alloy_sol_types::private::AssertTypeEq::<
7754 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7755 >(_) => {}
7756 }
7757 }
7758 #[automatically_derived]
7759 #[doc(hidden)]
7760 impl ::core::convert::From<ejectOperatorCall> for UnderlyingRustTuple<'_> {
7761 fn from(value: ejectOperatorCall) -> Self {
7762 (value.operator, value.quorumNumbers)
7763 }
7764 }
7765 #[automatically_derived]
7766 #[doc(hidden)]
7767 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ejectOperatorCall {
7768 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7769 Self {
7770 operator: tuple.0,
7771 quorumNumbers: tuple.1,
7772 }
7773 }
7774 }
7775 }
7776 {
7777 #[doc(hidden)]
7778 type UnderlyingSolTuple<'a> = ();
7779 #[doc(hidden)]
7780 type UnderlyingRustTuple<'a> = ();
7781 #[cfg(test)]
7782 #[allow(dead_code, unreachable_patterns)]
7783 fn _type_assertion(
7784 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7785 ) {
7786 match _t {
7787 alloy_sol_types::private::AssertTypeEq::<
7788 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7789 >(_) => {}
7790 }
7791 }
7792 #[automatically_derived]
7793 #[doc(hidden)]
7794 impl ::core::convert::From<ejectOperatorReturn> for UnderlyingRustTuple<'_> {
7795 fn from(value: ejectOperatorReturn) -> Self {
7796 ()
7797 }
7798 }
7799 #[automatically_derived]
7800 #[doc(hidden)]
7801 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ejectOperatorReturn {
7802 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7803 Self {}
7804 }
7805 }
7806 }
7807 #[automatically_derived]
7808 impl alloy_sol_types::SolCall for ejectOperatorCall {
7809 type Parameters<'a> = (
7810 alloy::sol_types::sol_data::Address,
7811 alloy::sol_types::sol_data::Bytes,
7812 );
7813 type Token<'a> = <Self::Parameters<
7814 'a,
7815 > as alloy_sol_types::SolType>::Token<'a>;
7816 type Return = ejectOperatorReturn;
7817 type ReturnTuple<'a> = ();
7818 type ReturnToken<'a> = <Self::ReturnTuple<
7819 'a,
7820 > as alloy_sol_types::SolType>::Token<'a>;
7821 const SIGNATURE: &'static str = "ejectOperator(address,bytes)";
7822 const SELECTOR: [u8; 4] = [110u8, 59u8, 23u8, 219u8];
7823 #[inline]
7824 fn new<'a>(
7825 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7826 ) -> Self {
7827 tuple.into()
7828 }
7829 #[inline]
7830 fn tokenize(&self) -> Self::Token<'_> {
7831 (
7832 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7833 &self.operator,
7834 ),
7835 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
7836 &self.quorumNumbers,
7837 ),
7838 )
7839 }
7840 #[inline]
7841 fn abi_decode_returns(
7842 data: &[u8],
7843 validate: bool,
7844 ) -> alloy_sol_types::Result<Self::Return> {
7845 <Self::ReturnTuple<
7846 '_,
7847 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7848 .map(Into::into)
7849 }
7850 }
7851 };
7852 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7853 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7858 #[derive(Clone)]
7859 pub struct ejectionCooldownCall {}
7860 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7861 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7863 #[derive(Clone)]
7864 pub struct ejectionCooldownReturn {
7865 #[allow(missing_docs)]
7866 pub _0: alloy::sol_types::private::primitives::aliases::U256,
7867 }
7868 #[allow(
7869 non_camel_case_types,
7870 non_snake_case,
7871 clippy::pub_underscore_fields,
7872 clippy::style
7873 )]
7874 const _: () = {
7875 use alloy::sol_types as alloy_sol_types;
7876 {
7877 #[doc(hidden)]
7878 type UnderlyingSolTuple<'a> = ();
7879 #[doc(hidden)]
7880 type UnderlyingRustTuple<'a> = ();
7881 #[cfg(test)]
7882 #[allow(dead_code, unreachable_patterns)]
7883 fn _type_assertion(
7884 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7885 ) {
7886 match _t {
7887 alloy_sol_types::private::AssertTypeEq::<
7888 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7889 >(_) => {}
7890 }
7891 }
7892 #[automatically_derived]
7893 #[doc(hidden)]
7894 impl ::core::convert::From<ejectionCooldownCall>
7895 for UnderlyingRustTuple<'_> {
7896 fn from(value: ejectionCooldownCall) -> Self {
7897 ()
7898 }
7899 }
7900 #[automatically_derived]
7901 #[doc(hidden)]
7902 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7903 for ejectionCooldownCall {
7904 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7905 Self {}
7906 }
7907 }
7908 }
7909 {
7910 #[doc(hidden)]
7911 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7912 #[doc(hidden)]
7913 type UnderlyingRustTuple<'a> = (
7914 alloy::sol_types::private::primitives::aliases::U256,
7915 );
7916 #[cfg(test)]
7917 #[allow(dead_code, unreachable_patterns)]
7918 fn _type_assertion(
7919 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7920 ) {
7921 match _t {
7922 alloy_sol_types::private::AssertTypeEq::<
7923 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7924 >(_) => {}
7925 }
7926 }
7927 #[automatically_derived]
7928 #[doc(hidden)]
7929 impl ::core::convert::From<ejectionCooldownReturn>
7930 for UnderlyingRustTuple<'_> {
7931 fn from(value: ejectionCooldownReturn) -> Self {
7932 (value._0,)
7933 }
7934 }
7935 #[automatically_derived]
7936 #[doc(hidden)]
7937 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7938 for ejectionCooldownReturn {
7939 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7940 Self { _0: tuple.0 }
7941 }
7942 }
7943 }
7944 #[automatically_derived]
7945 impl alloy_sol_types::SolCall for ejectionCooldownCall {
7946 type Parameters<'a> = ();
7947 type Token<'a> = <Self::Parameters<
7948 'a,
7949 > as alloy_sol_types::SolType>::Token<'a>;
7950 type Return = ejectionCooldownReturn;
7951 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7952 type ReturnToken<'a> = <Self::ReturnTuple<
7953 'a,
7954 > as alloy_sol_types::SolType>::Token<'a>;
7955 const SIGNATURE: &'static str = "ejectionCooldown()";
7956 const SELECTOR: [u8; 4] = [169u8, 111u8, 120u8, 62u8];
7957 #[inline]
7958 fn new<'a>(
7959 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7960 ) -> Self {
7961 tuple.into()
7962 }
7963 #[inline]
7964 fn tokenize(&self) -> Self::Token<'_> {
7965 ()
7966 }
7967 #[inline]
7968 fn abi_decode_returns(
7969 data: &[u8],
7970 validate: bool,
7971 ) -> alloy_sol_types::Result<Self::Return> {
7972 <Self::ReturnTuple<
7973 '_,
7974 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7975 .map(Into::into)
7976 }
7977 }
7978 };
7979 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7980 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7985 #[derive(Clone)]
7986 pub struct ejectorCall {}
7987 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7988 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7990 #[derive(Clone)]
7991 pub struct ejectorReturn {
7992 #[allow(missing_docs)]
7993 pub _0: alloy::sol_types::private::Address,
7994 }
7995 #[allow(
7996 non_camel_case_types,
7997 non_snake_case,
7998 clippy::pub_underscore_fields,
7999 clippy::style
8000 )]
8001 const _: () = {
8002 use alloy::sol_types as alloy_sol_types;
8003 {
8004 #[doc(hidden)]
8005 type UnderlyingSolTuple<'a> = ();
8006 #[doc(hidden)]
8007 type UnderlyingRustTuple<'a> = ();
8008 #[cfg(test)]
8009 #[allow(dead_code, unreachable_patterns)]
8010 fn _type_assertion(
8011 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8012 ) {
8013 match _t {
8014 alloy_sol_types::private::AssertTypeEq::<
8015 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8016 >(_) => {}
8017 }
8018 }
8019 #[automatically_derived]
8020 #[doc(hidden)]
8021 impl ::core::convert::From<ejectorCall> for UnderlyingRustTuple<'_> {
8022 fn from(value: ejectorCall) -> Self {
8023 ()
8024 }
8025 }
8026 #[automatically_derived]
8027 #[doc(hidden)]
8028 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ejectorCall {
8029 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8030 Self {}
8031 }
8032 }
8033 }
8034 {
8035 #[doc(hidden)]
8036 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8037 #[doc(hidden)]
8038 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8039 #[cfg(test)]
8040 #[allow(dead_code, unreachable_patterns)]
8041 fn _type_assertion(
8042 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8043 ) {
8044 match _t {
8045 alloy_sol_types::private::AssertTypeEq::<
8046 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8047 >(_) => {}
8048 }
8049 }
8050 #[automatically_derived]
8051 #[doc(hidden)]
8052 impl ::core::convert::From<ejectorReturn> for UnderlyingRustTuple<'_> {
8053 fn from(value: ejectorReturn) -> Self {
8054 (value._0,)
8055 }
8056 }
8057 #[automatically_derived]
8058 #[doc(hidden)]
8059 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ejectorReturn {
8060 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8061 Self { _0: tuple.0 }
8062 }
8063 }
8064 }
8065 #[automatically_derived]
8066 impl alloy_sol_types::SolCall for ejectorCall {
8067 type Parameters<'a> = ();
8068 type Token<'a> = <Self::Parameters<
8069 'a,
8070 > as alloy_sol_types::SolType>::Token<'a>;
8071 type Return = ejectorReturn;
8072 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
8073 type ReturnToken<'a> = <Self::ReturnTuple<
8074 'a,
8075 > as alloy_sol_types::SolType>::Token<'a>;
8076 const SIGNATURE: &'static str = "ejector()";
8077 const SELECTOR: [u8; 4] = [40u8, 246u8, 27u8, 49u8];
8078 #[inline]
8079 fn new<'a>(
8080 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8081 ) -> Self {
8082 tuple.into()
8083 }
8084 #[inline]
8085 fn tokenize(&self) -> Self::Token<'_> {
8086 ()
8087 }
8088 #[inline]
8089 fn abi_decode_returns(
8090 data: &[u8],
8091 validate: bool,
8092 ) -> alloy_sol_types::Result<Self::Return> {
8093 <Self::ReturnTuple<
8094 '_,
8095 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8096 .map(Into::into)
8097 }
8098 }
8099 };
8100 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8101 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8106 #[derive(Clone)]
8107 pub struct getCurrentQuorumBitmapCall {
8108 #[allow(missing_docs)]
8109 pub operatorId: alloy::sol_types::private::FixedBytes<32>,
8110 }
8111 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8112 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8114 #[derive(Clone)]
8115 pub struct getCurrentQuorumBitmapReturn {
8116 #[allow(missing_docs)]
8117 pub _0: alloy::sol_types::private::primitives::aliases::U192,
8118 }
8119 #[allow(
8120 non_camel_case_types,
8121 non_snake_case,
8122 clippy::pub_underscore_fields,
8123 clippy::style
8124 )]
8125 const _: () = {
8126 use alloy::sol_types as alloy_sol_types;
8127 {
8128 #[doc(hidden)]
8129 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8130 #[doc(hidden)]
8131 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
8132 #[cfg(test)]
8133 #[allow(dead_code, unreachable_patterns)]
8134 fn _type_assertion(
8135 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8136 ) {
8137 match _t {
8138 alloy_sol_types::private::AssertTypeEq::<
8139 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8140 >(_) => {}
8141 }
8142 }
8143 #[automatically_derived]
8144 #[doc(hidden)]
8145 impl ::core::convert::From<getCurrentQuorumBitmapCall>
8146 for UnderlyingRustTuple<'_> {
8147 fn from(value: getCurrentQuorumBitmapCall) -> Self {
8148 (value.operatorId,)
8149 }
8150 }
8151 #[automatically_derived]
8152 #[doc(hidden)]
8153 impl ::core::convert::From<UnderlyingRustTuple<'_>>
8154 for getCurrentQuorumBitmapCall {
8155 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8156 Self { operatorId: tuple.0 }
8157 }
8158 }
8159 }
8160 {
8161 #[doc(hidden)]
8162 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<192>,);
8163 #[doc(hidden)]
8164 type UnderlyingRustTuple<'a> = (
8165 alloy::sol_types::private::primitives::aliases::U192,
8166 );
8167 #[cfg(test)]
8168 #[allow(dead_code, unreachable_patterns)]
8169 fn _type_assertion(
8170 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8171 ) {
8172 match _t {
8173 alloy_sol_types::private::AssertTypeEq::<
8174 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8175 >(_) => {}
8176 }
8177 }
8178 #[automatically_derived]
8179 #[doc(hidden)]
8180 impl ::core::convert::From<getCurrentQuorumBitmapReturn>
8181 for UnderlyingRustTuple<'_> {
8182 fn from(value: getCurrentQuorumBitmapReturn) -> Self {
8183 (value._0,)
8184 }
8185 }
8186 #[automatically_derived]
8187 #[doc(hidden)]
8188 impl ::core::convert::From<UnderlyingRustTuple<'_>>
8189 for getCurrentQuorumBitmapReturn {
8190 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8191 Self { _0: tuple.0 }
8192 }
8193 }
8194 }
8195 #[automatically_derived]
8196 impl alloy_sol_types::SolCall for getCurrentQuorumBitmapCall {
8197 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8198 type Token<'a> = <Self::Parameters<
8199 'a,
8200 > as alloy_sol_types::SolType>::Token<'a>;
8201 type Return = getCurrentQuorumBitmapReturn;
8202 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<192>,);
8203 type ReturnToken<'a> = <Self::ReturnTuple<
8204 'a,
8205 > as alloy_sol_types::SolType>::Token<'a>;
8206 const SIGNATURE: &'static str = "getCurrentQuorumBitmap(bytes32)";
8207 const SELECTOR: [u8; 4] = [135u8, 30u8, 240u8, 73u8];
8208 #[inline]
8209 fn new<'a>(
8210 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8211 ) -> Self {
8212 tuple.into()
8213 }
8214 #[inline]
8215 fn tokenize(&self) -> Self::Token<'_> {
8216 (
8217 <alloy::sol_types::sol_data::FixedBytes<
8218 32,
8219 > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
8220 )
8221 }
8222 #[inline]
8223 fn abi_decode_returns(
8224 data: &[u8],
8225 validate: bool,
8226 ) -> alloy_sol_types::Result<Self::Return> {
8227 <Self::ReturnTuple<
8228 '_,
8229 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8230 .map(Into::into)
8231 }
8232 }
8233 };
8234 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8235 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8240 #[derive(Clone)]
8241 pub struct getOperatorCall {
8242 #[allow(missing_docs)]
8243 pub operator: alloy::sol_types::private::Address,
8244 }
8245 #[derive()]
8246 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8248 #[derive(Clone)]
8249 pub struct getOperatorReturn {
8250 #[allow(missing_docs)]
8251 pub _0: <ISlashingRegistryCoordinatorTypes::OperatorInfo as alloy::sol_types::SolType>::RustType,
8252 }
8253 #[allow(
8254 non_camel_case_types,
8255 non_snake_case,
8256 clippy::pub_underscore_fields,
8257 clippy::style
8258 )]
8259 const _: () = {
8260 use alloy::sol_types as alloy_sol_types;
8261 {
8262 #[doc(hidden)]
8263 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8264 #[doc(hidden)]
8265 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8266 #[cfg(test)]
8267 #[allow(dead_code, unreachable_patterns)]
8268 fn _type_assertion(
8269 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8270 ) {
8271 match _t {
8272 alloy_sol_types::private::AssertTypeEq::<
8273 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8274 >(_) => {}
8275 }
8276 }
8277 #[automatically_derived]
8278 #[doc(hidden)]
8279 impl ::core::convert::From<getOperatorCall> for UnderlyingRustTuple<'_> {
8280 fn from(value: getOperatorCall) -> Self {
8281 (value.operator,)
8282 }
8283 }
8284 #[automatically_derived]
8285 #[doc(hidden)]
8286 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorCall {
8287 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8288 Self { operator: tuple.0 }
8289 }
8290 }
8291 }
8292 {
8293 #[doc(hidden)]
8294 type UnderlyingSolTuple<'a> = (
8295 ISlashingRegistryCoordinatorTypes::OperatorInfo,
8296 );
8297 #[doc(hidden)]
8298 type UnderlyingRustTuple<'a> = (
8299 <ISlashingRegistryCoordinatorTypes::OperatorInfo as alloy::sol_types::SolType>::RustType,
8300 );
8301 #[cfg(test)]
8302 #[allow(dead_code, unreachable_patterns)]
8303 fn _type_assertion(
8304 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8305 ) {
8306 match _t {
8307 alloy_sol_types::private::AssertTypeEq::<
8308 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8309 >(_) => {}
8310 }
8311 }
8312 #[automatically_derived]
8313 #[doc(hidden)]
8314 impl ::core::convert::From<getOperatorReturn> for UnderlyingRustTuple<'_> {
8315 fn from(value: getOperatorReturn) -> Self {
8316 (value._0,)
8317 }
8318 }
8319 #[automatically_derived]
8320 #[doc(hidden)]
8321 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorReturn {
8322 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8323 Self { _0: tuple.0 }
8324 }
8325 }
8326 }
8327 #[automatically_derived]
8328 impl alloy_sol_types::SolCall for getOperatorCall {
8329 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
8330 type Token<'a> = <Self::Parameters<
8331 'a,
8332 > as alloy_sol_types::SolType>::Token<'a>;
8333 type Return = getOperatorReturn;
8334 type ReturnTuple<'a> = (ISlashingRegistryCoordinatorTypes::OperatorInfo,);
8335 type ReturnToken<'a> = <Self::ReturnTuple<
8336 'a,
8337 > as alloy_sol_types::SolType>::Token<'a>;
8338 const SIGNATURE: &'static str = "getOperator(address)";
8339 const SELECTOR: [u8; 4] = [88u8, 101u8, 198u8, 12u8];
8340 #[inline]
8341 fn new<'a>(
8342 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8343 ) -> Self {
8344 tuple.into()
8345 }
8346 #[inline]
8347 fn tokenize(&self) -> Self::Token<'_> {
8348 (
8349 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8350 &self.operator,
8351 ),
8352 )
8353 }
8354 #[inline]
8355 fn abi_decode_returns(
8356 data: &[u8],
8357 validate: bool,
8358 ) -> alloy_sol_types::Result<Self::Return> {
8359 <Self::ReturnTuple<
8360 '_,
8361 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8362 .map(Into::into)
8363 }
8364 }
8365 };
8366 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8367 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8372 #[derive(Clone)]
8373 pub struct getOperatorFromIdCall {
8374 #[allow(missing_docs)]
8375 pub operatorId: alloy::sol_types::private::FixedBytes<32>,
8376 }
8377 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8378 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8380 #[derive(Clone)]
8381 pub struct getOperatorFromIdReturn {
8382 #[allow(missing_docs)]
8383 pub _0: alloy::sol_types::private::Address,
8384 }
8385 #[allow(
8386 non_camel_case_types,
8387 non_snake_case,
8388 clippy::pub_underscore_fields,
8389 clippy::style
8390 )]
8391 const _: () = {
8392 use alloy::sol_types as alloy_sol_types;
8393 {
8394 #[doc(hidden)]
8395 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8396 #[doc(hidden)]
8397 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
8398 #[cfg(test)]
8399 #[allow(dead_code, unreachable_patterns)]
8400 fn _type_assertion(
8401 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8402 ) {
8403 match _t {
8404 alloy_sol_types::private::AssertTypeEq::<
8405 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8406 >(_) => {}
8407 }
8408 }
8409 #[automatically_derived]
8410 #[doc(hidden)]
8411 impl ::core::convert::From<getOperatorFromIdCall>
8412 for UnderlyingRustTuple<'_> {
8413 fn from(value: getOperatorFromIdCall) -> Self {
8414 (value.operatorId,)
8415 }
8416 }
8417 #[automatically_derived]
8418 #[doc(hidden)]
8419 impl ::core::convert::From<UnderlyingRustTuple<'_>>
8420 for getOperatorFromIdCall {
8421 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8422 Self { operatorId: tuple.0 }
8423 }
8424 }
8425 }
8426 {
8427 #[doc(hidden)]
8428 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8429 #[doc(hidden)]
8430 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8431 #[cfg(test)]
8432 #[allow(dead_code, unreachable_patterns)]
8433 fn _type_assertion(
8434 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8435 ) {
8436 match _t {
8437 alloy_sol_types::private::AssertTypeEq::<
8438 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8439 >(_) => {}
8440 }
8441 }
8442 #[automatically_derived]
8443 #[doc(hidden)]
8444 impl ::core::convert::From<getOperatorFromIdReturn>
8445 for UnderlyingRustTuple<'_> {
8446 fn from(value: getOperatorFromIdReturn) -> Self {
8447 (value._0,)
8448 }
8449 }
8450 #[automatically_derived]
8451 #[doc(hidden)]
8452 impl ::core::convert::From<UnderlyingRustTuple<'_>>
8453 for getOperatorFromIdReturn {
8454 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8455 Self { _0: tuple.0 }
8456 }
8457 }
8458 }
8459 #[automatically_derived]
8460 impl alloy_sol_types::SolCall for getOperatorFromIdCall {
8461 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8462 type Token<'a> = <Self::Parameters<
8463 'a,
8464 > as alloy_sol_types::SolType>::Token<'a>;
8465 type Return = getOperatorFromIdReturn;
8466 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
8467 type ReturnToken<'a> = <Self::ReturnTuple<
8468 'a,
8469 > as alloy_sol_types::SolType>::Token<'a>;
8470 const SIGNATURE: &'static str = "getOperatorFromId(bytes32)";
8471 const SELECTOR: [u8; 4] = [41u8, 107u8, 176u8, 100u8];
8472 #[inline]
8473 fn new<'a>(
8474 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8475 ) -> Self {
8476 tuple.into()
8477 }
8478 #[inline]
8479 fn tokenize(&self) -> Self::Token<'_> {
8480 (
8481 <alloy::sol_types::sol_data::FixedBytes<
8482 32,
8483 > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
8484 )
8485 }
8486 #[inline]
8487 fn abi_decode_returns(
8488 data: &[u8],
8489 validate: bool,
8490 ) -> alloy_sol_types::Result<Self::Return> {
8491 <Self::ReturnTuple<
8492 '_,
8493 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8494 .map(Into::into)
8495 }
8496 }
8497 };
8498 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8499 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8504 #[derive(Clone)]
8505 pub struct getOperatorIdCall {
8506 #[allow(missing_docs)]
8507 pub operator: alloy::sol_types::private::Address,
8508 }
8509 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8510 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8512 #[derive(Clone)]
8513 pub struct getOperatorIdReturn {
8514 #[allow(missing_docs)]
8515 pub _0: alloy::sol_types::private::FixedBytes<32>,
8516 }
8517 #[allow(
8518 non_camel_case_types,
8519 non_snake_case,
8520 clippy::pub_underscore_fields,
8521 clippy::style
8522 )]
8523 const _: () = {
8524 use alloy::sol_types as alloy_sol_types;
8525 {
8526 #[doc(hidden)]
8527 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8528 #[doc(hidden)]
8529 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8530 #[cfg(test)]
8531 #[allow(dead_code, unreachable_patterns)]
8532 fn _type_assertion(
8533 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8534 ) {
8535 match _t {
8536 alloy_sol_types::private::AssertTypeEq::<
8537 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8538 >(_) => {}
8539 }
8540 }
8541 #[automatically_derived]
8542 #[doc(hidden)]
8543 impl ::core::convert::From<getOperatorIdCall> for UnderlyingRustTuple<'_> {
8544 fn from(value: getOperatorIdCall) -> Self {
8545 (value.operator,)
8546 }
8547 }
8548 #[automatically_derived]
8549 #[doc(hidden)]
8550 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorIdCall {
8551 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8552 Self { operator: tuple.0 }
8553 }
8554 }
8555 }
8556 {
8557 #[doc(hidden)]
8558 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8559 #[doc(hidden)]
8560 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
8561 #[cfg(test)]
8562 #[allow(dead_code, unreachable_patterns)]
8563 fn _type_assertion(
8564 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8565 ) {
8566 match _t {
8567 alloy_sol_types::private::AssertTypeEq::<
8568 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8569 >(_) => {}
8570 }
8571 }
8572 #[automatically_derived]
8573 #[doc(hidden)]
8574 impl ::core::convert::From<getOperatorIdReturn> for UnderlyingRustTuple<'_> {
8575 fn from(value: getOperatorIdReturn) -> Self {
8576 (value._0,)
8577 }
8578 }
8579 #[automatically_derived]
8580 #[doc(hidden)]
8581 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorIdReturn {
8582 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8583 Self { _0: tuple.0 }
8584 }
8585 }
8586 }
8587 #[automatically_derived]
8588 impl alloy_sol_types::SolCall for getOperatorIdCall {
8589 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
8590 type Token<'a> = <Self::Parameters<
8591 'a,
8592 > as alloy_sol_types::SolType>::Token<'a>;
8593 type Return = getOperatorIdReturn;
8594 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8595 type ReturnToken<'a> = <Self::ReturnTuple<
8596 'a,
8597 > as alloy_sol_types::SolType>::Token<'a>;
8598 const SIGNATURE: &'static str = "getOperatorId(address)";
8599 const SELECTOR: [u8; 4] = [19u8, 84u8, 42u8, 78u8];
8600 #[inline]
8601 fn new<'a>(
8602 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8603 ) -> Self {
8604 tuple.into()
8605 }
8606 #[inline]
8607 fn tokenize(&self) -> Self::Token<'_> {
8608 (
8609 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8610 &self.operator,
8611 ),
8612 )
8613 }
8614 #[inline]
8615 fn abi_decode_returns(
8616 data: &[u8],
8617 validate: bool,
8618 ) -> alloy_sol_types::Result<Self::Return> {
8619 <Self::ReturnTuple<
8620 '_,
8621 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8622 .map(Into::into)
8623 }
8624 }
8625 };
8626 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8627 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8632 #[derive(Clone)]
8633 pub struct getOperatorSetParamsCall {
8634 #[allow(missing_docs)]
8635 pub quorumNumber: u8,
8636 }
8637 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8638 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8640 #[derive(Clone)]
8641 pub struct getOperatorSetParamsReturn {
8642 #[allow(missing_docs)]
8643 pub _0: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
8644 }
8645 #[allow(
8646 non_camel_case_types,
8647 non_snake_case,
8648 clippy::pub_underscore_fields,
8649 clippy::style
8650 )]
8651 const _: () = {
8652 use alloy::sol_types as alloy_sol_types;
8653 {
8654 #[doc(hidden)]
8655 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
8656 #[doc(hidden)]
8657 type UnderlyingRustTuple<'a> = (u8,);
8658 #[cfg(test)]
8659 #[allow(dead_code, unreachable_patterns)]
8660 fn _type_assertion(
8661 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8662 ) {
8663 match _t {
8664 alloy_sol_types::private::AssertTypeEq::<
8665 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8666 >(_) => {}
8667 }
8668 }
8669 #[automatically_derived]
8670 #[doc(hidden)]
8671 impl ::core::convert::From<getOperatorSetParamsCall>
8672 for UnderlyingRustTuple<'_> {
8673 fn from(value: getOperatorSetParamsCall) -> Self {
8674 (value.quorumNumber,)
8675 }
8676 }
8677 #[automatically_derived]
8678 #[doc(hidden)]
8679 impl ::core::convert::From<UnderlyingRustTuple<'_>>
8680 for getOperatorSetParamsCall {
8681 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8682 Self { quorumNumber: tuple.0 }
8683 }
8684 }
8685 }
8686 {
8687 #[doc(hidden)]
8688 type UnderlyingSolTuple<'a> = (
8689 ISlashingRegistryCoordinatorTypes::OperatorSetParam,
8690 );
8691 #[doc(hidden)]
8692 type UnderlyingRustTuple<'a> = (
8693 <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
8694 );
8695 #[cfg(test)]
8696 #[allow(dead_code, unreachable_patterns)]
8697 fn _type_assertion(
8698 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8699 ) {
8700 match _t {
8701 alloy_sol_types::private::AssertTypeEq::<
8702 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8703 >(_) => {}
8704 }
8705 }
8706 #[automatically_derived]
8707 #[doc(hidden)]
8708 impl ::core::convert::From<getOperatorSetParamsReturn>
8709 for UnderlyingRustTuple<'_> {
8710 fn from(value: getOperatorSetParamsReturn) -> Self {
8711 (value._0,)
8712 }
8713 }
8714 #[automatically_derived]
8715 #[doc(hidden)]
8716 impl ::core::convert::From<UnderlyingRustTuple<'_>>
8717 for getOperatorSetParamsReturn {
8718 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8719 Self { _0: tuple.0 }
8720 }
8721 }
8722 }
8723 #[automatically_derived]
8724 impl alloy_sol_types::SolCall for getOperatorSetParamsCall {
8725 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
8726 type Token<'a> = <Self::Parameters<
8727 'a,
8728 > as alloy_sol_types::SolType>::Token<'a>;
8729 type Return = getOperatorSetParamsReturn;
8730 type ReturnTuple<'a> = (
8731 ISlashingRegistryCoordinatorTypes::OperatorSetParam,
8732 );
8733 type ReturnToken<'a> = <Self::ReturnTuple<
8734 'a,
8735 > as alloy_sol_types::SolType>::Token<'a>;
8736 const SIGNATURE: &'static str = "getOperatorSetParams(uint8)";
8737 const SELECTOR: [u8; 4] = [230u8, 87u8, 151u8, 173u8];
8738 #[inline]
8739 fn new<'a>(
8740 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8741 ) -> Self {
8742 tuple.into()
8743 }
8744 #[inline]
8745 fn tokenize(&self) -> Self::Token<'_> {
8746 (
8747 <alloy::sol_types::sol_data::Uint<
8748 8,
8749 > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
8750 )
8751 }
8752 #[inline]
8753 fn abi_decode_returns(
8754 data: &[u8],
8755 validate: bool,
8756 ) -> alloy_sol_types::Result<Self::Return> {
8757 <Self::ReturnTuple<
8758 '_,
8759 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8760 .map(Into::into)
8761 }
8762 }
8763 };
8764 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8765 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8770 #[derive(Clone)]
8771 pub struct getOperatorStatusCall {
8772 #[allow(missing_docs)]
8773 pub operator: alloy::sol_types::private::Address,
8774 }
8775 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8776 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8778 #[derive(Clone)]
8779 pub struct getOperatorStatusReturn {
8780 #[allow(missing_docs)]
8781 pub _0: <ISlashingRegistryCoordinatorTypes::OperatorStatus as alloy::sol_types::SolType>::RustType,
8782 }
8783 #[allow(
8784 non_camel_case_types,
8785 non_snake_case,
8786 clippy::pub_underscore_fields,
8787 clippy::style
8788 )]
8789 const _: () = {
8790 use alloy::sol_types as alloy_sol_types;
8791 {
8792 #[doc(hidden)]
8793 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8794 #[doc(hidden)]
8795 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8796 #[cfg(test)]
8797 #[allow(dead_code, unreachable_patterns)]
8798 fn _type_assertion(
8799 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8800 ) {
8801 match _t {
8802 alloy_sol_types::private::AssertTypeEq::<
8803 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8804 >(_) => {}
8805 }
8806 }
8807 #[automatically_derived]
8808 #[doc(hidden)]
8809 impl ::core::convert::From<getOperatorStatusCall>
8810 for UnderlyingRustTuple<'_> {
8811 fn from(value: getOperatorStatusCall) -> Self {
8812 (value.operator,)
8813 }
8814 }
8815 #[automatically_derived]
8816 #[doc(hidden)]
8817 impl ::core::convert::From<UnderlyingRustTuple<'_>>
8818 for getOperatorStatusCall {
8819 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8820 Self { operator: tuple.0 }
8821 }
8822 }
8823 }
8824 {
8825 #[doc(hidden)]
8826 type UnderlyingSolTuple<'a> = (
8827 ISlashingRegistryCoordinatorTypes::OperatorStatus,
8828 );
8829 #[doc(hidden)]
8830 type UnderlyingRustTuple<'a> = (
8831 <ISlashingRegistryCoordinatorTypes::OperatorStatus as alloy::sol_types::SolType>::RustType,
8832 );
8833 #[cfg(test)]
8834 #[allow(dead_code, unreachable_patterns)]
8835 fn _type_assertion(
8836 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8837 ) {
8838 match _t {
8839 alloy_sol_types::private::AssertTypeEq::<
8840 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8841 >(_) => {}
8842 }
8843 }
8844 #[automatically_derived]
8845 #[doc(hidden)]
8846 impl ::core::convert::From<getOperatorStatusReturn>
8847 for UnderlyingRustTuple<'_> {
8848 fn from(value: getOperatorStatusReturn) -> Self {
8849 (value._0,)
8850 }
8851 }
8852 #[automatically_derived]
8853 #[doc(hidden)]
8854 impl ::core::convert::From<UnderlyingRustTuple<'_>>
8855 for getOperatorStatusReturn {
8856 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8857 Self { _0: tuple.0 }
8858 }
8859 }
8860 }
8861 #[automatically_derived]
8862 impl alloy_sol_types::SolCall for getOperatorStatusCall {
8863 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
8864 type Token<'a> = <Self::Parameters<
8865 'a,
8866 > as alloy_sol_types::SolType>::Token<'a>;
8867 type Return = getOperatorStatusReturn;
8868 type ReturnTuple<'a> = (ISlashingRegistryCoordinatorTypes::OperatorStatus,);
8869 type ReturnToken<'a> = <Self::ReturnTuple<
8870 'a,
8871 > as alloy_sol_types::SolType>::Token<'a>;
8872 const SIGNATURE: &'static str = "getOperatorStatus(address)";
8873 const SELECTOR: [u8; 4] = [253u8, 57u8, 16u8, 90u8];
8874 #[inline]
8875 fn new<'a>(
8876 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8877 ) -> Self {
8878 tuple.into()
8879 }
8880 #[inline]
8881 fn tokenize(&self) -> Self::Token<'_> {
8882 (
8883 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8884 &self.operator,
8885 ),
8886 )
8887 }
8888 #[inline]
8889 fn abi_decode_returns(
8890 data: &[u8],
8891 validate: bool,
8892 ) -> alloy_sol_types::Result<Self::Return> {
8893 <Self::ReturnTuple<
8894 '_,
8895 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8896 .map(Into::into)
8897 }
8898 }
8899 };
8900 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8901 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8906 #[derive(Clone)]
8907 pub struct getQuorumBitmapAtBlockNumberByIndexCall {
8908 #[allow(missing_docs)]
8909 pub operatorId: alloy::sol_types::private::FixedBytes<32>,
8910 #[allow(missing_docs)]
8911 pub blockNumber: u32,
8912 #[allow(missing_docs)]
8913 pub index: alloy::sol_types::private::primitives::aliases::U256,
8914 }
8915 #[derive(Default, Debug, PartialEq, Eq, Hash)]
8916 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8918 #[derive(Clone)]
8919 pub struct getQuorumBitmapAtBlockNumberByIndexReturn {
8920 #[allow(missing_docs)]
8921 pub _0: alloy::sol_types::private::primitives::aliases::U192,
8922 }
8923 #[allow(
8924 non_camel_case_types,
8925 non_snake_case,
8926 clippy::pub_underscore_fields,
8927 clippy::style
8928 )]
8929 const _: () = {
8930 use alloy::sol_types as alloy_sol_types;
8931 {
8932 #[doc(hidden)]
8933 type UnderlyingSolTuple<'a> = (
8934 alloy::sol_types::sol_data::FixedBytes<32>,
8935 alloy::sol_types::sol_data::Uint<32>,
8936 alloy::sol_types::sol_data::Uint<256>,
8937 );
8938 #[doc(hidden)]
8939 type UnderlyingRustTuple<'a> = (
8940 alloy::sol_types::private::FixedBytes<32>,
8941 u32,
8942 alloy::sol_types::private::primitives::aliases::U256,
8943 );
8944 #[cfg(test)]
8945 #[allow(dead_code, unreachable_patterns)]
8946 fn _type_assertion(
8947 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8948 ) {
8949 match _t {
8950 alloy_sol_types::private::AssertTypeEq::<
8951 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8952 >(_) => {}
8953 }
8954 }
8955 #[automatically_derived]
8956 #[doc(hidden)]
8957 impl ::core::convert::From<getQuorumBitmapAtBlockNumberByIndexCall>
8958 for UnderlyingRustTuple<'_> {
8959 fn from(value: getQuorumBitmapAtBlockNumberByIndexCall) -> Self {
8960 (value.operatorId, value.blockNumber, value.index)
8961 }
8962 }
8963 #[automatically_derived]
8964 #[doc(hidden)]
8965 impl ::core::convert::From<UnderlyingRustTuple<'_>>
8966 for getQuorumBitmapAtBlockNumberByIndexCall {
8967 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8968 Self {
8969 operatorId: tuple.0,
8970 blockNumber: tuple.1,
8971 index: tuple.2,
8972 }
8973 }
8974 }
8975 }
8976 {
8977 #[doc(hidden)]
8978 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<192>,);
8979 #[doc(hidden)]
8980 type UnderlyingRustTuple<'a> = (
8981 alloy::sol_types::private::primitives::aliases::U192,
8982 );
8983 #[cfg(test)]
8984 #[allow(dead_code, unreachable_patterns)]
8985 fn _type_assertion(
8986 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8987 ) {
8988 match _t {
8989 alloy_sol_types::private::AssertTypeEq::<
8990 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8991 >(_) => {}
8992 }
8993 }
8994 #[automatically_derived]
8995 #[doc(hidden)]
8996 impl ::core::convert::From<getQuorumBitmapAtBlockNumberByIndexReturn>
8997 for UnderlyingRustTuple<'_> {
8998 fn from(value: getQuorumBitmapAtBlockNumberByIndexReturn) -> Self {
8999 (value._0,)
9000 }
9001 }
9002 #[automatically_derived]
9003 #[doc(hidden)]
9004 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9005 for getQuorumBitmapAtBlockNumberByIndexReturn {
9006 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9007 Self { _0: tuple.0 }
9008 }
9009 }
9010 }
9011 #[automatically_derived]
9012 impl alloy_sol_types::SolCall for getQuorumBitmapAtBlockNumberByIndexCall {
9013 type Parameters<'a> = (
9014 alloy::sol_types::sol_data::FixedBytes<32>,
9015 alloy::sol_types::sol_data::Uint<32>,
9016 alloy::sol_types::sol_data::Uint<256>,
9017 );
9018 type Token<'a> = <Self::Parameters<
9019 'a,
9020 > as alloy_sol_types::SolType>::Token<'a>;
9021 type Return = getQuorumBitmapAtBlockNumberByIndexReturn;
9022 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<192>,);
9023 type ReturnToken<'a> = <Self::ReturnTuple<
9024 'a,
9025 > as alloy_sol_types::SolType>::Token<'a>;
9026 const SIGNATURE: &'static str = "getQuorumBitmapAtBlockNumberByIndex(bytes32,uint32,uint256)";
9027 const SELECTOR: [u8; 4] = [4u8, 236u8, 99u8, 81u8];
9028 #[inline]
9029 fn new<'a>(
9030 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9031 ) -> Self {
9032 tuple.into()
9033 }
9034 #[inline]
9035 fn tokenize(&self) -> Self::Token<'_> {
9036 (
9037 <alloy::sol_types::sol_data::FixedBytes<
9038 32,
9039 > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
9040 <alloy::sol_types::sol_data::Uint<
9041 32,
9042 > as alloy_sol_types::SolType>::tokenize(&self.blockNumber),
9043 <alloy::sol_types::sol_data::Uint<
9044 256,
9045 > as alloy_sol_types::SolType>::tokenize(&self.index),
9046 )
9047 }
9048 #[inline]
9049 fn abi_decode_returns(
9050 data: &[u8],
9051 validate: bool,
9052 ) -> alloy_sol_types::Result<Self::Return> {
9053 <Self::ReturnTuple<
9054 '_,
9055 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
9056 .map(Into::into)
9057 }
9058 }
9059 };
9060 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9061 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9066 #[derive(Clone)]
9067 pub struct getQuorumBitmapHistoryLengthCall {
9068 #[allow(missing_docs)]
9069 pub operatorId: alloy::sol_types::private::FixedBytes<32>,
9070 }
9071 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9072 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9074 #[derive(Clone)]
9075 pub struct getQuorumBitmapHistoryLengthReturn {
9076 #[allow(missing_docs)]
9077 pub _0: alloy::sol_types::private::primitives::aliases::U256,
9078 }
9079 #[allow(
9080 non_camel_case_types,
9081 non_snake_case,
9082 clippy::pub_underscore_fields,
9083 clippy::style
9084 )]
9085 const _: () = {
9086 use alloy::sol_types as alloy_sol_types;
9087 {
9088 #[doc(hidden)]
9089 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
9090 #[doc(hidden)]
9091 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
9092 #[cfg(test)]
9093 #[allow(dead_code, unreachable_patterns)]
9094 fn _type_assertion(
9095 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9096 ) {
9097 match _t {
9098 alloy_sol_types::private::AssertTypeEq::<
9099 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9100 >(_) => {}
9101 }
9102 }
9103 #[automatically_derived]
9104 #[doc(hidden)]
9105 impl ::core::convert::From<getQuorumBitmapHistoryLengthCall>
9106 for UnderlyingRustTuple<'_> {
9107 fn from(value: getQuorumBitmapHistoryLengthCall) -> Self {
9108 (value.operatorId,)
9109 }
9110 }
9111 #[automatically_derived]
9112 #[doc(hidden)]
9113 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9114 for getQuorumBitmapHistoryLengthCall {
9115 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9116 Self { operatorId: tuple.0 }
9117 }
9118 }
9119 }
9120 {
9121 #[doc(hidden)]
9122 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9123 #[doc(hidden)]
9124 type UnderlyingRustTuple<'a> = (
9125 alloy::sol_types::private::primitives::aliases::U256,
9126 );
9127 #[cfg(test)]
9128 #[allow(dead_code, unreachable_patterns)]
9129 fn _type_assertion(
9130 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9131 ) {
9132 match _t {
9133 alloy_sol_types::private::AssertTypeEq::<
9134 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9135 >(_) => {}
9136 }
9137 }
9138 #[automatically_derived]
9139 #[doc(hidden)]
9140 impl ::core::convert::From<getQuorumBitmapHistoryLengthReturn>
9141 for UnderlyingRustTuple<'_> {
9142 fn from(value: getQuorumBitmapHistoryLengthReturn) -> Self {
9143 (value._0,)
9144 }
9145 }
9146 #[automatically_derived]
9147 #[doc(hidden)]
9148 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9149 for getQuorumBitmapHistoryLengthReturn {
9150 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9151 Self { _0: tuple.0 }
9152 }
9153 }
9154 }
9155 #[automatically_derived]
9156 impl alloy_sol_types::SolCall for getQuorumBitmapHistoryLengthCall {
9157 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
9158 type Token<'a> = <Self::Parameters<
9159 'a,
9160 > as alloy_sol_types::SolType>::Token<'a>;
9161 type Return = getQuorumBitmapHistoryLengthReturn;
9162 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9163 type ReturnToken<'a> = <Self::ReturnTuple<
9164 'a,
9165 > as alloy_sol_types::SolType>::Token<'a>;
9166 const SIGNATURE: &'static str = "getQuorumBitmapHistoryLength(bytes32)";
9167 const SELECTOR: [u8; 4] = [3u8, 253u8, 52u8, 146u8];
9168 #[inline]
9169 fn new<'a>(
9170 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9171 ) -> Self {
9172 tuple.into()
9173 }
9174 #[inline]
9175 fn tokenize(&self) -> Self::Token<'_> {
9176 (
9177 <alloy::sol_types::sol_data::FixedBytes<
9178 32,
9179 > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
9180 )
9181 }
9182 #[inline]
9183 fn abi_decode_returns(
9184 data: &[u8],
9185 validate: bool,
9186 ) -> alloy_sol_types::Result<Self::Return> {
9187 <Self::ReturnTuple<
9188 '_,
9189 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
9190 .map(Into::into)
9191 }
9192 }
9193 };
9194 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9195 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9200 #[derive(Clone)]
9201 pub struct getQuorumBitmapIndicesAtBlockNumberCall {
9202 #[allow(missing_docs)]
9203 pub blockNumber: u32,
9204 #[allow(missing_docs)]
9205 pub operatorIds: alloy::sol_types::private::Vec<
9206 alloy::sol_types::private::FixedBytes<32>,
9207 >,
9208 }
9209 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9210 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9212 #[derive(Clone)]
9213 pub struct getQuorumBitmapIndicesAtBlockNumberReturn {
9214 #[allow(missing_docs)]
9215 pub _0: alloy::sol_types::private::Vec<u32>,
9216 }
9217 #[allow(
9218 non_camel_case_types,
9219 non_snake_case,
9220 clippy::pub_underscore_fields,
9221 clippy::style
9222 )]
9223 const _: () = {
9224 use alloy::sol_types as alloy_sol_types;
9225 {
9226 #[doc(hidden)]
9227 type UnderlyingSolTuple<'a> = (
9228 alloy::sol_types::sol_data::Uint<32>,
9229 alloy::sol_types::sol_data::Array<
9230 alloy::sol_types::sol_data::FixedBytes<32>,
9231 >,
9232 );
9233 #[doc(hidden)]
9234 type UnderlyingRustTuple<'a> = (
9235 u32,
9236 alloy::sol_types::private::Vec<alloy::sol_types::private::FixedBytes<32>>,
9237 );
9238 #[cfg(test)]
9239 #[allow(dead_code, unreachable_patterns)]
9240 fn _type_assertion(
9241 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9242 ) {
9243 match _t {
9244 alloy_sol_types::private::AssertTypeEq::<
9245 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9246 >(_) => {}
9247 }
9248 }
9249 #[automatically_derived]
9250 #[doc(hidden)]
9251 impl ::core::convert::From<getQuorumBitmapIndicesAtBlockNumberCall>
9252 for UnderlyingRustTuple<'_> {
9253 fn from(value: getQuorumBitmapIndicesAtBlockNumberCall) -> Self {
9254 (value.blockNumber, value.operatorIds)
9255 }
9256 }
9257 #[automatically_derived]
9258 #[doc(hidden)]
9259 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9260 for getQuorumBitmapIndicesAtBlockNumberCall {
9261 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9262 Self {
9263 blockNumber: tuple.0,
9264 operatorIds: tuple.1,
9265 }
9266 }
9267 }
9268 }
9269 {
9270 #[doc(hidden)]
9271 type UnderlyingSolTuple<'a> = (
9272 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
9273 );
9274 #[doc(hidden)]
9275 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Vec<u32>,);
9276 #[cfg(test)]
9277 #[allow(dead_code, unreachable_patterns)]
9278 fn _type_assertion(
9279 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9280 ) {
9281 match _t {
9282 alloy_sol_types::private::AssertTypeEq::<
9283 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9284 >(_) => {}
9285 }
9286 }
9287 #[automatically_derived]
9288 #[doc(hidden)]
9289 impl ::core::convert::From<getQuorumBitmapIndicesAtBlockNumberReturn>
9290 for UnderlyingRustTuple<'_> {
9291 fn from(value: getQuorumBitmapIndicesAtBlockNumberReturn) -> Self {
9292 (value._0,)
9293 }
9294 }
9295 #[automatically_derived]
9296 #[doc(hidden)]
9297 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9298 for getQuorumBitmapIndicesAtBlockNumberReturn {
9299 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9300 Self { _0: tuple.0 }
9301 }
9302 }
9303 }
9304 #[automatically_derived]
9305 impl alloy_sol_types::SolCall for getQuorumBitmapIndicesAtBlockNumberCall {
9306 type Parameters<'a> = (
9307 alloy::sol_types::sol_data::Uint<32>,
9308 alloy::sol_types::sol_data::Array<
9309 alloy::sol_types::sol_data::FixedBytes<32>,
9310 >,
9311 );
9312 type Token<'a> = <Self::Parameters<
9313 'a,
9314 > as alloy_sol_types::SolType>::Token<'a>;
9315 type Return = getQuorumBitmapIndicesAtBlockNumberReturn;
9316 type ReturnTuple<'a> = (
9317 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
9318 );
9319 type ReturnToken<'a> = <Self::ReturnTuple<
9320 'a,
9321 > as alloy_sol_types::SolType>::Token<'a>;
9322 const SIGNATURE: &'static str = "getQuorumBitmapIndicesAtBlockNumber(uint32,bytes32[])";
9323 const SELECTOR: [u8; 4] = [195u8, 145u8, 66u8, 94u8];
9324 #[inline]
9325 fn new<'a>(
9326 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9327 ) -> Self {
9328 tuple.into()
9329 }
9330 #[inline]
9331 fn tokenize(&self) -> Self::Token<'_> {
9332 (
9333 <alloy::sol_types::sol_data::Uint<
9334 32,
9335 > as alloy_sol_types::SolType>::tokenize(&self.blockNumber),
9336 <alloy::sol_types::sol_data::Array<
9337 alloy::sol_types::sol_data::FixedBytes<32>,
9338 > as alloy_sol_types::SolType>::tokenize(&self.operatorIds),
9339 )
9340 }
9341 #[inline]
9342 fn abi_decode_returns(
9343 data: &[u8],
9344 validate: bool,
9345 ) -> alloy_sol_types::Result<Self::Return> {
9346 <Self::ReturnTuple<
9347 '_,
9348 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
9349 .map(Into::into)
9350 }
9351 }
9352 };
9353 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9354 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9359 #[derive(Clone)]
9360 pub struct getQuorumBitmapUpdateByIndexCall {
9361 #[allow(missing_docs)]
9362 pub operatorId: alloy::sol_types::private::FixedBytes<32>,
9363 #[allow(missing_docs)]
9364 pub index: alloy::sol_types::private::primitives::aliases::U256,
9365 }
9366 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9367 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9369 #[derive(Clone)]
9370 pub struct getQuorumBitmapUpdateByIndexReturn {
9371 #[allow(missing_docs)]
9372 pub _0: <ISlashingRegistryCoordinatorTypes::QuorumBitmapUpdate as alloy::sol_types::SolType>::RustType,
9373 }
9374 #[allow(
9375 non_camel_case_types,
9376 non_snake_case,
9377 clippy::pub_underscore_fields,
9378 clippy::style
9379 )]
9380 const _: () = {
9381 use alloy::sol_types as alloy_sol_types;
9382 {
9383 #[doc(hidden)]
9384 type UnderlyingSolTuple<'a> = (
9385 alloy::sol_types::sol_data::FixedBytes<32>,
9386 alloy::sol_types::sol_data::Uint<256>,
9387 );
9388 #[doc(hidden)]
9389 type UnderlyingRustTuple<'a> = (
9390 alloy::sol_types::private::FixedBytes<32>,
9391 alloy::sol_types::private::primitives::aliases::U256,
9392 );
9393 #[cfg(test)]
9394 #[allow(dead_code, unreachable_patterns)]
9395 fn _type_assertion(
9396 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9397 ) {
9398 match _t {
9399 alloy_sol_types::private::AssertTypeEq::<
9400 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9401 >(_) => {}
9402 }
9403 }
9404 #[automatically_derived]
9405 #[doc(hidden)]
9406 impl ::core::convert::From<getQuorumBitmapUpdateByIndexCall>
9407 for UnderlyingRustTuple<'_> {
9408 fn from(value: getQuorumBitmapUpdateByIndexCall) -> Self {
9409 (value.operatorId, value.index)
9410 }
9411 }
9412 #[automatically_derived]
9413 #[doc(hidden)]
9414 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9415 for getQuorumBitmapUpdateByIndexCall {
9416 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9417 Self {
9418 operatorId: tuple.0,
9419 index: tuple.1,
9420 }
9421 }
9422 }
9423 }
9424 {
9425 #[doc(hidden)]
9426 type UnderlyingSolTuple<'a> = (
9427 ISlashingRegistryCoordinatorTypes::QuorumBitmapUpdate,
9428 );
9429 #[doc(hidden)]
9430 type UnderlyingRustTuple<'a> = (
9431 <ISlashingRegistryCoordinatorTypes::QuorumBitmapUpdate as alloy::sol_types::SolType>::RustType,
9432 );
9433 #[cfg(test)]
9434 #[allow(dead_code, unreachable_patterns)]
9435 fn _type_assertion(
9436 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9437 ) {
9438 match _t {
9439 alloy_sol_types::private::AssertTypeEq::<
9440 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9441 >(_) => {}
9442 }
9443 }
9444 #[automatically_derived]
9445 #[doc(hidden)]
9446 impl ::core::convert::From<getQuorumBitmapUpdateByIndexReturn>
9447 for UnderlyingRustTuple<'_> {
9448 fn from(value: getQuorumBitmapUpdateByIndexReturn) -> Self {
9449 (value._0,)
9450 }
9451 }
9452 #[automatically_derived]
9453 #[doc(hidden)]
9454 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9455 for getQuorumBitmapUpdateByIndexReturn {
9456 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9457 Self { _0: tuple.0 }
9458 }
9459 }
9460 }
9461 #[automatically_derived]
9462 impl alloy_sol_types::SolCall for getQuorumBitmapUpdateByIndexCall {
9463 type Parameters<'a> = (
9464 alloy::sol_types::sol_data::FixedBytes<32>,
9465 alloy::sol_types::sol_data::Uint<256>,
9466 );
9467 type Token<'a> = <Self::Parameters<
9468 'a,
9469 > as alloy_sol_types::SolType>::Token<'a>;
9470 type Return = getQuorumBitmapUpdateByIndexReturn;
9471 type ReturnTuple<'a> = (
9472 ISlashingRegistryCoordinatorTypes::QuorumBitmapUpdate,
9473 );
9474 type ReturnToken<'a> = <Self::ReturnTuple<
9475 'a,
9476 > as alloy_sol_types::SolType>::Token<'a>;
9477 const SIGNATURE: &'static str = "getQuorumBitmapUpdateByIndex(bytes32,uint256)";
9478 const SELECTOR: [u8; 4] = [30u8, 184u8, 18u8, 218u8];
9479 #[inline]
9480 fn new<'a>(
9481 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9482 ) -> Self {
9483 tuple.into()
9484 }
9485 #[inline]
9486 fn tokenize(&self) -> Self::Token<'_> {
9487 (
9488 <alloy::sol_types::sol_data::FixedBytes<
9489 32,
9490 > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
9491 <alloy::sol_types::sol_data::Uint<
9492 256,
9493 > as alloy_sol_types::SolType>::tokenize(&self.index),
9494 )
9495 }
9496 #[inline]
9497 fn abi_decode_returns(
9498 data: &[u8],
9499 validate: bool,
9500 ) -> alloy_sol_types::Result<Self::Return> {
9501 <Self::ReturnTuple<
9502 '_,
9503 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
9504 .map(Into::into)
9505 }
9506 }
9507 };
9508 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9509 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9514 #[derive(Clone)]
9515 pub struct indexRegistryCall {}
9516 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9517 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9519 #[derive(Clone)]
9520 pub struct indexRegistryReturn {
9521 #[allow(missing_docs)]
9522 pub _0: alloy::sol_types::private::Address,
9523 }
9524 #[allow(
9525 non_camel_case_types,
9526 non_snake_case,
9527 clippy::pub_underscore_fields,
9528 clippy::style
9529 )]
9530 const _: () = {
9531 use alloy::sol_types as alloy_sol_types;
9532 {
9533 #[doc(hidden)]
9534 type UnderlyingSolTuple<'a> = ();
9535 #[doc(hidden)]
9536 type UnderlyingRustTuple<'a> = ();
9537 #[cfg(test)]
9538 #[allow(dead_code, unreachable_patterns)]
9539 fn _type_assertion(
9540 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9541 ) {
9542 match _t {
9543 alloy_sol_types::private::AssertTypeEq::<
9544 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9545 >(_) => {}
9546 }
9547 }
9548 #[automatically_derived]
9549 #[doc(hidden)]
9550 impl ::core::convert::From<indexRegistryCall> for UnderlyingRustTuple<'_> {
9551 fn from(value: indexRegistryCall) -> Self {
9552 ()
9553 }
9554 }
9555 #[automatically_derived]
9556 #[doc(hidden)]
9557 impl ::core::convert::From<UnderlyingRustTuple<'_>> for indexRegistryCall {
9558 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9559 Self {}
9560 }
9561 }
9562 }
9563 {
9564 #[doc(hidden)]
9565 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
9566 #[doc(hidden)]
9567 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
9568 #[cfg(test)]
9569 #[allow(dead_code, unreachable_patterns)]
9570 fn _type_assertion(
9571 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9572 ) {
9573 match _t {
9574 alloy_sol_types::private::AssertTypeEq::<
9575 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9576 >(_) => {}
9577 }
9578 }
9579 #[automatically_derived]
9580 #[doc(hidden)]
9581 impl ::core::convert::From<indexRegistryReturn> for UnderlyingRustTuple<'_> {
9582 fn from(value: indexRegistryReturn) -> Self {
9583 (value._0,)
9584 }
9585 }
9586 #[automatically_derived]
9587 #[doc(hidden)]
9588 impl ::core::convert::From<UnderlyingRustTuple<'_>> for indexRegistryReturn {
9589 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9590 Self { _0: tuple.0 }
9591 }
9592 }
9593 }
9594 #[automatically_derived]
9595 impl alloy_sol_types::SolCall for indexRegistryCall {
9596 type Parameters<'a> = ();
9597 type Token<'a> = <Self::Parameters<
9598 'a,
9599 > as alloy_sol_types::SolType>::Token<'a>;
9600 type Return = indexRegistryReturn;
9601 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
9602 type ReturnToken<'a> = <Self::ReturnTuple<
9603 'a,
9604 > as alloy_sol_types::SolType>::Token<'a>;
9605 const SIGNATURE: &'static str = "indexRegistry()";
9606 const SELECTOR: [u8; 4] = [158u8, 153u8, 35u8, 194u8];
9607 #[inline]
9608 fn new<'a>(
9609 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9610 ) -> Self {
9611 tuple.into()
9612 }
9613 #[inline]
9614 fn tokenize(&self) -> Self::Token<'_> {
9615 ()
9616 }
9617 #[inline]
9618 fn abi_decode_returns(
9619 data: &[u8],
9620 validate: bool,
9621 ) -> alloy_sol_types::Result<Self::Return> {
9622 <Self::ReturnTuple<
9623 '_,
9624 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
9625 .map(Into::into)
9626 }
9627 }
9628 };
9629 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9630 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9635 #[derive(Clone)]
9636 pub struct isChurnApproverSaltUsedCall {
9637 #[allow(missing_docs)]
9638 pub salt: alloy::sol_types::private::FixedBytes<32>,
9639 }
9640 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9641 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9643 #[derive(Clone)]
9644 pub struct isChurnApproverSaltUsedReturn {
9645 #[allow(missing_docs)]
9646 pub _0: bool,
9647 }
9648 #[allow(
9649 non_camel_case_types,
9650 non_snake_case,
9651 clippy::pub_underscore_fields,
9652 clippy::style
9653 )]
9654 const _: () = {
9655 use alloy::sol_types as alloy_sol_types;
9656 {
9657 #[doc(hidden)]
9658 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
9659 #[doc(hidden)]
9660 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
9661 #[cfg(test)]
9662 #[allow(dead_code, unreachable_patterns)]
9663 fn _type_assertion(
9664 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9665 ) {
9666 match _t {
9667 alloy_sol_types::private::AssertTypeEq::<
9668 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9669 >(_) => {}
9670 }
9671 }
9672 #[automatically_derived]
9673 #[doc(hidden)]
9674 impl ::core::convert::From<isChurnApproverSaltUsedCall>
9675 for UnderlyingRustTuple<'_> {
9676 fn from(value: isChurnApproverSaltUsedCall) -> Self {
9677 (value.salt,)
9678 }
9679 }
9680 #[automatically_derived]
9681 #[doc(hidden)]
9682 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9683 for isChurnApproverSaltUsedCall {
9684 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9685 Self { salt: tuple.0 }
9686 }
9687 }
9688 }
9689 {
9690 #[doc(hidden)]
9691 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
9692 #[doc(hidden)]
9693 type UnderlyingRustTuple<'a> = (bool,);
9694 #[cfg(test)]
9695 #[allow(dead_code, unreachable_patterns)]
9696 fn _type_assertion(
9697 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9698 ) {
9699 match _t {
9700 alloy_sol_types::private::AssertTypeEq::<
9701 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9702 >(_) => {}
9703 }
9704 }
9705 #[automatically_derived]
9706 #[doc(hidden)]
9707 impl ::core::convert::From<isChurnApproverSaltUsedReturn>
9708 for UnderlyingRustTuple<'_> {
9709 fn from(value: isChurnApproverSaltUsedReturn) -> Self {
9710 (value._0,)
9711 }
9712 }
9713 #[automatically_derived]
9714 #[doc(hidden)]
9715 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9716 for isChurnApproverSaltUsedReturn {
9717 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9718 Self { _0: tuple.0 }
9719 }
9720 }
9721 }
9722 #[automatically_derived]
9723 impl alloy_sol_types::SolCall for isChurnApproverSaltUsedCall {
9724 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
9725 type Token<'a> = <Self::Parameters<
9726 'a,
9727 > as alloy_sol_types::SolType>::Token<'a>;
9728 type Return = isChurnApproverSaltUsedReturn;
9729 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
9730 type ReturnToken<'a> = <Self::ReturnTuple<
9731 'a,
9732 > as alloy_sol_types::SolType>::Token<'a>;
9733 const SIGNATURE: &'static str = "isChurnApproverSaltUsed(bytes32)";
9734 const SELECTOR: [u8; 4] = [20u8, 120u8, 133u8, 31u8];
9735 #[inline]
9736 fn new<'a>(
9737 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9738 ) -> Self {
9739 tuple.into()
9740 }
9741 #[inline]
9742 fn tokenize(&self) -> Self::Token<'_> {
9743 (
9744 <alloy::sol_types::sol_data::FixedBytes<
9745 32,
9746 > as alloy_sol_types::SolType>::tokenize(&self.salt),
9747 )
9748 }
9749 #[inline]
9750 fn abi_decode_returns(
9751 data: &[u8],
9752 validate: bool,
9753 ) -> alloy_sol_types::Result<Self::Return> {
9754 <Self::ReturnTuple<
9755 '_,
9756 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
9757 .map(Into::into)
9758 }
9759 }
9760 };
9761 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9762 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9767 #[derive(Clone)]
9768 pub struct lastEjectionTimestampCall {
9769 #[allow(missing_docs)]
9770 pub operator: alloy::sol_types::private::Address,
9771 }
9772 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9773 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9775 #[derive(Clone)]
9776 pub struct lastEjectionTimestampReturn {
9777 #[allow(missing_docs)]
9778 pub _0: alloy::sol_types::private::primitives::aliases::U256,
9779 }
9780 #[allow(
9781 non_camel_case_types,
9782 non_snake_case,
9783 clippy::pub_underscore_fields,
9784 clippy::style
9785 )]
9786 const _: () = {
9787 use alloy::sol_types as alloy_sol_types;
9788 {
9789 #[doc(hidden)]
9790 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
9791 #[doc(hidden)]
9792 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
9793 #[cfg(test)]
9794 #[allow(dead_code, unreachable_patterns)]
9795 fn _type_assertion(
9796 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9797 ) {
9798 match _t {
9799 alloy_sol_types::private::AssertTypeEq::<
9800 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9801 >(_) => {}
9802 }
9803 }
9804 #[automatically_derived]
9805 #[doc(hidden)]
9806 impl ::core::convert::From<lastEjectionTimestampCall>
9807 for UnderlyingRustTuple<'_> {
9808 fn from(value: lastEjectionTimestampCall) -> Self {
9809 (value.operator,)
9810 }
9811 }
9812 #[automatically_derived]
9813 #[doc(hidden)]
9814 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9815 for lastEjectionTimestampCall {
9816 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9817 Self { operator: tuple.0 }
9818 }
9819 }
9820 }
9821 {
9822 #[doc(hidden)]
9823 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9824 #[doc(hidden)]
9825 type UnderlyingRustTuple<'a> = (
9826 alloy::sol_types::private::primitives::aliases::U256,
9827 );
9828 #[cfg(test)]
9829 #[allow(dead_code, unreachable_patterns)]
9830 fn _type_assertion(
9831 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9832 ) {
9833 match _t {
9834 alloy_sol_types::private::AssertTypeEq::<
9835 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9836 >(_) => {}
9837 }
9838 }
9839 #[automatically_derived]
9840 #[doc(hidden)]
9841 impl ::core::convert::From<lastEjectionTimestampReturn>
9842 for UnderlyingRustTuple<'_> {
9843 fn from(value: lastEjectionTimestampReturn) -> Self {
9844 (value._0,)
9845 }
9846 }
9847 #[automatically_derived]
9848 #[doc(hidden)]
9849 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9850 for lastEjectionTimestampReturn {
9851 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9852 Self { _0: tuple.0 }
9853 }
9854 }
9855 }
9856 #[automatically_derived]
9857 impl alloy_sol_types::SolCall for lastEjectionTimestampCall {
9858 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
9859 type Token<'a> = <Self::Parameters<
9860 'a,
9861 > as alloy_sol_types::SolType>::Token<'a>;
9862 type Return = lastEjectionTimestampReturn;
9863 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9864 type ReturnToken<'a> = <Self::ReturnTuple<
9865 'a,
9866 > as alloy_sol_types::SolType>::Token<'a>;
9867 const SIGNATURE: &'static str = "lastEjectionTimestamp(address)";
9868 const SELECTOR: [u8; 4] = [18u8, 94u8, 5u8, 132u8];
9869 #[inline]
9870 fn new<'a>(
9871 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9872 ) -> Self {
9873 tuple.into()
9874 }
9875 #[inline]
9876 fn tokenize(&self) -> Self::Token<'_> {
9877 (
9878 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9879 &self.operator,
9880 ),
9881 )
9882 }
9883 #[inline]
9884 fn abi_decode_returns(
9885 data: &[u8],
9886 validate: bool,
9887 ) -> alloy_sol_types::Result<Self::Return> {
9888 <Self::ReturnTuple<
9889 '_,
9890 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
9891 .map(Into::into)
9892 }
9893 }
9894 };
9895 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9896 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9901 #[derive(Clone)]
9902 pub struct pubkeyRegistrationMessageHashCall {
9903 #[allow(missing_docs)]
9904 pub operator: alloy::sol_types::private::Address,
9905 }
9906 #[derive(Default, Debug, PartialEq, Eq, Hash)]
9907 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9909 #[derive(Clone)]
9910 pub struct pubkeyRegistrationMessageHashReturn {
9911 #[allow(missing_docs)]
9912 pub _0: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
9913 }
9914 #[allow(
9915 non_camel_case_types,
9916 non_snake_case,
9917 clippy::pub_underscore_fields,
9918 clippy::style
9919 )]
9920 const _: () = {
9921 use alloy::sol_types as alloy_sol_types;
9922 {
9923 #[doc(hidden)]
9924 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
9925 #[doc(hidden)]
9926 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
9927 #[cfg(test)]
9928 #[allow(dead_code, unreachable_patterns)]
9929 fn _type_assertion(
9930 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9931 ) {
9932 match _t {
9933 alloy_sol_types::private::AssertTypeEq::<
9934 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9935 >(_) => {}
9936 }
9937 }
9938 #[automatically_derived]
9939 #[doc(hidden)]
9940 impl ::core::convert::From<pubkeyRegistrationMessageHashCall>
9941 for UnderlyingRustTuple<'_> {
9942 fn from(value: pubkeyRegistrationMessageHashCall) -> Self {
9943 (value.operator,)
9944 }
9945 }
9946 #[automatically_derived]
9947 #[doc(hidden)]
9948 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9949 for pubkeyRegistrationMessageHashCall {
9950 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9951 Self { operator: tuple.0 }
9952 }
9953 }
9954 }
9955 {
9956 #[doc(hidden)]
9957 type UnderlyingSolTuple<'a> = (BN254::G1Point,);
9958 #[doc(hidden)]
9959 type UnderlyingRustTuple<'a> = (
9960 <BN254::G1Point as alloy::sol_types::SolType>::RustType,
9961 );
9962 #[cfg(test)]
9963 #[allow(dead_code, unreachable_patterns)]
9964 fn _type_assertion(
9965 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9966 ) {
9967 match _t {
9968 alloy_sol_types::private::AssertTypeEq::<
9969 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9970 >(_) => {}
9971 }
9972 }
9973 #[automatically_derived]
9974 #[doc(hidden)]
9975 impl ::core::convert::From<pubkeyRegistrationMessageHashReturn>
9976 for UnderlyingRustTuple<'_> {
9977 fn from(value: pubkeyRegistrationMessageHashReturn) -> Self {
9978 (value._0,)
9979 }
9980 }
9981 #[automatically_derived]
9982 #[doc(hidden)]
9983 impl ::core::convert::From<UnderlyingRustTuple<'_>>
9984 for pubkeyRegistrationMessageHashReturn {
9985 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9986 Self { _0: tuple.0 }
9987 }
9988 }
9989 }
9990 #[automatically_derived]
9991 impl alloy_sol_types::SolCall for pubkeyRegistrationMessageHashCall {
9992 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
9993 type Token<'a> = <Self::Parameters<
9994 'a,
9995 > as alloy_sol_types::SolType>::Token<'a>;
9996 type Return = pubkeyRegistrationMessageHashReturn;
9997 type ReturnTuple<'a> = (BN254::G1Point,);
9998 type ReturnToken<'a> = <Self::ReturnTuple<
9999 'a,
10000 > as alloy_sol_types::SolType>::Token<'a>;
10001 const SIGNATURE: &'static str = "pubkeyRegistrationMessageHash(address)";
10002 const SELECTOR: [u8; 4] = [60u8, 42u8, 127u8, 76u8];
10003 #[inline]
10004 fn new<'a>(
10005 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10006 ) -> Self {
10007 tuple.into()
10008 }
10009 #[inline]
10010 fn tokenize(&self) -> Self::Token<'_> {
10011 (
10012 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10013 &self.operator,
10014 ),
10015 )
10016 }
10017 #[inline]
10018 fn abi_decode_returns(
10019 data: &[u8],
10020 validate: bool,
10021 ) -> alloy_sol_types::Result<Self::Return> {
10022 <Self::ReturnTuple<
10023 '_,
10024 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
10025 .map(Into::into)
10026 }
10027 }
10028 };
10029 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10030 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10035 #[derive(Clone)]
10036 pub struct quorumCountCall {}
10037 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10038 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10040 #[derive(Clone)]
10041 pub struct quorumCountReturn {
10042 #[allow(missing_docs)]
10043 pub _0: u8,
10044 }
10045 #[allow(
10046 non_camel_case_types,
10047 non_snake_case,
10048 clippy::pub_underscore_fields,
10049 clippy::style
10050 )]
10051 const _: () = {
10052 use alloy::sol_types as alloy_sol_types;
10053 {
10054 #[doc(hidden)]
10055 type UnderlyingSolTuple<'a> = ();
10056 #[doc(hidden)]
10057 type UnderlyingRustTuple<'a> = ();
10058 #[cfg(test)]
10059 #[allow(dead_code, unreachable_patterns)]
10060 fn _type_assertion(
10061 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10062 ) {
10063 match _t {
10064 alloy_sol_types::private::AssertTypeEq::<
10065 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10066 >(_) => {}
10067 }
10068 }
10069 #[automatically_derived]
10070 #[doc(hidden)]
10071 impl ::core::convert::From<quorumCountCall> for UnderlyingRustTuple<'_> {
10072 fn from(value: quorumCountCall) -> Self {
10073 ()
10074 }
10075 }
10076 #[automatically_derived]
10077 #[doc(hidden)]
10078 impl ::core::convert::From<UnderlyingRustTuple<'_>> for quorumCountCall {
10079 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10080 Self {}
10081 }
10082 }
10083 }
10084 {
10085 #[doc(hidden)]
10086 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
10087 #[doc(hidden)]
10088 type UnderlyingRustTuple<'a> = (u8,);
10089 #[cfg(test)]
10090 #[allow(dead_code, unreachable_patterns)]
10091 fn _type_assertion(
10092 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10093 ) {
10094 match _t {
10095 alloy_sol_types::private::AssertTypeEq::<
10096 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10097 >(_) => {}
10098 }
10099 }
10100 #[automatically_derived]
10101 #[doc(hidden)]
10102 impl ::core::convert::From<quorumCountReturn> for UnderlyingRustTuple<'_> {
10103 fn from(value: quorumCountReturn) -> Self {
10104 (value._0,)
10105 }
10106 }
10107 #[automatically_derived]
10108 #[doc(hidden)]
10109 impl ::core::convert::From<UnderlyingRustTuple<'_>> for quorumCountReturn {
10110 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10111 Self { _0: tuple.0 }
10112 }
10113 }
10114 }
10115 #[automatically_derived]
10116 impl alloy_sol_types::SolCall for quorumCountCall {
10117 type Parameters<'a> = ();
10118 type Token<'a> = <Self::Parameters<
10119 'a,
10120 > as alloy_sol_types::SolType>::Token<'a>;
10121 type Return = quorumCountReturn;
10122 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
10123 type ReturnToken<'a> = <Self::ReturnTuple<
10124 'a,
10125 > as alloy_sol_types::SolType>::Token<'a>;
10126 const SIGNATURE: &'static str = "quorumCount()";
10127 const SELECTOR: [u8; 4] = [154u8, 161u8, 101u8, 61u8];
10128 #[inline]
10129 fn new<'a>(
10130 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10131 ) -> Self {
10132 tuple.into()
10133 }
10134 #[inline]
10135 fn tokenize(&self) -> Self::Token<'_> {
10136 ()
10137 }
10138 #[inline]
10139 fn abi_decode_returns(
10140 data: &[u8],
10141 validate: bool,
10142 ) -> alloy_sol_types::Result<Self::Return> {
10143 <Self::ReturnTuple<
10144 '_,
10145 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
10146 .map(Into::into)
10147 }
10148 }
10149 };
10150 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10151 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10156 #[derive(Clone)]
10157 pub struct quorumUpdateBlockNumberCall {
10158 #[allow(missing_docs)]
10159 pub quorumNumber: u8,
10160 }
10161 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10162 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10164 #[derive(Clone)]
10165 pub struct quorumUpdateBlockNumberReturn {
10166 #[allow(missing_docs)]
10167 pub _0: alloy::sol_types::private::primitives::aliases::U256,
10168 }
10169 #[allow(
10170 non_camel_case_types,
10171 non_snake_case,
10172 clippy::pub_underscore_fields,
10173 clippy::style
10174 )]
10175 const _: () = {
10176 use alloy::sol_types as alloy_sol_types;
10177 {
10178 #[doc(hidden)]
10179 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
10180 #[doc(hidden)]
10181 type UnderlyingRustTuple<'a> = (u8,);
10182 #[cfg(test)]
10183 #[allow(dead_code, unreachable_patterns)]
10184 fn _type_assertion(
10185 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10186 ) {
10187 match _t {
10188 alloy_sol_types::private::AssertTypeEq::<
10189 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10190 >(_) => {}
10191 }
10192 }
10193 #[automatically_derived]
10194 #[doc(hidden)]
10195 impl ::core::convert::From<quorumUpdateBlockNumberCall>
10196 for UnderlyingRustTuple<'_> {
10197 fn from(value: quorumUpdateBlockNumberCall) -> Self {
10198 (value.quorumNumber,)
10199 }
10200 }
10201 #[automatically_derived]
10202 #[doc(hidden)]
10203 impl ::core::convert::From<UnderlyingRustTuple<'_>>
10204 for quorumUpdateBlockNumberCall {
10205 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10206 Self { quorumNumber: tuple.0 }
10207 }
10208 }
10209 }
10210 {
10211 #[doc(hidden)]
10212 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
10213 #[doc(hidden)]
10214 type UnderlyingRustTuple<'a> = (
10215 alloy::sol_types::private::primitives::aliases::U256,
10216 );
10217 #[cfg(test)]
10218 #[allow(dead_code, unreachable_patterns)]
10219 fn _type_assertion(
10220 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10221 ) {
10222 match _t {
10223 alloy_sol_types::private::AssertTypeEq::<
10224 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10225 >(_) => {}
10226 }
10227 }
10228 #[automatically_derived]
10229 #[doc(hidden)]
10230 impl ::core::convert::From<quorumUpdateBlockNumberReturn>
10231 for UnderlyingRustTuple<'_> {
10232 fn from(value: quorumUpdateBlockNumberReturn) -> Self {
10233 (value._0,)
10234 }
10235 }
10236 #[automatically_derived]
10237 #[doc(hidden)]
10238 impl ::core::convert::From<UnderlyingRustTuple<'_>>
10239 for quorumUpdateBlockNumberReturn {
10240 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10241 Self { _0: tuple.0 }
10242 }
10243 }
10244 }
10245 #[automatically_derived]
10246 impl alloy_sol_types::SolCall for quorumUpdateBlockNumberCall {
10247 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
10248 type Token<'a> = <Self::Parameters<
10249 'a,
10250 > as alloy_sol_types::SolType>::Token<'a>;
10251 type Return = quorumUpdateBlockNumberReturn;
10252 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
10253 type ReturnToken<'a> = <Self::ReturnTuple<
10254 'a,
10255 > as alloy_sol_types::SolType>::Token<'a>;
10256 const SIGNATURE: &'static str = "quorumUpdateBlockNumber(uint8)";
10257 const SELECTOR: [u8; 4] = [36u8, 154u8, 12u8, 66u8];
10258 #[inline]
10259 fn new<'a>(
10260 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10261 ) -> Self {
10262 tuple.into()
10263 }
10264 #[inline]
10265 fn tokenize(&self) -> Self::Token<'_> {
10266 (
10267 <alloy::sol_types::sol_data::Uint<
10268 8,
10269 > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
10270 )
10271 }
10272 #[inline]
10273 fn abi_decode_returns(
10274 data: &[u8],
10275 validate: bool,
10276 ) -> alloy_sol_types::Result<Self::Return> {
10277 <Self::ReturnTuple<
10278 '_,
10279 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
10280 .map(Into::into)
10281 }
10282 }
10283 };
10284 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10285 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10290 #[derive(Clone)]
10291 pub struct registerOperatorCall {
10292 #[allow(missing_docs)]
10293 pub operator: alloy::sol_types::private::Address,
10294 #[allow(missing_docs)]
10295 pub avs: alloy::sol_types::private::Address,
10296 #[allow(missing_docs)]
10297 pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
10298 #[allow(missing_docs)]
10299 pub data: alloy::sol_types::private::Bytes,
10300 }
10301 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10303 #[derive(Clone)]
10304 pub struct registerOperatorReturn {}
10305 #[allow(
10306 non_camel_case_types,
10307 non_snake_case,
10308 clippy::pub_underscore_fields,
10309 clippy::style
10310 )]
10311 const _: () = {
10312 use alloy::sol_types as alloy_sol_types;
10313 {
10314 #[doc(hidden)]
10315 type UnderlyingSolTuple<'a> = (
10316 alloy::sol_types::sol_data::Address,
10317 alloy::sol_types::sol_data::Address,
10318 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
10319 alloy::sol_types::sol_data::Bytes,
10320 );
10321 #[doc(hidden)]
10322 type UnderlyingRustTuple<'a> = (
10323 alloy::sol_types::private::Address,
10324 alloy::sol_types::private::Address,
10325 alloy::sol_types::private::Vec<u32>,
10326 alloy::sol_types::private::Bytes,
10327 );
10328 #[cfg(test)]
10329 #[allow(dead_code, unreachable_patterns)]
10330 fn _type_assertion(
10331 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10332 ) {
10333 match _t {
10334 alloy_sol_types::private::AssertTypeEq::<
10335 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10336 >(_) => {}
10337 }
10338 }
10339 #[automatically_derived]
10340 #[doc(hidden)]
10341 impl ::core::convert::From<registerOperatorCall>
10342 for UnderlyingRustTuple<'_> {
10343 fn from(value: registerOperatorCall) -> Self {
10344 (value.operator, value.avs, value.operatorSetIds, value.data)
10345 }
10346 }
10347 #[automatically_derived]
10348 #[doc(hidden)]
10349 impl ::core::convert::From<UnderlyingRustTuple<'_>>
10350 for registerOperatorCall {
10351 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10352 Self {
10353 operator: tuple.0,
10354 avs: tuple.1,
10355 operatorSetIds: tuple.2,
10356 data: tuple.3,
10357 }
10358 }
10359 }
10360 }
10361 {
10362 #[doc(hidden)]
10363 type UnderlyingSolTuple<'a> = ();
10364 #[doc(hidden)]
10365 type UnderlyingRustTuple<'a> = ();
10366 #[cfg(test)]
10367 #[allow(dead_code, unreachable_patterns)]
10368 fn _type_assertion(
10369 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10370 ) {
10371 match _t {
10372 alloy_sol_types::private::AssertTypeEq::<
10373 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10374 >(_) => {}
10375 }
10376 }
10377 #[automatically_derived]
10378 #[doc(hidden)]
10379 impl ::core::convert::From<registerOperatorReturn>
10380 for UnderlyingRustTuple<'_> {
10381 fn from(value: registerOperatorReturn) -> Self {
10382 ()
10383 }
10384 }
10385 #[automatically_derived]
10386 #[doc(hidden)]
10387 impl ::core::convert::From<UnderlyingRustTuple<'_>>
10388 for registerOperatorReturn {
10389 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10390 Self {}
10391 }
10392 }
10393 }
10394 #[automatically_derived]
10395 impl alloy_sol_types::SolCall for registerOperatorCall {
10396 type Parameters<'a> = (
10397 alloy::sol_types::sol_data::Address,
10398 alloy::sol_types::sol_data::Address,
10399 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
10400 alloy::sol_types::sol_data::Bytes,
10401 );
10402 type Token<'a> = <Self::Parameters<
10403 'a,
10404 > as alloy_sol_types::SolType>::Token<'a>;
10405 type Return = registerOperatorReturn;
10406 type ReturnTuple<'a> = ();
10407 type ReturnToken<'a> = <Self::ReturnTuple<
10408 'a,
10409 > as alloy_sol_types::SolType>::Token<'a>;
10410 const SIGNATURE: &'static str = "registerOperator(address,address,uint32[],bytes)";
10411 const SELECTOR: [u8; 4] = [198u8, 63u8, 213u8, 2u8];
10412 #[inline]
10413 fn new<'a>(
10414 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10415 ) -> Self {
10416 tuple.into()
10417 }
10418 #[inline]
10419 fn tokenize(&self) -> Self::Token<'_> {
10420 (
10421 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10422 &self.operator,
10423 ),
10424 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10425 &self.avs,
10426 ),
10427 <alloy::sol_types::sol_data::Array<
10428 alloy::sol_types::sol_data::Uint<32>,
10429 > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
10430 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
10431 &self.data,
10432 ),
10433 )
10434 }
10435 #[inline]
10436 fn abi_decode_returns(
10437 data: &[u8],
10438 validate: bool,
10439 ) -> alloy_sol_types::Result<Self::Return> {
10440 <Self::ReturnTuple<
10441 '_,
10442 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
10443 .map(Into::into)
10444 }
10445 }
10446 };
10447 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10448 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10453 #[derive(Clone)]
10454 pub struct setAVSCall {
10455 #[allow(missing_docs)]
10456 pub _avs: alloy::sol_types::private::Address,
10457 }
10458 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10460 #[derive(Clone)]
10461 pub struct setAVSReturn {}
10462 #[allow(
10463 non_camel_case_types,
10464 non_snake_case,
10465 clippy::pub_underscore_fields,
10466 clippy::style
10467 )]
10468 const _: () = {
10469 use alloy::sol_types as alloy_sol_types;
10470 {
10471 #[doc(hidden)]
10472 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
10473 #[doc(hidden)]
10474 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
10475 #[cfg(test)]
10476 #[allow(dead_code, unreachable_patterns)]
10477 fn _type_assertion(
10478 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10479 ) {
10480 match _t {
10481 alloy_sol_types::private::AssertTypeEq::<
10482 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10483 >(_) => {}
10484 }
10485 }
10486 #[automatically_derived]
10487 #[doc(hidden)]
10488 impl ::core::convert::From<setAVSCall> for UnderlyingRustTuple<'_> {
10489 fn from(value: setAVSCall) -> Self {
10490 (value._avs,)
10491 }
10492 }
10493 #[automatically_derived]
10494 #[doc(hidden)]
10495 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAVSCall {
10496 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10497 Self { _avs: tuple.0 }
10498 }
10499 }
10500 }
10501 {
10502 #[doc(hidden)]
10503 type UnderlyingSolTuple<'a> = ();
10504 #[doc(hidden)]
10505 type UnderlyingRustTuple<'a> = ();
10506 #[cfg(test)]
10507 #[allow(dead_code, unreachable_patterns)]
10508 fn _type_assertion(
10509 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10510 ) {
10511 match _t {
10512 alloy_sol_types::private::AssertTypeEq::<
10513 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10514 >(_) => {}
10515 }
10516 }
10517 #[automatically_derived]
10518 #[doc(hidden)]
10519 impl ::core::convert::From<setAVSReturn> for UnderlyingRustTuple<'_> {
10520 fn from(value: setAVSReturn) -> Self {
10521 ()
10522 }
10523 }
10524 #[automatically_derived]
10525 #[doc(hidden)]
10526 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAVSReturn {
10527 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10528 Self {}
10529 }
10530 }
10531 }
10532 #[automatically_derived]
10533 impl alloy_sol_types::SolCall for setAVSCall {
10534 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
10535 type Token<'a> = <Self::Parameters<
10536 'a,
10537 > as alloy_sol_types::SolType>::Token<'a>;
10538 type Return = setAVSReturn;
10539 type ReturnTuple<'a> = ();
10540 type ReturnToken<'a> = <Self::ReturnTuple<
10541 'a,
10542 > as alloy_sol_types::SolType>::Token<'a>;
10543 const SIGNATURE: &'static str = "setAVS(address)";
10544 const SELECTOR: [u8; 4] = [166u8, 84u8, 151u8, 198u8];
10545 #[inline]
10546 fn new<'a>(
10547 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10548 ) -> Self {
10549 tuple.into()
10550 }
10551 #[inline]
10552 fn tokenize(&self) -> Self::Token<'_> {
10553 (
10554 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10555 &self._avs,
10556 ),
10557 )
10558 }
10559 #[inline]
10560 fn abi_decode_returns(
10561 data: &[u8],
10562 validate: bool,
10563 ) -> alloy_sol_types::Result<Self::Return> {
10564 <Self::ReturnTuple<
10565 '_,
10566 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
10567 .map(Into::into)
10568 }
10569 }
10570 };
10571 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10572 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10577 #[derive(Clone)]
10578 pub struct setChurnApproverCall {
10579 #[allow(missing_docs)]
10580 pub _churnApprover: alloy::sol_types::private::Address,
10581 }
10582 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10584 #[derive(Clone)]
10585 pub struct setChurnApproverReturn {}
10586 #[allow(
10587 non_camel_case_types,
10588 non_snake_case,
10589 clippy::pub_underscore_fields,
10590 clippy::style
10591 )]
10592 const _: () = {
10593 use alloy::sol_types as alloy_sol_types;
10594 {
10595 #[doc(hidden)]
10596 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
10597 #[doc(hidden)]
10598 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
10599 #[cfg(test)]
10600 #[allow(dead_code, unreachable_patterns)]
10601 fn _type_assertion(
10602 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10603 ) {
10604 match _t {
10605 alloy_sol_types::private::AssertTypeEq::<
10606 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10607 >(_) => {}
10608 }
10609 }
10610 #[automatically_derived]
10611 #[doc(hidden)]
10612 impl ::core::convert::From<setChurnApproverCall>
10613 for UnderlyingRustTuple<'_> {
10614 fn from(value: setChurnApproverCall) -> Self {
10615 (value._churnApprover,)
10616 }
10617 }
10618 #[automatically_derived]
10619 #[doc(hidden)]
10620 impl ::core::convert::From<UnderlyingRustTuple<'_>>
10621 for setChurnApproverCall {
10622 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10623 Self { _churnApprover: tuple.0 }
10624 }
10625 }
10626 }
10627 {
10628 #[doc(hidden)]
10629 type UnderlyingSolTuple<'a> = ();
10630 #[doc(hidden)]
10631 type UnderlyingRustTuple<'a> = ();
10632 #[cfg(test)]
10633 #[allow(dead_code, unreachable_patterns)]
10634 fn _type_assertion(
10635 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10636 ) {
10637 match _t {
10638 alloy_sol_types::private::AssertTypeEq::<
10639 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10640 >(_) => {}
10641 }
10642 }
10643 #[automatically_derived]
10644 #[doc(hidden)]
10645 impl ::core::convert::From<setChurnApproverReturn>
10646 for UnderlyingRustTuple<'_> {
10647 fn from(value: setChurnApproverReturn) -> Self {
10648 ()
10649 }
10650 }
10651 #[automatically_derived]
10652 #[doc(hidden)]
10653 impl ::core::convert::From<UnderlyingRustTuple<'_>>
10654 for setChurnApproverReturn {
10655 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10656 Self {}
10657 }
10658 }
10659 }
10660 #[automatically_derived]
10661 impl alloy_sol_types::SolCall for setChurnApproverCall {
10662 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
10663 type Token<'a> = <Self::Parameters<
10664 'a,
10665 > as alloy_sol_types::SolType>::Token<'a>;
10666 type Return = setChurnApproverReturn;
10667 type ReturnTuple<'a> = ();
10668 type ReturnToken<'a> = <Self::ReturnTuple<
10669 'a,
10670 > as alloy_sol_types::SolType>::Token<'a>;
10671 const SIGNATURE: &'static str = "setChurnApprover(address)";
10672 const SELECTOR: [u8; 4] = [41u8, 209u8, 224u8, 195u8];
10673 #[inline]
10674 fn new<'a>(
10675 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10676 ) -> Self {
10677 tuple.into()
10678 }
10679 #[inline]
10680 fn tokenize(&self) -> Self::Token<'_> {
10681 (
10682 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10683 &self._churnApprover,
10684 ),
10685 )
10686 }
10687 #[inline]
10688 fn abi_decode_returns(
10689 data: &[u8],
10690 validate: bool,
10691 ) -> alloy_sol_types::Result<Self::Return> {
10692 <Self::ReturnTuple<
10693 '_,
10694 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
10695 .map(Into::into)
10696 }
10697 }
10698 };
10699 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10700 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10705 #[derive(Clone)]
10706 pub struct setEjectionCooldownCall {
10707 #[allow(missing_docs)]
10708 pub _ejectionCooldown: alloy::sol_types::private::primitives::aliases::U256,
10709 }
10710 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10712 #[derive(Clone)]
10713 pub struct setEjectionCooldownReturn {}
10714 #[allow(
10715 non_camel_case_types,
10716 non_snake_case,
10717 clippy::pub_underscore_fields,
10718 clippy::style
10719 )]
10720 const _: () = {
10721 use alloy::sol_types as alloy_sol_types;
10722 {
10723 #[doc(hidden)]
10724 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
10725 #[doc(hidden)]
10726 type UnderlyingRustTuple<'a> = (
10727 alloy::sol_types::private::primitives::aliases::U256,
10728 );
10729 #[cfg(test)]
10730 #[allow(dead_code, unreachable_patterns)]
10731 fn _type_assertion(
10732 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10733 ) {
10734 match _t {
10735 alloy_sol_types::private::AssertTypeEq::<
10736 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10737 >(_) => {}
10738 }
10739 }
10740 #[automatically_derived]
10741 #[doc(hidden)]
10742 impl ::core::convert::From<setEjectionCooldownCall>
10743 for UnderlyingRustTuple<'_> {
10744 fn from(value: setEjectionCooldownCall) -> Self {
10745 (value._ejectionCooldown,)
10746 }
10747 }
10748 #[automatically_derived]
10749 #[doc(hidden)]
10750 impl ::core::convert::From<UnderlyingRustTuple<'_>>
10751 for setEjectionCooldownCall {
10752 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10753 Self { _ejectionCooldown: tuple.0 }
10754 }
10755 }
10756 }
10757 {
10758 #[doc(hidden)]
10759 type UnderlyingSolTuple<'a> = ();
10760 #[doc(hidden)]
10761 type UnderlyingRustTuple<'a> = ();
10762 #[cfg(test)]
10763 #[allow(dead_code, unreachable_patterns)]
10764 fn _type_assertion(
10765 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10766 ) {
10767 match _t {
10768 alloy_sol_types::private::AssertTypeEq::<
10769 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10770 >(_) => {}
10771 }
10772 }
10773 #[automatically_derived]
10774 #[doc(hidden)]
10775 impl ::core::convert::From<setEjectionCooldownReturn>
10776 for UnderlyingRustTuple<'_> {
10777 fn from(value: setEjectionCooldownReturn) -> Self {
10778 ()
10779 }
10780 }
10781 #[automatically_derived]
10782 #[doc(hidden)]
10783 impl ::core::convert::From<UnderlyingRustTuple<'_>>
10784 for setEjectionCooldownReturn {
10785 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10786 Self {}
10787 }
10788 }
10789 }
10790 #[automatically_derived]
10791 impl alloy_sol_types::SolCall for setEjectionCooldownCall {
10792 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
10793 type Token<'a> = <Self::Parameters<
10794 'a,
10795 > as alloy_sol_types::SolType>::Token<'a>;
10796 type Return = setEjectionCooldownReturn;
10797 type ReturnTuple<'a> = ();
10798 type ReturnToken<'a> = <Self::ReturnTuple<
10799 'a,
10800 > as alloy_sol_types::SolType>::Token<'a>;
10801 const SIGNATURE: &'static str = "setEjectionCooldown(uint256)";
10802 const SELECTOR: [u8; 4] = [13u8, 63u8, 33u8, 52u8];
10803 #[inline]
10804 fn new<'a>(
10805 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10806 ) -> Self {
10807 tuple.into()
10808 }
10809 #[inline]
10810 fn tokenize(&self) -> Self::Token<'_> {
10811 (
10812 <alloy::sol_types::sol_data::Uint<
10813 256,
10814 > as alloy_sol_types::SolType>::tokenize(&self._ejectionCooldown),
10815 )
10816 }
10817 #[inline]
10818 fn abi_decode_returns(
10819 data: &[u8],
10820 validate: bool,
10821 ) -> alloy_sol_types::Result<Self::Return> {
10822 <Self::ReturnTuple<
10823 '_,
10824 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
10825 .map(Into::into)
10826 }
10827 }
10828 };
10829 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10830 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10835 #[derive(Clone)]
10836 pub struct setEjectorCall {
10837 #[allow(missing_docs)]
10838 pub _ejector: alloy::sol_types::private::Address,
10839 }
10840 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10842 #[derive(Clone)]
10843 pub struct setEjectorReturn {}
10844 #[allow(
10845 non_camel_case_types,
10846 non_snake_case,
10847 clippy::pub_underscore_fields,
10848 clippy::style
10849 )]
10850 const _: () = {
10851 use alloy::sol_types as alloy_sol_types;
10852 {
10853 #[doc(hidden)]
10854 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
10855 #[doc(hidden)]
10856 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
10857 #[cfg(test)]
10858 #[allow(dead_code, unreachable_patterns)]
10859 fn _type_assertion(
10860 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10861 ) {
10862 match _t {
10863 alloy_sol_types::private::AssertTypeEq::<
10864 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10865 >(_) => {}
10866 }
10867 }
10868 #[automatically_derived]
10869 #[doc(hidden)]
10870 impl ::core::convert::From<setEjectorCall> for UnderlyingRustTuple<'_> {
10871 fn from(value: setEjectorCall) -> Self {
10872 (value._ejector,)
10873 }
10874 }
10875 #[automatically_derived]
10876 #[doc(hidden)]
10877 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setEjectorCall {
10878 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10879 Self { _ejector: tuple.0 }
10880 }
10881 }
10882 }
10883 {
10884 #[doc(hidden)]
10885 type UnderlyingSolTuple<'a> = ();
10886 #[doc(hidden)]
10887 type UnderlyingRustTuple<'a> = ();
10888 #[cfg(test)]
10889 #[allow(dead_code, unreachable_patterns)]
10890 fn _type_assertion(
10891 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10892 ) {
10893 match _t {
10894 alloy_sol_types::private::AssertTypeEq::<
10895 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10896 >(_) => {}
10897 }
10898 }
10899 #[automatically_derived]
10900 #[doc(hidden)]
10901 impl ::core::convert::From<setEjectorReturn> for UnderlyingRustTuple<'_> {
10902 fn from(value: setEjectorReturn) -> Self {
10903 ()
10904 }
10905 }
10906 #[automatically_derived]
10907 #[doc(hidden)]
10908 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setEjectorReturn {
10909 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10910 Self {}
10911 }
10912 }
10913 }
10914 #[automatically_derived]
10915 impl alloy_sol_types::SolCall for setEjectorCall {
10916 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
10917 type Token<'a> = <Self::Parameters<
10918 'a,
10919 > as alloy_sol_types::SolType>::Token<'a>;
10920 type Return = setEjectorReturn;
10921 type ReturnTuple<'a> = ();
10922 type ReturnToken<'a> = <Self::ReturnTuple<
10923 'a,
10924 > as alloy_sol_types::SolType>::Token<'a>;
10925 const SIGNATURE: &'static str = "setEjector(address)";
10926 const SELECTOR: [u8; 4] = [44u8, 221u8, 30u8, 134u8];
10927 #[inline]
10928 fn new<'a>(
10929 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10930 ) -> Self {
10931 tuple.into()
10932 }
10933 #[inline]
10934 fn tokenize(&self) -> Self::Token<'_> {
10935 (
10936 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10937 &self._ejector,
10938 ),
10939 )
10940 }
10941 #[inline]
10942 fn abi_decode_returns(
10943 data: &[u8],
10944 validate: bool,
10945 ) -> alloy_sol_types::Result<Self::Return> {
10946 <Self::ReturnTuple<
10947 '_,
10948 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
10949 .map(Into::into)
10950 }
10951 }
10952 };
10953 #[derive(Default, Debug, PartialEq, Eq, Hash)]
10954 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10959 #[derive(Clone)]
10960 pub struct setOperatorSetParamsCall {
10961 #[allow(missing_docs)]
10962 pub quorumNumber: u8,
10963 #[allow(missing_docs)]
10964 pub operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
10965 }
10966 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10968 #[derive(Clone)]
10969 pub struct setOperatorSetParamsReturn {}
10970 #[allow(
10971 non_camel_case_types,
10972 non_snake_case,
10973 clippy::pub_underscore_fields,
10974 clippy::style
10975 )]
10976 const _: () = {
10977 use alloy::sol_types as alloy_sol_types;
10978 {
10979 #[doc(hidden)]
10980 type UnderlyingSolTuple<'a> = (
10981 alloy::sol_types::sol_data::Uint<8>,
10982 ISlashingRegistryCoordinatorTypes::OperatorSetParam,
10983 );
10984 #[doc(hidden)]
10985 type UnderlyingRustTuple<'a> = (
10986 u8,
10987 <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
10988 );
10989 #[cfg(test)]
10990 #[allow(dead_code, unreachable_patterns)]
10991 fn _type_assertion(
10992 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10993 ) {
10994 match _t {
10995 alloy_sol_types::private::AssertTypeEq::<
10996 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10997 >(_) => {}
10998 }
10999 }
11000 #[automatically_derived]
11001 #[doc(hidden)]
11002 impl ::core::convert::From<setOperatorSetParamsCall>
11003 for UnderlyingRustTuple<'_> {
11004 fn from(value: setOperatorSetParamsCall) -> Self {
11005 (value.quorumNumber, value.operatorSetParams)
11006 }
11007 }
11008 #[automatically_derived]
11009 #[doc(hidden)]
11010 impl ::core::convert::From<UnderlyingRustTuple<'_>>
11011 for setOperatorSetParamsCall {
11012 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11013 Self {
11014 quorumNumber: tuple.0,
11015 operatorSetParams: tuple.1,
11016 }
11017 }
11018 }
11019 }
11020 {
11021 #[doc(hidden)]
11022 type UnderlyingSolTuple<'a> = ();
11023 #[doc(hidden)]
11024 type UnderlyingRustTuple<'a> = ();
11025 #[cfg(test)]
11026 #[allow(dead_code, unreachable_patterns)]
11027 fn _type_assertion(
11028 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11029 ) {
11030 match _t {
11031 alloy_sol_types::private::AssertTypeEq::<
11032 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11033 >(_) => {}
11034 }
11035 }
11036 #[automatically_derived]
11037 #[doc(hidden)]
11038 impl ::core::convert::From<setOperatorSetParamsReturn>
11039 for UnderlyingRustTuple<'_> {
11040 fn from(value: setOperatorSetParamsReturn) -> Self {
11041 ()
11042 }
11043 }
11044 #[automatically_derived]
11045 #[doc(hidden)]
11046 impl ::core::convert::From<UnderlyingRustTuple<'_>>
11047 for setOperatorSetParamsReturn {
11048 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11049 Self {}
11050 }
11051 }
11052 }
11053 #[automatically_derived]
11054 impl alloy_sol_types::SolCall for setOperatorSetParamsCall {
11055 type Parameters<'a> = (
11056 alloy::sol_types::sol_data::Uint<8>,
11057 ISlashingRegistryCoordinatorTypes::OperatorSetParam,
11058 );
11059 type Token<'a> = <Self::Parameters<
11060 'a,
11061 > as alloy_sol_types::SolType>::Token<'a>;
11062 type Return = setOperatorSetParamsReturn;
11063 type ReturnTuple<'a> = ();
11064 type ReturnToken<'a> = <Self::ReturnTuple<
11065 'a,
11066 > as alloy_sol_types::SolType>::Token<'a>;
11067 const SIGNATURE: &'static str = "setOperatorSetParams(uint8,(uint32,uint16,uint16))";
11068 const SELECTOR: [u8; 4] = [91u8, 11u8, 130u8, 159u8];
11069 #[inline]
11070 fn new<'a>(
11071 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11072 ) -> Self {
11073 tuple.into()
11074 }
11075 #[inline]
11076 fn tokenize(&self) -> Self::Token<'_> {
11077 (
11078 <alloy::sol_types::sol_data::Uint<
11079 8,
11080 > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
11081 <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy_sol_types::SolType>::tokenize(
11082 &self.operatorSetParams,
11083 ),
11084 )
11085 }
11086 #[inline]
11087 fn abi_decode_returns(
11088 data: &[u8],
11089 validate: bool,
11090 ) -> alloy_sol_types::Result<Self::Return> {
11091 <Self::ReturnTuple<
11092 '_,
11093 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11094 .map(Into::into)
11095 }
11096 }
11097 };
11098 #[derive(Default, Debug, PartialEq, Eq, Hash)]
11099 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11104 #[derive(Clone)]
11105 pub struct socketRegistryCall {}
11106 #[derive(Default, Debug, PartialEq, Eq, Hash)]
11107 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11109 #[derive(Clone)]
11110 pub struct socketRegistryReturn {
11111 #[allow(missing_docs)]
11112 pub _0: alloy::sol_types::private::Address,
11113 }
11114 #[allow(
11115 non_camel_case_types,
11116 non_snake_case,
11117 clippy::pub_underscore_fields,
11118 clippy::style
11119 )]
11120 const _: () = {
11121 use alloy::sol_types as alloy_sol_types;
11122 {
11123 #[doc(hidden)]
11124 type UnderlyingSolTuple<'a> = ();
11125 #[doc(hidden)]
11126 type UnderlyingRustTuple<'a> = ();
11127 #[cfg(test)]
11128 #[allow(dead_code, unreachable_patterns)]
11129 fn _type_assertion(
11130 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11131 ) {
11132 match _t {
11133 alloy_sol_types::private::AssertTypeEq::<
11134 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11135 >(_) => {}
11136 }
11137 }
11138 #[automatically_derived]
11139 #[doc(hidden)]
11140 impl ::core::convert::From<socketRegistryCall> for UnderlyingRustTuple<'_> {
11141 fn from(value: socketRegistryCall) -> Self {
11142 ()
11143 }
11144 }
11145 #[automatically_derived]
11146 #[doc(hidden)]
11147 impl ::core::convert::From<UnderlyingRustTuple<'_>> for socketRegistryCall {
11148 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11149 Self {}
11150 }
11151 }
11152 }
11153 {
11154 #[doc(hidden)]
11155 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11156 #[doc(hidden)]
11157 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11158 #[cfg(test)]
11159 #[allow(dead_code, unreachable_patterns)]
11160 fn _type_assertion(
11161 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11162 ) {
11163 match _t {
11164 alloy_sol_types::private::AssertTypeEq::<
11165 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11166 >(_) => {}
11167 }
11168 }
11169 #[automatically_derived]
11170 #[doc(hidden)]
11171 impl ::core::convert::From<socketRegistryReturn>
11172 for UnderlyingRustTuple<'_> {
11173 fn from(value: socketRegistryReturn) -> Self {
11174 (value._0,)
11175 }
11176 }
11177 #[automatically_derived]
11178 #[doc(hidden)]
11179 impl ::core::convert::From<UnderlyingRustTuple<'_>>
11180 for socketRegistryReturn {
11181 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11182 Self { _0: tuple.0 }
11183 }
11184 }
11185 }
11186 #[automatically_derived]
11187 impl alloy_sol_types::SolCall for socketRegistryCall {
11188 type Parameters<'a> = ();
11189 type Token<'a> = <Self::Parameters<
11190 'a,
11191 > as alloy_sol_types::SolType>::Token<'a>;
11192 type Return = socketRegistryReturn;
11193 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
11194 type ReturnToken<'a> = <Self::ReturnTuple<
11195 'a,
11196 > as alloy_sol_types::SolType>::Token<'a>;
11197 const SIGNATURE: &'static str = "socketRegistry()";
11198 const SELECTOR: [u8; 4] = [234u8, 50u8, 175u8, 174u8];
11199 #[inline]
11200 fn new<'a>(
11201 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11202 ) -> Self {
11203 tuple.into()
11204 }
11205 #[inline]
11206 fn tokenize(&self) -> Self::Token<'_> {
11207 ()
11208 }
11209 #[inline]
11210 fn abi_decode_returns(
11211 data: &[u8],
11212 validate: bool,
11213 ) -> alloy_sol_types::Result<Self::Return> {
11214 <Self::ReturnTuple<
11215 '_,
11216 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11217 .map(Into::into)
11218 }
11219 }
11220 };
11221 #[derive(Default, Debug, PartialEq, Eq, Hash)]
11222 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11227 #[derive(Clone)]
11228 pub struct stakeRegistryCall {}
11229 #[derive(Default, Debug, PartialEq, Eq, Hash)]
11230 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11232 #[derive(Clone)]
11233 pub struct stakeRegistryReturn {
11234 #[allow(missing_docs)]
11235 pub _0: alloy::sol_types::private::Address,
11236 }
11237 #[allow(
11238 non_camel_case_types,
11239 non_snake_case,
11240 clippy::pub_underscore_fields,
11241 clippy::style
11242 )]
11243 const _: () = {
11244 use alloy::sol_types as alloy_sol_types;
11245 {
11246 #[doc(hidden)]
11247 type UnderlyingSolTuple<'a> = ();
11248 #[doc(hidden)]
11249 type UnderlyingRustTuple<'a> = ();
11250 #[cfg(test)]
11251 #[allow(dead_code, unreachable_patterns)]
11252 fn _type_assertion(
11253 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11254 ) {
11255 match _t {
11256 alloy_sol_types::private::AssertTypeEq::<
11257 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11258 >(_) => {}
11259 }
11260 }
11261 #[automatically_derived]
11262 #[doc(hidden)]
11263 impl ::core::convert::From<stakeRegistryCall> for UnderlyingRustTuple<'_> {
11264 fn from(value: stakeRegistryCall) -> Self {
11265 ()
11266 }
11267 }
11268 #[automatically_derived]
11269 #[doc(hidden)]
11270 impl ::core::convert::From<UnderlyingRustTuple<'_>> for stakeRegistryCall {
11271 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11272 Self {}
11273 }
11274 }
11275 }
11276 {
11277 #[doc(hidden)]
11278 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11279 #[doc(hidden)]
11280 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11281 #[cfg(test)]
11282 #[allow(dead_code, unreachable_patterns)]
11283 fn _type_assertion(
11284 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11285 ) {
11286 match _t {
11287 alloy_sol_types::private::AssertTypeEq::<
11288 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11289 >(_) => {}
11290 }
11291 }
11292 #[automatically_derived]
11293 #[doc(hidden)]
11294 impl ::core::convert::From<stakeRegistryReturn> for UnderlyingRustTuple<'_> {
11295 fn from(value: stakeRegistryReturn) -> Self {
11296 (value._0,)
11297 }
11298 }
11299 #[automatically_derived]
11300 #[doc(hidden)]
11301 impl ::core::convert::From<UnderlyingRustTuple<'_>> for stakeRegistryReturn {
11302 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11303 Self { _0: tuple.0 }
11304 }
11305 }
11306 }
11307 #[automatically_derived]
11308 impl alloy_sol_types::SolCall for stakeRegistryCall {
11309 type Parameters<'a> = ();
11310 type Token<'a> = <Self::Parameters<
11311 'a,
11312 > as alloy_sol_types::SolType>::Token<'a>;
11313 type Return = stakeRegistryReturn;
11314 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
11315 type ReturnToken<'a> = <Self::ReturnTuple<
11316 'a,
11317 > as alloy_sol_types::SolType>::Token<'a>;
11318 const SIGNATURE: &'static str = "stakeRegistry()";
11319 const SELECTOR: [u8; 4] = [104u8, 48u8, 72u8, 53u8];
11320 #[inline]
11321 fn new<'a>(
11322 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11323 ) -> Self {
11324 tuple.into()
11325 }
11326 #[inline]
11327 fn tokenize(&self) -> Self::Token<'_> {
11328 ()
11329 }
11330 #[inline]
11331 fn abi_decode_returns(
11332 data: &[u8],
11333 validate: bool,
11334 ) -> alloy_sol_types::Result<Self::Return> {
11335 <Self::ReturnTuple<
11336 '_,
11337 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11338 .map(Into::into)
11339 }
11340 }
11341 };
11342 #[derive(Default, Debug, PartialEq, Eq, Hash)]
11343 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11348 #[derive(Clone)]
11349 pub struct supportsAVSCall {
11350 #[allow(missing_docs)]
11351 pub avs: alloy::sol_types::private::Address,
11352 }
11353 #[derive(Default, Debug, PartialEq, Eq, Hash)]
11354 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11356 #[derive(Clone)]
11357 pub struct supportsAVSReturn {
11358 #[allow(missing_docs)]
11359 pub _0: bool,
11360 }
11361 #[allow(
11362 non_camel_case_types,
11363 non_snake_case,
11364 clippy::pub_underscore_fields,
11365 clippy::style
11366 )]
11367 const _: () = {
11368 use alloy::sol_types as alloy_sol_types;
11369 {
11370 #[doc(hidden)]
11371 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
11372 #[doc(hidden)]
11373 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
11374 #[cfg(test)]
11375 #[allow(dead_code, unreachable_patterns)]
11376 fn _type_assertion(
11377 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11378 ) {
11379 match _t {
11380 alloy_sol_types::private::AssertTypeEq::<
11381 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11382 >(_) => {}
11383 }
11384 }
11385 #[automatically_derived]
11386 #[doc(hidden)]
11387 impl ::core::convert::From<supportsAVSCall> for UnderlyingRustTuple<'_> {
11388 fn from(value: supportsAVSCall) -> Self {
11389 (value.avs,)
11390 }
11391 }
11392 #[automatically_derived]
11393 #[doc(hidden)]
11394 impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportsAVSCall {
11395 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11396 Self { avs: tuple.0 }
11397 }
11398 }
11399 }
11400 {
11401 #[doc(hidden)]
11402 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
11403 #[doc(hidden)]
11404 type UnderlyingRustTuple<'a> = (bool,);
11405 #[cfg(test)]
11406 #[allow(dead_code, unreachable_patterns)]
11407 fn _type_assertion(
11408 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11409 ) {
11410 match _t {
11411 alloy_sol_types::private::AssertTypeEq::<
11412 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11413 >(_) => {}
11414 }
11415 }
11416 #[automatically_derived]
11417 #[doc(hidden)]
11418 impl ::core::convert::From<supportsAVSReturn> for UnderlyingRustTuple<'_> {
11419 fn from(value: supportsAVSReturn) -> Self {
11420 (value._0,)
11421 }
11422 }
11423 #[automatically_derived]
11424 #[doc(hidden)]
11425 impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportsAVSReturn {
11426 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11427 Self { _0: tuple.0 }
11428 }
11429 }
11430 }
11431 #[automatically_derived]
11432 impl alloy_sol_types::SolCall for supportsAVSCall {
11433 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
11434 type Token<'a> = <Self::Parameters<
11435 'a,
11436 > as alloy_sol_types::SolType>::Token<'a>;
11437 type Return = supportsAVSReturn;
11438 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
11439 type ReturnToken<'a> = <Self::ReturnTuple<
11440 'a,
11441 > as alloy_sol_types::SolType>::Token<'a>;
11442 const SIGNATURE: &'static str = "supportsAVS(address)";
11443 const SELECTOR: [u8; 4] = [181u8, 38u8, 87u8, 135u8];
11444 #[inline]
11445 fn new<'a>(
11446 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11447 ) -> Self {
11448 tuple.into()
11449 }
11450 #[inline]
11451 fn tokenize(&self) -> Self::Token<'_> {
11452 (
11453 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11454 &self.avs,
11455 ),
11456 )
11457 }
11458 #[inline]
11459 fn abi_decode_returns(
11460 data: &[u8],
11461 validate: bool,
11462 ) -> alloy_sol_types::Result<Self::Return> {
11463 <Self::ReturnTuple<
11464 '_,
11465 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11466 .map(Into::into)
11467 }
11468 }
11469 };
11470 #[derive(Default, Debug, PartialEq, Eq, Hash)]
11471 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11476 #[derive(Clone)]
11477 pub struct updateOperatorsCall {
11478 #[allow(missing_docs)]
11479 pub operators: alloy::sol_types::private::Vec<
11480 alloy::sol_types::private::Address,
11481 >,
11482 }
11483 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11485 #[derive(Clone)]
11486 pub struct updateOperatorsReturn {}
11487 #[allow(
11488 non_camel_case_types,
11489 non_snake_case,
11490 clippy::pub_underscore_fields,
11491 clippy::style
11492 )]
11493 const _: () = {
11494 use alloy::sol_types as alloy_sol_types;
11495 {
11496 #[doc(hidden)]
11497 type UnderlyingSolTuple<'a> = (
11498 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
11499 );
11500 #[doc(hidden)]
11501 type UnderlyingRustTuple<'a> = (
11502 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
11503 );
11504 #[cfg(test)]
11505 #[allow(dead_code, unreachable_patterns)]
11506 fn _type_assertion(
11507 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11508 ) {
11509 match _t {
11510 alloy_sol_types::private::AssertTypeEq::<
11511 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11512 >(_) => {}
11513 }
11514 }
11515 #[automatically_derived]
11516 #[doc(hidden)]
11517 impl ::core::convert::From<updateOperatorsCall> for UnderlyingRustTuple<'_> {
11518 fn from(value: updateOperatorsCall) -> Self {
11519 (value.operators,)
11520 }
11521 }
11522 #[automatically_derived]
11523 #[doc(hidden)]
11524 impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateOperatorsCall {
11525 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11526 Self { operators: tuple.0 }
11527 }
11528 }
11529 }
11530 {
11531 #[doc(hidden)]
11532 type UnderlyingSolTuple<'a> = ();
11533 #[doc(hidden)]
11534 type UnderlyingRustTuple<'a> = ();
11535 #[cfg(test)]
11536 #[allow(dead_code, unreachable_patterns)]
11537 fn _type_assertion(
11538 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11539 ) {
11540 match _t {
11541 alloy_sol_types::private::AssertTypeEq::<
11542 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11543 >(_) => {}
11544 }
11545 }
11546 #[automatically_derived]
11547 #[doc(hidden)]
11548 impl ::core::convert::From<updateOperatorsReturn>
11549 for UnderlyingRustTuple<'_> {
11550 fn from(value: updateOperatorsReturn) -> Self {
11551 ()
11552 }
11553 }
11554 #[automatically_derived]
11555 #[doc(hidden)]
11556 impl ::core::convert::From<UnderlyingRustTuple<'_>>
11557 for updateOperatorsReturn {
11558 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11559 Self {}
11560 }
11561 }
11562 }
11563 #[automatically_derived]
11564 impl alloy_sol_types::SolCall for updateOperatorsCall {
11565 type Parameters<'a> = (
11566 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
11567 );
11568 type Token<'a> = <Self::Parameters<
11569 'a,
11570 > as alloy_sol_types::SolType>::Token<'a>;
11571 type Return = updateOperatorsReturn;
11572 type ReturnTuple<'a> = ();
11573 type ReturnToken<'a> = <Self::ReturnTuple<
11574 'a,
11575 > as alloy_sol_types::SolType>::Token<'a>;
11576 const SIGNATURE: &'static str = "updateOperators(address[])";
11577 const SELECTOR: [u8; 4] = [0u8, 207u8, 42u8, 181u8];
11578 #[inline]
11579 fn new<'a>(
11580 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11581 ) -> Self {
11582 tuple.into()
11583 }
11584 #[inline]
11585 fn tokenize(&self) -> Self::Token<'_> {
11586 (
11587 <alloy::sol_types::sol_data::Array<
11588 alloy::sol_types::sol_data::Address,
11589 > as alloy_sol_types::SolType>::tokenize(&self.operators),
11590 )
11591 }
11592 #[inline]
11593 fn abi_decode_returns(
11594 data: &[u8],
11595 validate: bool,
11596 ) -> alloy_sol_types::Result<Self::Return> {
11597 <Self::ReturnTuple<
11598 '_,
11599 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11600 .map(Into::into)
11601 }
11602 }
11603 };
11604 #[derive(Default, Debug, PartialEq, Eq, Hash)]
11605 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11610 #[derive(Clone)]
11611 pub struct updateOperatorsForQuorumCall {
11612 #[allow(missing_docs)]
11613 pub operatorsPerQuorum: alloy::sol_types::private::Vec<
11614 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
11615 >,
11616 #[allow(missing_docs)]
11617 pub quorumNumbers: alloy::sol_types::private::Bytes,
11618 }
11619 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11621 #[derive(Clone)]
11622 pub struct updateOperatorsForQuorumReturn {}
11623 #[allow(
11624 non_camel_case_types,
11625 non_snake_case,
11626 clippy::pub_underscore_fields,
11627 clippy::style
11628 )]
11629 const _: () = {
11630 use alloy::sol_types as alloy_sol_types;
11631 {
11632 #[doc(hidden)]
11633 type UnderlyingSolTuple<'a> = (
11634 alloy::sol_types::sol_data::Array<
11635 alloy::sol_types::sol_data::Array<
11636 alloy::sol_types::sol_data::Address,
11637 >,
11638 >,
11639 alloy::sol_types::sol_data::Bytes,
11640 );
11641 #[doc(hidden)]
11642 type UnderlyingRustTuple<'a> = (
11643 alloy::sol_types::private::Vec<
11644 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
11645 >,
11646 alloy::sol_types::private::Bytes,
11647 );
11648 #[cfg(test)]
11649 #[allow(dead_code, unreachable_patterns)]
11650 fn _type_assertion(
11651 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11652 ) {
11653 match _t {
11654 alloy_sol_types::private::AssertTypeEq::<
11655 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11656 >(_) => {}
11657 }
11658 }
11659 #[automatically_derived]
11660 #[doc(hidden)]
11661 impl ::core::convert::From<updateOperatorsForQuorumCall>
11662 for UnderlyingRustTuple<'_> {
11663 fn from(value: updateOperatorsForQuorumCall) -> Self {
11664 (value.operatorsPerQuorum, value.quorumNumbers)
11665 }
11666 }
11667 #[automatically_derived]
11668 #[doc(hidden)]
11669 impl ::core::convert::From<UnderlyingRustTuple<'_>>
11670 for updateOperatorsForQuorumCall {
11671 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11672 Self {
11673 operatorsPerQuorum: tuple.0,
11674 quorumNumbers: tuple.1,
11675 }
11676 }
11677 }
11678 }
11679 {
11680 #[doc(hidden)]
11681 type UnderlyingSolTuple<'a> = ();
11682 #[doc(hidden)]
11683 type UnderlyingRustTuple<'a> = ();
11684 #[cfg(test)]
11685 #[allow(dead_code, unreachable_patterns)]
11686 fn _type_assertion(
11687 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11688 ) {
11689 match _t {
11690 alloy_sol_types::private::AssertTypeEq::<
11691 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11692 >(_) => {}
11693 }
11694 }
11695 #[automatically_derived]
11696 #[doc(hidden)]
11697 impl ::core::convert::From<updateOperatorsForQuorumReturn>
11698 for UnderlyingRustTuple<'_> {
11699 fn from(value: updateOperatorsForQuorumReturn) -> Self {
11700 ()
11701 }
11702 }
11703 #[automatically_derived]
11704 #[doc(hidden)]
11705 impl ::core::convert::From<UnderlyingRustTuple<'_>>
11706 for updateOperatorsForQuorumReturn {
11707 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11708 Self {}
11709 }
11710 }
11711 }
11712 #[automatically_derived]
11713 impl alloy_sol_types::SolCall for updateOperatorsForQuorumCall {
11714 type Parameters<'a> = (
11715 alloy::sol_types::sol_data::Array<
11716 alloy::sol_types::sol_data::Array<
11717 alloy::sol_types::sol_data::Address,
11718 >,
11719 >,
11720 alloy::sol_types::sol_data::Bytes,
11721 );
11722 type Token<'a> = <Self::Parameters<
11723 'a,
11724 > as alloy_sol_types::SolType>::Token<'a>;
11725 type Return = updateOperatorsForQuorumReturn;
11726 type ReturnTuple<'a> = ();
11727 type ReturnToken<'a> = <Self::ReturnTuple<
11728 'a,
11729 > as alloy_sol_types::SolType>::Token<'a>;
11730 const SIGNATURE: &'static str = "updateOperatorsForQuorum(address[][],bytes)";
11731 const SELECTOR: [u8; 4] = [81u8, 64u8, 165u8, 72u8];
11732 #[inline]
11733 fn new<'a>(
11734 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11735 ) -> Self {
11736 tuple.into()
11737 }
11738 #[inline]
11739 fn tokenize(&self) -> Self::Token<'_> {
11740 (
11741 <alloy::sol_types::sol_data::Array<
11742 alloy::sol_types::sol_data::Array<
11743 alloy::sol_types::sol_data::Address,
11744 >,
11745 > as alloy_sol_types::SolType>::tokenize(&self.operatorsPerQuorum),
11746 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
11747 &self.quorumNumbers,
11748 ),
11749 )
11750 }
11751 #[inline]
11752 fn abi_decode_returns(
11753 data: &[u8],
11754 validate: bool,
11755 ) -> alloy_sol_types::Result<Self::Return> {
11756 <Self::ReturnTuple<
11757 '_,
11758 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11759 .map(Into::into)
11760 }
11761 }
11762 };
11763 #[derive(Default, Debug, PartialEq, Eq, Hash)]
11764 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11769 #[derive(Clone)]
11770 pub struct updateSocketCall {
11771 #[allow(missing_docs)]
11772 pub socket: alloy::sol_types::private::String,
11773 }
11774 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11776 #[derive(Clone)]
11777 pub struct updateSocketReturn {}
11778 #[allow(
11779 non_camel_case_types,
11780 non_snake_case,
11781 clippy::pub_underscore_fields,
11782 clippy::style
11783 )]
11784 const _: () = {
11785 use alloy::sol_types as alloy_sol_types;
11786 {
11787 #[doc(hidden)]
11788 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
11789 #[doc(hidden)]
11790 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
11791 #[cfg(test)]
11792 #[allow(dead_code, unreachable_patterns)]
11793 fn _type_assertion(
11794 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11795 ) {
11796 match _t {
11797 alloy_sol_types::private::AssertTypeEq::<
11798 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11799 >(_) => {}
11800 }
11801 }
11802 #[automatically_derived]
11803 #[doc(hidden)]
11804 impl ::core::convert::From<updateSocketCall> for UnderlyingRustTuple<'_> {
11805 fn from(value: updateSocketCall) -> Self {
11806 (value.socket,)
11807 }
11808 }
11809 #[automatically_derived]
11810 #[doc(hidden)]
11811 impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateSocketCall {
11812 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11813 Self { socket: tuple.0 }
11814 }
11815 }
11816 }
11817 {
11818 #[doc(hidden)]
11819 type UnderlyingSolTuple<'a> = ();
11820 #[doc(hidden)]
11821 type UnderlyingRustTuple<'a> = ();
11822 #[cfg(test)]
11823 #[allow(dead_code, unreachable_patterns)]
11824 fn _type_assertion(
11825 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11826 ) {
11827 match _t {
11828 alloy_sol_types::private::AssertTypeEq::<
11829 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11830 >(_) => {}
11831 }
11832 }
11833 #[automatically_derived]
11834 #[doc(hidden)]
11835 impl ::core::convert::From<updateSocketReturn> for UnderlyingRustTuple<'_> {
11836 fn from(value: updateSocketReturn) -> Self {
11837 ()
11838 }
11839 }
11840 #[automatically_derived]
11841 #[doc(hidden)]
11842 impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateSocketReturn {
11843 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11844 Self {}
11845 }
11846 }
11847 }
11848 #[automatically_derived]
11849 impl alloy_sol_types::SolCall for updateSocketCall {
11850 type Parameters<'a> = (alloy::sol_types::sol_data::String,);
11851 type Token<'a> = <Self::Parameters<
11852 'a,
11853 > as alloy_sol_types::SolType>::Token<'a>;
11854 type Return = updateSocketReturn;
11855 type ReturnTuple<'a> = ();
11856 type ReturnToken<'a> = <Self::ReturnTuple<
11857 'a,
11858 > as alloy_sol_types::SolType>::Token<'a>;
11859 const SIGNATURE: &'static str = "updateSocket(string)";
11860 const SELECTOR: [u8; 4] = [12u8, 244u8, 183u8, 103u8];
11861 #[inline]
11862 fn new<'a>(
11863 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11864 ) -> Self {
11865 tuple.into()
11866 }
11867 #[inline]
11868 fn tokenize(&self) -> Self::Token<'_> {
11869 (
11870 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
11871 &self.socket,
11872 ),
11873 )
11874 }
11875 #[inline]
11876 fn abi_decode_returns(
11877 data: &[u8],
11878 validate: bool,
11879 ) -> alloy_sol_types::Result<Self::Return> {
11880 <Self::ReturnTuple<
11881 '_,
11882 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
11883 .map(Into::into)
11884 }
11885 }
11886 };
11887 #[derive()]
11889 pub enum ISlashingRegistryCoordinatorCalls {
11890 #[allow(missing_docs)]
11891 OPERATOR_CHURN_APPROVAL_TYPEHASH(OPERATOR_CHURN_APPROVAL_TYPEHASHCall),
11892 #[allow(missing_docs)]
11893 PUBKEY_REGISTRATION_TYPEHASH(PUBKEY_REGISTRATION_TYPEHASHCall),
11894 #[allow(missing_docs)]
11895 allocationManager(allocationManagerCall),
11896 #[allow(missing_docs)]
11897 avs(avsCall),
11898 #[allow(missing_docs)]
11899 blsApkRegistry(blsApkRegistryCall),
11900 #[allow(missing_docs)]
11901 calculateOperatorChurnApprovalDigestHash(
11902 calculateOperatorChurnApprovalDigestHashCall,
11903 ),
11904 #[allow(missing_docs)]
11905 calculatePubkeyRegistrationMessageHash(
11906 calculatePubkeyRegistrationMessageHashCall,
11907 ),
11908 #[allow(missing_docs)]
11909 churnApprover(churnApproverCall),
11910 #[allow(missing_docs)]
11911 createSlashableStakeQuorum(createSlashableStakeQuorumCall),
11912 #[allow(missing_docs)]
11913 createTotalDelegatedStakeQuorum(createTotalDelegatedStakeQuorumCall),
11914 #[allow(missing_docs)]
11915 deregisterOperator(deregisterOperatorCall),
11916 #[allow(missing_docs)]
11917 ejectOperator(ejectOperatorCall),
11918 #[allow(missing_docs)]
11919 ejectionCooldown(ejectionCooldownCall),
11920 #[allow(missing_docs)]
11921 ejector(ejectorCall),
11922 #[allow(missing_docs)]
11923 getCurrentQuorumBitmap(getCurrentQuorumBitmapCall),
11924 #[allow(missing_docs)]
11925 getOperator(getOperatorCall),
11926 #[allow(missing_docs)]
11927 getOperatorFromId(getOperatorFromIdCall),
11928 #[allow(missing_docs)]
11929 getOperatorId(getOperatorIdCall),
11930 #[allow(missing_docs)]
11931 getOperatorSetParams(getOperatorSetParamsCall),
11932 #[allow(missing_docs)]
11933 getOperatorStatus(getOperatorStatusCall),
11934 #[allow(missing_docs)]
11935 getQuorumBitmapAtBlockNumberByIndex(getQuorumBitmapAtBlockNumberByIndexCall),
11936 #[allow(missing_docs)]
11937 getQuorumBitmapHistoryLength(getQuorumBitmapHistoryLengthCall),
11938 #[allow(missing_docs)]
11939 getQuorumBitmapIndicesAtBlockNumber(getQuorumBitmapIndicesAtBlockNumberCall),
11940 #[allow(missing_docs)]
11941 getQuorumBitmapUpdateByIndex(getQuorumBitmapUpdateByIndexCall),
11942 #[allow(missing_docs)]
11943 indexRegistry(indexRegistryCall),
11944 #[allow(missing_docs)]
11945 isChurnApproverSaltUsed(isChurnApproverSaltUsedCall),
11946 #[allow(missing_docs)]
11947 lastEjectionTimestamp(lastEjectionTimestampCall),
11948 #[allow(missing_docs)]
11949 pubkeyRegistrationMessageHash(pubkeyRegistrationMessageHashCall),
11950 #[allow(missing_docs)]
11951 quorumCount(quorumCountCall),
11952 #[allow(missing_docs)]
11953 quorumUpdateBlockNumber(quorumUpdateBlockNumberCall),
11954 #[allow(missing_docs)]
11955 registerOperator(registerOperatorCall),
11956 #[allow(missing_docs)]
11957 setAVS(setAVSCall),
11958 #[allow(missing_docs)]
11959 setChurnApprover(setChurnApproverCall),
11960 #[allow(missing_docs)]
11961 setEjectionCooldown(setEjectionCooldownCall),
11962 #[allow(missing_docs)]
11963 setEjector(setEjectorCall),
11964 #[allow(missing_docs)]
11965 setOperatorSetParams(setOperatorSetParamsCall),
11966 #[allow(missing_docs)]
11967 socketRegistry(socketRegistryCall),
11968 #[allow(missing_docs)]
11969 stakeRegistry(stakeRegistryCall),
11970 #[allow(missing_docs)]
11971 supportsAVS(supportsAVSCall),
11972 #[allow(missing_docs)]
11973 updateOperators(updateOperatorsCall),
11974 #[allow(missing_docs)]
11975 updateOperatorsForQuorum(updateOperatorsForQuorumCall),
11976 #[allow(missing_docs)]
11977 updateSocket(updateSocketCall),
11978 }
11979 #[automatically_derived]
11980 impl ISlashingRegistryCoordinatorCalls {
11981 pub const SELECTORS: &'static [[u8; 4usize]] = &[
11988 [0u8, 207u8, 42u8, 181u8],
11989 [3u8, 253u8, 52u8, 146u8],
11990 [4u8, 236u8, 99u8, 81u8],
11991 [5u8, 67u8, 16u8, 230u8],
11992 [12u8, 244u8, 183u8, 103u8],
11993 [13u8, 63u8, 33u8, 52u8],
11994 [18u8, 94u8, 5u8, 132u8],
11995 [19u8, 84u8, 42u8, 78u8],
11996 [20u8, 120u8, 133u8, 31u8],
11997 [30u8, 184u8, 18u8, 218u8],
11998 [36u8, 154u8, 12u8, 66u8],
11999 [40u8, 246u8, 27u8, 49u8],
12000 [41u8, 107u8, 176u8, 100u8],
12001 [41u8, 209u8, 224u8, 195u8],
12002 [44u8, 221u8, 30u8, 134u8],
12003 [48u8, 60u8, 169u8, 86u8],
12004 [60u8, 42u8, 127u8, 76u8],
12005 [62u8, 239u8, 58u8, 81u8],
12006 [81u8, 64u8, 165u8, 72u8],
12007 [88u8, 101u8, 198u8, 12u8],
12008 [91u8, 11u8, 130u8, 159u8],
12009 [93u8, 244u8, 89u8, 70u8],
12010 [104u8, 48u8, 72u8, 53u8],
12011 [110u8, 59u8, 23u8, 219u8],
12012 [115u8, 68u8, 121u8, 146u8],
12013 [130u8, 129u8, 171u8, 117u8],
12014 [132u8, 202u8, 82u8, 19u8],
12015 [135u8, 30u8, 240u8, 73u8],
12016 [154u8, 161u8, 101u8, 61u8],
12017 [158u8, 153u8, 35u8, 194u8],
12018 [159u8, 234u8, 184u8, 89u8],
12019 [166u8, 84u8, 151u8, 198u8],
12020 [169u8, 111u8, 120u8, 62u8],
12021 [181u8, 38u8, 87u8, 135u8],
12022 [195u8, 145u8, 66u8, 94u8],
12023 [198u8, 63u8, 213u8, 2u8],
12024 [202u8, 13u8, 232u8, 130u8],
12025 [202u8, 138u8, 167u8, 199u8],
12026 [222u8, 17u8, 100u8, 187u8],
12027 [230u8, 87u8, 151u8, 173u8],
12028 [234u8, 50u8, 175u8, 174u8],
12029 [253u8, 57u8, 16u8, 90u8],
12030 ];
12031 }
12032 #[automatically_derived]
12033 impl alloy_sol_types::SolInterface for ISlashingRegistryCoordinatorCalls {
12034 const NAME: &'static str = "ISlashingRegistryCoordinatorCalls";
12035 const MIN_DATA_LENGTH: usize = 0usize;
12036 const COUNT: usize = 42usize;
12037 #[inline]
12038 fn selector(&self) -> [u8; 4] {
12039 match self {
12040 Self::OPERATOR_CHURN_APPROVAL_TYPEHASH(_) => {
12041 <OPERATOR_CHURN_APPROVAL_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
12042 }
12043 Self::PUBKEY_REGISTRATION_TYPEHASH(_) => {
12044 <PUBKEY_REGISTRATION_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
12045 }
12046 Self::allocationManager(_) => {
12047 <allocationManagerCall as alloy_sol_types::SolCall>::SELECTOR
12048 }
12049 Self::avs(_) => <avsCall as alloy_sol_types::SolCall>::SELECTOR,
12050 Self::blsApkRegistry(_) => {
12051 <blsApkRegistryCall as alloy_sol_types::SolCall>::SELECTOR
12052 }
12053 Self::calculateOperatorChurnApprovalDigestHash(_) => {
12054 <calculateOperatorChurnApprovalDigestHashCall as alloy_sol_types::SolCall>::SELECTOR
12055 }
12056 Self::calculatePubkeyRegistrationMessageHash(_) => {
12057 <calculatePubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::SELECTOR
12058 }
12059 Self::churnApprover(_) => {
12060 <churnApproverCall as alloy_sol_types::SolCall>::SELECTOR
12061 }
12062 Self::createSlashableStakeQuorum(_) => {
12063 <createSlashableStakeQuorumCall as alloy_sol_types::SolCall>::SELECTOR
12064 }
12065 Self::createTotalDelegatedStakeQuorum(_) => {
12066 <createTotalDelegatedStakeQuorumCall as alloy_sol_types::SolCall>::SELECTOR
12067 }
12068 Self::deregisterOperator(_) => {
12069 <deregisterOperatorCall as alloy_sol_types::SolCall>::SELECTOR
12070 }
12071 Self::ejectOperator(_) => {
12072 <ejectOperatorCall as alloy_sol_types::SolCall>::SELECTOR
12073 }
12074 Self::ejectionCooldown(_) => {
12075 <ejectionCooldownCall as alloy_sol_types::SolCall>::SELECTOR
12076 }
12077 Self::ejector(_) => <ejectorCall as alloy_sol_types::SolCall>::SELECTOR,
12078 Self::getCurrentQuorumBitmap(_) => {
12079 <getCurrentQuorumBitmapCall as alloy_sol_types::SolCall>::SELECTOR
12080 }
12081 Self::getOperator(_) => {
12082 <getOperatorCall as alloy_sol_types::SolCall>::SELECTOR
12083 }
12084 Self::getOperatorFromId(_) => {
12085 <getOperatorFromIdCall as alloy_sol_types::SolCall>::SELECTOR
12086 }
12087 Self::getOperatorId(_) => {
12088 <getOperatorIdCall as alloy_sol_types::SolCall>::SELECTOR
12089 }
12090 Self::getOperatorSetParams(_) => {
12091 <getOperatorSetParamsCall as alloy_sol_types::SolCall>::SELECTOR
12092 }
12093 Self::getOperatorStatus(_) => {
12094 <getOperatorStatusCall as alloy_sol_types::SolCall>::SELECTOR
12095 }
12096 Self::getQuorumBitmapAtBlockNumberByIndex(_) => {
12097 <getQuorumBitmapAtBlockNumberByIndexCall as alloy_sol_types::SolCall>::SELECTOR
12098 }
12099 Self::getQuorumBitmapHistoryLength(_) => {
12100 <getQuorumBitmapHistoryLengthCall as alloy_sol_types::SolCall>::SELECTOR
12101 }
12102 Self::getQuorumBitmapIndicesAtBlockNumber(_) => {
12103 <getQuorumBitmapIndicesAtBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
12104 }
12105 Self::getQuorumBitmapUpdateByIndex(_) => {
12106 <getQuorumBitmapUpdateByIndexCall as alloy_sol_types::SolCall>::SELECTOR
12107 }
12108 Self::indexRegistry(_) => {
12109 <indexRegistryCall as alloy_sol_types::SolCall>::SELECTOR
12110 }
12111 Self::isChurnApproverSaltUsed(_) => {
12112 <isChurnApproverSaltUsedCall as alloy_sol_types::SolCall>::SELECTOR
12113 }
12114 Self::lastEjectionTimestamp(_) => {
12115 <lastEjectionTimestampCall as alloy_sol_types::SolCall>::SELECTOR
12116 }
12117 Self::pubkeyRegistrationMessageHash(_) => {
12118 <pubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::SELECTOR
12119 }
12120 Self::quorumCount(_) => {
12121 <quorumCountCall as alloy_sol_types::SolCall>::SELECTOR
12122 }
12123 Self::quorumUpdateBlockNumber(_) => {
12124 <quorumUpdateBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
12125 }
12126 Self::registerOperator(_) => {
12127 <registerOperatorCall as alloy_sol_types::SolCall>::SELECTOR
12128 }
12129 Self::setAVS(_) => <setAVSCall as alloy_sol_types::SolCall>::SELECTOR,
12130 Self::setChurnApprover(_) => {
12131 <setChurnApproverCall as alloy_sol_types::SolCall>::SELECTOR
12132 }
12133 Self::setEjectionCooldown(_) => {
12134 <setEjectionCooldownCall as alloy_sol_types::SolCall>::SELECTOR
12135 }
12136 Self::setEjector(_) => {
12137 <setEjectorCall as alloy_sol_types::SolCall>::SELECTOR
12138 }
12139 Self::setOperatorSetParams(_) => {
12140 <setOperatorSetParamsCall as alloy_sol_types::SolCall>::SELECTOR
12141 }
12142 Self::socketRegistry(_) => {
12143 <socketRegistryCall as alloy_sol_types::SolCall>::SELECTOR
12144 }
12145 Self::stakeRegistry(_) => {
12146 <stakeRegistryCall as alloy_sol_types::SolCall>::SELECTOR
12147 }
12148 Self::supportsAVS(_) => {
12149 <supportsAVSCall as alloy_sol_types::SolCall>::SELECTOR
12150 }
12151 Self::updateOperators(_) => {
12152 <updateOperatorsCall as alloy_sol_types::SolCall>::SELECTOR
12153 }
12154 Self::updateOperatorsForQuorum(_) => {
12155 <updateOperatorsForQuorumCall as alloy_sol_types::SolCall>::SELECTOR
12156 }
12157 Self::updateSocket(_) => {
12158 <updateSocketCall as alloy_sol_types::SolCall>::SELECTOR
12159 }
12160 }
12161 }
12162 #[inline]
12163 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
12164 Self::SELECTORS.get(i).copied()
12165 }
12166 #[inline]
12167 fn valid_selector(selector: [u8; 4]) -> bool {
12168 Self::SELECTORS.binary_search(&selector).is_ok()
12169 }
12170 #[inline]
12171 #[allow(non_snake_case)]
12172 fn abi_decode_raw(
12173 selector: [u8; 4],
12174 data: &[u8],
12175 validate: bool,
12176 ) -> alloy_sol_types::Result<Self> {
12177 static DECODE_SHIMS: &[fn(
12178 &[u8],
12179 bool,
12180 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls>] = &[
12181 {
12182 fn updateOperators(
12183 data: &[u8],
12184 validate: bool,
12185 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12186 <updateOperatorsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12187 data,
12188 validate,
12189 )
12190 .map(ISlashingRegistryCoordinatorCalls::updateOperators)
12191 }
12192 updateOperators
12193 },
12194 {
12195 fn getQuorumBitmapHistoryLength(
12196 data: &[u8],
12197 validate: bool,
12198 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12199 <getQuorumBitmapHistoryLengthCall as alloy_sol_types::SolCall>::abi_decode_raw(
12200 data,
12201 validate,
12202 )
12203 .map(
12204 ISlashingRegistryCoordinatorCalls::getQuorumBitmapHistoryLength,
12205 )
12206 }
12207 getQuorumBitmapHistoryLength
12208 },
12209 {
12210 fn getQuorumBitmapAtBlockNumberByIndex(
12211 data: &[u8],
12212 validate: bool,
12213 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12214 <getQuorumBitmapAtBlockNumberByIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(
12215 data,
12216 validate,
12217 )
12218 .map(
12219 ISlashingRegistryCoordinatorCalls::getQuorumBitmapAtBlockNumberByIndex,
12220 )
12221 }
12222 getQuorumBitmapAtBlockNumberByIndex
12223 },
12224 {
12225 fn churnApprover(
12226 data: &[u8],
12227 validate: bool,
12228 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12229 <churnApproverCall as alloy_sol_types::SolCall>::abi_decode_raw(
12230 data,
12231 validate,
12232 )
12233 .map(ISlashingRegistryCoordinatorCalls::churnApprover)
12234 }
12235 churnApprover
12236 },
12237 {
12238 fn updateSocket(
12239 data: &[u8],
12240 validate: bool,
12241 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12242 <updateSocketCall as alloy_sol_types::SolCall>::abi_decode_raw(
12243 data,
12244 validate,
12245 )
12246 .map(ISlashingRegistryCoordinatorCalls::updateSocket)
12247 }
12248 updateSocket
12249 },
12250 {
12251 fn setEjectionCooldown(
12252 data: &[u8],
12253 validate: bool,
12254 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12255 <setEjectionCooldownCall as alloy_sol_types::SolCall>::abi_decode_raw(
12256 data,
12257 validate,
12258 )
12259 .map(ISlashingRegistryCoordinatorCalls::setEjectionCooldown)
12260 }
12261 setEjectionCooldown
12262 },
12263 {
12264 fn lastEjectionTimestamp(
12265 data: &[u8],
12266 validate: bool,
12267 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12268 <lastEjectionTimestampCall as alloy_sol_types::SolCall>::abi_decode_raw(
12269 data,
12270 validate,
12271 )
12272 .map(
12273 ISlashingRegistryCoordinatorCalls::lastEjectionTimestamp,
12274 )
12275 }
12276 lastEjectionTimestamp
12277 },
12278 {
12279 fn getOperatorId(
12280 data: &[u8],
12281 validate: bool,
12282 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12283 <getOperatorIdCall as alloy_sol_types::SolCall>::abi_decode_raw(
12284 data,
12285 validate,
12286 )
12287 .map(ISlashingRegistryCoordinatorCalls::getOperatorId)
12288 }
12289 getOperatorId
12290 },
12291 {
12292 fn isChurnApproverSaltUsed(
12293 data: &[u8],
12294 validate: bool,
12295 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12296 <isChurnApproverSaltUsedCall as alloy_sol_types::SolCall>::abi_decode_raw(
12297 data,
12298 validate,
12299 )
12300 .map(
12301 ISlashingRegistryCoordinatorCalls::isChurnApproverSaltUsed,
12302 )
12303 }
12304 isChurnApproverSaltUsed
12305 },
12306 {
12307 fn getQuorumBitmapUpdateByIndex(
12308 data: &[u8],
12309 validate: bool,
12310 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12311 <getQuorumBitmapUpdateByIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(
12312 data,
12313 validate,
12314 )
12315 .map(
12316 ISlashingRegistryCoordinatorCalls::getQuorumBitmapUpdateByIndex,
12317 )
12318 }
12319 getQuorumBitmapUpdateByIndex
12320 },
12321 {
12322 fn quorumUpdateBlockNumber(
12323 data: &[u8],
12324 validate: bool,
12325 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12326 <quorumUpdateBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
12327 data,
12328 validate,
12329 )
12330 .map(
12331 ISlashingRegistryCoordinatorCalls::quorumUpdateBlockNumber,
12332 )
12333 }
12334 quorumUpdateBlockNumber
12335 },
12336 {
12337 fn ejector(
12338 data: &[u8],
12339 validate: bool,
12340 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12341 <ejectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
12342 data,
12343 validate,
12344 )
12345 .map(ISlashingRegistryCoordinatorCalls::ejector)
12346 }
12347 ejector
12348 },
12349 {
12350 fn getOperatorFromId(
12351 data: &[u8],
12352 validate: bool,
12353 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12354 <getOperatorFromIdCall as alloy_sol_types::SolCall>::abi_decode_raw(
12355 data,
12356 validate,
12357 )
12358 .map(ISlashingRegistryCoordinatorCalls::getOperatorFromId)
12359 }
12360 getOperatorFromId
12361 },
12362 {
12363 fn setChurnApprover(
12364 data: &[u8],
12365 validate: bool,
12366 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12367 <setChurnApproverCall as alloy_sol_types::SolCall>::abi_decode_raw(
12368 data,
12369 validate,
12370 )
12371 .map(ISlashingRegistryCoordinatorCalls::setChurnApprover)
12372 }
12373 setChurnApprover
12374 },
12375 {
12376 fn setEjector(
12377 data: &[u8],
12378 validate: bool,
12379 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12380 <setEjectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
12381 data,
12382 validate,
12383 )
12384 .map(ISlashingRegistryCoordinatorCalls::setEjector)
12385 }
12386 setEjector
12387 },
12388 {
12389 fn deregisterOperator(
12390 data: &[u8],
12391 validate: bool,
12392 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12393 <deregisterOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
12394 data,
12395 validate,
12396 )
12397 .map(ISlashingRegistryCoordinatorCalls::deregisterOperator)
12398 }
12399 deregisterOperator
12400 },
12401 {
12402 fn pubkeyRegistrationMessageHash(
12403 data: &[u8],
12404 validate: bool,
12405 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12406 <pubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
12407 data,
12408 validate,
12409 )
12410 .map(
12411 ISlashingRegistryCoordinatorCalls::pubkeyRegistrationMessageHash,
12412 )
12413 }
12414 pubkeyRegistrationMessageHash
12415 },
12416 {
12417 fn createSlashableStakeQuorum(
12418 data: &[u8],
12419 validate: bool,
12420 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12421 <createSlashableStakeQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw(
12422 data,
12423 validate,
12424 )
12425 .map(
12426 ISlashingRegistryCoordinatorCalls::createSlashableStakeQuorum,
12427 )
12428 }
12429 createSlashableStakeQuorum
12430 },
12431 {
12432 fn updateOperatorsForQuorum(
12433 data: &[u8],
12434 validate: bool,
12435 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12436 <updateOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw(
12437 data,
12438 validate,
12439 )
12440 .map(
12441 ISlashingRegistryCoordinatorCalls::updateOperatorsForQuorum,
12442 )
12443 }
12444 updateOperatorsForQuorum
12445 },
12446 {
12447 fn getOperator(
12448 data: &[u8],
12449 validate: bool,
12450 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12451 <getOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
12452 data,
12453 validate,
12454 )
12455 .map(ISlashingRegistryCoordinatorCalls::getOperator)
12456 }
12457 getOperator
12458 },
12459 {
12460 fn setOperatorSetParams(
12461 data: &[u8],
12462 validate: bool,
12463 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12464 <setOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12465 data,
12466 validate,
12467 )
12468 .map(ISlashingRegistryCoordinatorCalls::setOperatorSetParams)
12469 }
12470 setOperatorSetParams
12471 },
12472 {
12473 fn blsApkRegistry(
12474 data: &[u8],
12475 validate: bool,
12476 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12477 <blsApkRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
12478 data,
12479 validate,
12480 )
12481 .map(ISlashingRegistryCoordinatorCalls::blsApkRegistry)
12482 }
12483 blsApkRegistry
12484 },
12485 {
12486 fn stakeRegistry(
12487 data: &[u8],
12488 validate: bool,
12489 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12490 <stakeRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
12491 data,
12492 validate,
12493 )
12494 .map(ISlashingRegistryCoordinatorCalls::stakeRegistry)
12495 }
12496 stakeRegistry
12497 },
12498 {
12499 fn ejectOperator(
12500 data: &[u8],
12501 validate: bool,
12502 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12503 <ejectOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
12504 data,
12505 validate,
12506 )
12507 .map(ISlashingRegistryCoordinatorCalls::ejectOperator)
12508 }
12509 ejectOperator
12510 },
12511 {
12512 fn calculatePubkeyRegistrationMessageHash(
12513 data: &[u8],
12514 validate: bool,
12515 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12516 <calculatePubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
12517 data,
12518 validate,
12519 )
12520 .map(
12521 ISlashingRegistryCoordinatorCalls::calculatePubkeyRegistrationMessageHash,
12522 )
12523 }
12524 calculatePubkeyRegistrationMessageHash
12525 },
12526 {
12527 fn createTotalDelegatedStakeQuorum(
12528 data: &[u8],
12529 validate: bool,
12530 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12531 <createTotalDelegatedStakeQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw(
12532 data,
12533 validate,
12534 )
12535 .map(
12536 ISlashingRegistryCoordinatorCalls::createTotalDelegatedStakeQuorum,
12537 )
12538 }
12539 createTotalDelegatedStakeQuorum
12540 },
12541 {
12542 fn calculateOperatorChurnApprovalDigestHash(
12543 data: &[u8],
12544 validate: bool,
12545 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12546 <calculateOperatorChurnApprovalDigestHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
12547 data,
12548 validate,
12549 )
12550 .map(
12551 ISlashingRegistryCoordinatorCalls::calculateOperatorChurnApprovalDigestHash,
12552 )
12553 }
12554 calculateOperatorChurnApprovalDigestHash
12555 },
12556 {
12557 fn getCurrentQuorumBitmap(
12558 data: &[u8],
12559 validate: bool,
12560 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12561 <getCurrentQuorumBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw(
12562 data,
12563 validate,
12564 )
12565 .map(
12566 ISlashingRegistryCoordinatorCalls::getCurrentQuorumBitmap,
12567 )
12568 }
12569 getCurrentQuorumBitmap
12570 },
12571 {
12572 fn quorumCount(
12573 data: &[u8],
12574 validate: bool,
12575 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12576 <quorumCountCall as alloy_sol_types::SolCall>::abi_decode_raw(
12577 data,
12578 validate,
12579 )
12580 .map(ISlashingRegistryCoordinatorCalls::quorumCount)
12581 }
12582 quorumCount
12583 },
12584 {
12585 fn indexRegistry(
12586 data: &[u8],
12587 validate: bool,
12588 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12589 <indexRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
12590 data,
12591 validate,
12592 )
12593 .map(ISlashingRegistryCoordinatorCalls::indexRegistry)
12594 }
12595 indexRegistry
12596 },
12597 {
12598 fn PUBKEY_REGISTRATION_TYPEHASH(
12599 data: &[u8],
12600 validate: bool,
12601 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12602 <PUBKEY_REGISTRATION_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(
12603 data,
12604 validate,
12605 )
12606 .map(
12607 ISlashingRegistryCoordinatorCalls::PUBKEY_REGISTRATION_TYPEHASH,
12608 )
12609 }
12610 PUBKEY_REGISTRATION_TYPEHASH
12611 },
12612 {
12613 fn setAVS(
12614 data: &[u8],
12615 validate: bool,
12616 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12617 <setAVSCall as alloy_sol_types::SolCall>::abi_decode_raw(
12618 data,
12619 validate,
12620 )
12621 .map(ISlashingRegistryCoordinatorCalls::setAVS)
12622 }
12623 setAVS
12624 },
12625 {
12626 fn ejectionCooldown(
12627 data: &[u8],
12628 validate: bool,
12629 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12630 <ejectionCooldownCall as alloy_sol_types::SolCall>::abi_decode_raw(
12631 data,
12632 validate,
12633 )
12634 .map(ISlashingRegistryCoordinatorCalls::ejectionCooldown)
12635 }
12636 ejectionCooldown
12637 },
12638 {
12639 fn supportsAVS(
12640 data: &[u8],
12641 validate: bool,
12642 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12643 <supportsAVSCall as alloy_sol_types::SolCall>::abi_decode_raw(
12644 data,
12645 validate,
12646 )
12647 .map(ISlashingRegistryCoordinatorCalls::supportsAVS)
12648 }
12649 supportsAVS
12650 },
12651 {
12652 fn getQuorumBitmapIndicesAtBlockNumber(
12653 data: &[u8],
12654 validate: bool,
12655 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12656 <getQuorumBitmapIndicesAtBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
12657 data,
12658 validate,
12659 )
12660 .map(
12661 ISlashingRegistryCoordinatorCalls::getQuorumBitmapIndicesAtBlockNumber,
12662 )
12663 }
12664 getQuorumBitmapIndicesAtBlockNumber
12665 },
12666 {
12667 fn registerOperator(
12668 data: &[u8],
12669 validate: bool,
12670 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12671 <registerOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
12672 data,
12673 validate,
12674 )
12675 .map(ISlashingRegistryCoordinatorCalls::registerOperator)
12676 }
12677 registerOperator
12678 },
12679 {
12680 fn OPERATOR_CHURN_APPROVAL_TYPEHASH(
12681 data: &[u8],
12682 validate: bool,
12683 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12684 <OPERATOR_CHURN_APPROVAL_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(
12685 data,
12686 validate,
12687 )
12688 .map(
12689 ISlashingRegistryCoordinatorCalls::OPERATOR_CHURN_APPROVAL_TYPEHASH,
12690 )
12691 }
12692 OPERATOR_CHURN_APPROVAL_TYPEHASH
12693 },
12694 {
12695 fn allocationManager(
12696 data: &[u8],
12697 validate: bool,
12698 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12699 <allocationManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
12700 data,
12701 validate,
12702 )
12703 .map(ISlashingRegistryCoordinatorCalls::allocationManager)
12704 }
12705 allocationManager
12706 },
12707 {
12708 fn avs(
12709 data: &[u8],
12710 validate: bool,
12711 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12712 <avsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12713 data,
12714 validate,
12715 )
12716 .map(ISlashingRegistryCoordinatorCalls::avs)
12717 }
12718 avs
12719 },
12720 {
12721 fn getOperatorSetParams(
12722 data: &[u8],
12723 validate: bool,
12724 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12725 <getOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12726 data,
12727 validate,
12728 )
12729 .map(ISlashingRegistryCoordinatorCalls::getOperatorSetParams)
12730 }
12731 getOperatorSetParams
12732 },
12733 {
12734 fn socketRegistry(
12735 data: &[u8],
12736 validate: bool,
12737 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12738 <socketRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
12739 data,
12740 validate,
12741 )
12742 .map(ISlashingRegistryCoordinatorCalls::socketRegistry)
12743 }
12744 socketRegistry
12745 },
12746 {
12747 fn getOperatorStatus(
12748 data: &[u8],
12749 validate: bool,
12750 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorCalls> {
12751 <getOperatorStatusCall as alloy_sol_types::SolCall>::abi_decode_raw(
12752 data,
12753 validate,
12754 )
12755 .map(ISlashingRegistryCoordinatorCalls::getOperatorStatus)
12756 }
12757 getOperatorStatus
12758 },
12759 ];
12760 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
12761 return Err(
12762 alloy_sol_types::Error::unknown_selector(
12763 <Self as alloy_sol_types::SolInterface>::NAME,
12764 selector,
12765 ),
12766 );
12767 };
12768 DECODE_SHIMS[idx](data, validate)
12769 }
12770 #[inline]
12771 fn abi_encoded_size(&self) -> usize {
12772 match self {
12773 Self::OPERATOR_CHURN_APPROVAL_TYPEHASH(inner) => {
12774 <OPERATOR_CHURN_APPROVAL_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(
12775 inner,
12776 )
12777 }
12778 Self::PUBKEY_REGISTRATION_TYPEHASH(inner) => {
12779 <PUBKEY_REGISTRATION_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(
12780 inner,
12781 )
12782 }
12783 Self::allocationManager(inner) => {
12784 <allocationManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
12785 inner,
12786 )
12787 }
12788 Self::avs(inner) => {
12789 <avsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
12790 }
12791 Self::blsApkRegistry(inner) => {
12792 <blsApkRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
12793 inner,
12794 )
12795 }
12796 Self::calculateOperatorChurnApprovalDigestHash(inner) => {
12797 <calculateOperatorChurnApprovalDigestHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
12798 inner,
12799 )
12800 }
12801 Self::calculatePubkeyRegistrationMessageHash(inner) => {
12802 <calculatePubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
12803 inner,
12804 )
12805 }
12806 Self::churnApprover(inner) => {
12807 <churnApproverCall as alloy_sol_types::SolCall>::abi_encoded_size(
12808 inner,
12809 )
12810 }
12811 Self::createSlashableStakeQuorum(inner) => {
12812 <createSlashableStakeQuorumCall as alloy_sol_types::SolCall>::abi_encoded_size(
12813 inner,
12814 )
12815 }
12816 Self::createTotalDelegatedStakeQuorum(inner) => {
12817 <createTotalDelegatedStakeQuorumCall as alloy_sol_types::SolCall>::abi_encoded_size(
12818 inner,
12819 )
12820 }
12821 Self::deregisterOperator(inner) => {
12822 <deregisterOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
12823 inner,
12824 )
12825 }
12826 Self::ejectOperator(inner) => {
12827 <ejectOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
12828 inner,
12829 )
12830 }
12831 Self::ejectionCooldown(inner) => {
12832 <ejectionCooldownCall as alloy_sol_types::SolCall>::abi_encoded_size(
12833 inner,
12834 )
12835 }
12836 Self::ejector(inner) => {
12837 <ejectorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
12838 }
12839 Self::getCurrentQuorumBitmap(inner) => {
12840 <getCurrentQuorumBitmapCall as alloy_sol_types::SolCall>::abi_encoded_size(
12841 inner,
12842 )
12843 }
12844 Self::getOperator(inner) => {
12845 <getOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
12846 inner,
12847 )
12848 }
12849 Self::getOperatorFromId(inner) => {
12850 <getOperatorFromIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
12851 inner,
12852 )
12853 }
12854 Self::getOperatorId(inner) => {
12855 <getOperatorIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
12856 inner,
12857 )
12858 }
12859 Self::getOperatorSetParams(inner) => {
12860 <getOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_encoded_size(
12861 inner,
12862 )
12863 }
12864 Self::getOperatorStatus(inner) => {
12865 <getOperatorStatusCall as alloy_sol_types::SolCall>::abi_encoded_size(
12866 inner,
12867 )
12868 }
12869 Self::getQuorumBitmapAtBlockNumberByIndex(inner) => {
12870 <getQuorumBitmapAtBlockNumberByIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
12871 inner,
12872 )
12873 }
12874 Self::getQuorumBitmapHistoryLength(inner) => {
12875 <getQuorumBitmapHistoryLengthCall as alloy_sol_types::SolCall>::abi_encoded_size(
12876 inner,
12877 )
12878 }
12879 Self::getQuorumBitmapIndicesAtBlockNumber(inner) => {
12880 <getQuorumBitmapIndicesAtBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
12881 inner,
12882 )
12883 }
12884 Self::getQuorumBitmapUpdateByIndex(inner) => {
12885 <getQuorumBitmapUpdateByIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
12886 inner,
12887 )
12888 }
12889 Self::indexRegistry(inner) => {
12890 <indexRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
12891 inner,
12892 )
12893 }
12894 Self::isChurnApproverSaltUsed(inner) => {
12895 <isChurnApproverSaltUsedCall as alloy_sol_types::SolCall>::abi_encoded_size(
12896 inner,
12897 )
12898 }
12899 Self::lastEjectionTimestamp(inner) => {
12900 <lastEjectionTimestampCall as alloy_sol_types::SolCall>::abi_encoded_size(
12901 inner,
12902 )
12903 }
12904 Self::pubkeyRegistrationMessageHash(inner) => {
12905 <pubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
12906 inner,
12907 )
12908 }
12909 Self::quorumCount(inner) => {
12910 <quorumCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
12911 inner,
12912 )
12913 }
12914 Self::quorumUpdateBlockNumber(inner) => {
12915 <quorumUpdateBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
12916 inner,
12917 )
12918 }
12919 Self::registerOperator(inner) => {
12920 <registerOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
12921 inner,
12922 )
12923 }
12924 Self::setAVS(inner) => {
12925 <setAVSCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
12926 }
12927 Self::setChurnApprover(inner) => {
12928 <setChurnApproverCall as alloy_sol_types::SolCall>::abi_encoded_size(
12929 inner,
12930 )
12931 }
12932 Self::setEjectionCooldown(inner) => {
12933 <setEjectionCooldownCall as alloy_sol_types::SolCall>::abi_encoded_size(
12934 inner,
12935 )
12936 }
12937 Self::setEjector(inner) => {
12938 <setEjectorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
12939 }
12940 Self::setOperatorSetParams(inner) => {
12941 <setOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_encoded_size(
12942 inner,
12943 )
12944 }
12945 Self::socketRegistry(inner) => {
12946 <socketRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
12947 inner,
12948 )
12949 }
12950 Self::stakeRegistry(inner) => {
12951 <stakeRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
12952 inner,
12953 )
12954 }
12955 Self::supportsAVS(inner) => {
12956 <supportsAVSCall as alloy_sol_types::SolCall>::abi_encoded_size(
12957 inner,
12958 )
12959 }
12960 Self::updateOperators(inner) => {
12961 <updateOperatorsCall as alloy_sol_types::SolCall>::abi_encoded_size(
12962 inner,
12963 )
12964 }
12965 Self::updateOperatorsForQuorum(inner) => {
12966 <updateOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_encoded_size(
12967 inner,
12968 )
12969 }
12970 Self::updateSocket(inner) => {
12971 <updateSocketCall as alloy_sol_types::SolCall>::abi_encoded_size(
12972 inner,
12973 )
12974 }
12975 }
12976 }
12977 #[inline]
12978 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
12979 match self {
12980 Self::OPERATOR_CHURN_APPROVAL_TYPEHASH(inner) => {
12981 <OPERATOR_CHURN_APPROVAL_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(
12982 inner,
12983 out,
12984 )
12985 }
12986 Self::PUBKEY_REGISTRATION_TYPEHASH(inner) => {
12987 <PUBKEY_REGISTRATION_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(
12988 inner,
12989 out,
12990 )
12991 }
12992 Self::allocationManager(inner) => {
12993 <allocationManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
12994 inner,
12995 out,
12996 )
12997 }
12998 Self::avs(inner) => {
12999 <avsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
13000 }
13001 Self::blsApkRegistry(inner) => {
13002 <blsApkRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
13003 inner,
13004 out,
13005 )
13006 }
13007 Self::calculateOperatorChurnApprovalDigestHash(inner) => {
13008 <calculateOperatorChurnApprovalDigestHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
13009 inner,
13010 out,
13011 )
13012 }
13013 Self::calculatePubkeyRegistrationMessageHash(inner) => {
13014 <calculatePubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
13015 inner,
13016 out,
13017 )
13018 }
13019 Self::churnApprover(inner) => {
13020 <churnApproverCall as alloy_sol_types::SolCall>::abi_encode_raw(
13021 inner,
13022 out,
13023 )
13024 }
13025 Self::createSlashableStakeQuorum(inner) => {
13026 <createSlashableStakeQuorumCall as alloy_sol_types::SolCall>::abi_encode_raw(
13027 inner,
13028 out,
13029 )
13030 }
13031 Self::createTotalDelegatedStakeQuorum(inner) => {
13032 <createTotalDelegatedStakeQuorumCall as alloy_sol_types::SolCall>::abi_encode_raw(
13033 inner,
13034 out,
13035 )
13036 }
13037 Self::deregisterOperator(inner) => {
13038 <deregisterOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
13039 inner,
13040 out,
13041 )
13042 }
13043 Self::ejectOperator(inner) => {
13044 <ejectOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
13045 inner,
13046 out,
13047 )
13048 }
13049 Self::ejectionCooldown(inner) => {
13050 <ejectionCooldownCall as alloy_sol_types::SolCall>::abi_encode_raw(
13051 inner,
13052 out,
13053 )
13054 }
13055 Self::ejector(inner) => {
13056 <ejectorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
13057 }
13058 Self::getCurrentQuorumBitmap(inner) => {
13059 <getCurrentQuorumBitmapCall as alloy_sol_types::SolCall>::abi_encode_raw(
13060 inner,
13061 out,
13062 )
13063 }
13064 Self::getOperator(inner) => {
13065 <getOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
13066 inner,
13067 out,
13068 )
13069 }
13070 Self::getOperatorFromId(inner) => {
13071 <getOperatorFromIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
13072 inner,
13073 out,
13074 )
13075 }
13076 Self::getOperatorId(inner) => {
13077 <getOperatorIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
13078 inner,
13079 out,
13080 )
13081 }
13082 Self::getOperatorSetParams(inner) => {
13083 <getOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13084 inner,
13085 out,
13086 )
13087 }
13088 Self::getOperatorStatus(inner) => {
13089 <getOperatorStatusCall as alloy_sol_types::SolCall>::abi_encode_raw(
13090 inner,
13091 out,
13092 )
13093 }
13094 Self::getQuorumBitmapAtBlockNumberByIndex(inner) => {
13095 <getQuorumBitmapAtBlockNumberByIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
13096 inner,
13097 out,
13098 )
13099 }
13100 Self::getQuorumBitmapHistoryLength(inner) => {
13101 <getQuorumBitmapHistoryLengthCall as alloy_sol_types::SolCall>::abi_encode_raw(
13102 inner,
13103 out,
13104 )
13105 }
13106 Self::getQuorumBitmapIndicesAtBlockNumber(inner) => {
13107 <getQuorumBitmapIndicesAtBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
13108 inner,
13109 out,
13110 )
13111 }
13112 Self::getQuorumBitmapUpdateByIndex(inner) => {
13113 <getQuorumBitmapUpdateByIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
13114 inner,
13115 out,
13116 )
13117 }
13118 Self::indexRegistry(inner) => {
13119 <indexRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
13120 inner,
13121 out,
13122 )
13123 }
13124 Self::isChurnApproverSaltUsed(inner) => {
13125 <isChurnApproverSaltUsedCall as alloy_sol_types::SolCall>::abi_encode_raw(
13126 inner,
13127 out,
13128 )
13129 }
13130 Self::lastEjectionTimestamp(inner) => {
13131 <lastEjectionTimestampCall as alloy_sol_types::SolCall>::abi_encode_raw(
13132 inner,
13133 out,
13134 )
13135 }
13136 Self::pubkeyRegistrationMessageHash(inner) => {
13137 <pubkeyRegistrationMessageHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
13138 inner,
13139 out,
13140 )
13141 }
13142 Self::quorumCount(inner) => {
13143 <quorumCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
13144 inner,
13145 out,
13146 )
13147 }
13148 Self::quorumUpdateBlockNumber(inner) => {
13149 <quorumUpdateBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
13150 inner,
13151 out,
13152 )
13153 }
13154 Self::registerOperator(inner) => {
13155 <registerOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
13156 inner,
13157 out,
13158 )
13159 }
13160 Self::setAVS(inner) => {
13161 <setAVSCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
13162 }
13163 Self::setChurnApprover(inner) => {
13164 <setChurnApproverCall as alloy_sol_types::SolCall>::abi_encode_raw(
13165 inner,
13166 out,
13167 )
13168 }
13169 Self::setEjectionCooldown(inner) => {
13170 <setEjectionCooldownCall as alloy_sol_types::SolCall>::abi_encode_raw(
13171 inner,
13172 out,
13173 )
13174 }
13175 Self::setEjector(inner) => {
13176 <setEjectorCall as alloy_sol_types::SolCall>::abi_encode_raw(
13177 inner,
13178 out,
13179 )
13180 }
13181 Self::setOperatorSetParams(inner) => {
13182 <setOperatorSetParamsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13183 inner,
13184 out,
13185 )
13186 }
13187 Self::socketRegistry(inner) => {
13188 <socketRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
13189 inner,
13190 out,
13191 )
13192 }
13193 Self::stakeRegistry(inner) => {
13194 <stakeRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
13195 inner,
13196 out,
13197 )
13198 }
13199 Self::supportsAVS(inner) => {
13200 <supportsAVSCall as alloy_sol_types::SolCall>::abi_encode_raw(
13201 inner,
13202 out,
13203 )
13204 }
13205 Self::updateOperators(inner) => {
13206 <updateOperatorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13207 inner,
13208 out,
13209 )
13210 }
13211 Self::updateOperatorsForQuorum(inner) => {
13212 <updateOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_encode_raw(
13213 inner,
13214 out,
13215 )
13216 }
13217 Self::updateSocket(inner) => {
13218 <updateSocketCall as alloy_sol_types::SolCall>::abi_encode_raw(
13219 inner,
13220 out,
13221 )
13222 }
13223 }
13224 }
13225 }
13226 #[derive(Debug, PartialEq, Eq, Hash)]
13228 pub enum ISlashingRegistryCoordinatorErrors {
13229 #[allow(missing_docs)]
13230 AlreadyRegisteredForQuorums(AlreadyRegisteredForQuorums),
13231 #[allow(missing_docs)]
13232 BitmapCannotBeZero(BitmapCannotBeZero),
13233 #[allow(missing_docs)]
13234 BitmapEmpty(BitmapEmpty),
13235 #[allow(missing_docs)]
13236 CannotChurnSelf(CannotChurnSelf),
13237 #[allow(missing_docs)]
13238 CannotKickOperatorAboveThreshold(CannotKickOperatorAboveThreshold),
13239 #[allow(missing_docs)]
13240 CannotReregisterYet(CannotReregisterYet),
13241 #[allow(missing_docs)]
13242 ChurnApproverSaltUsed(ChurnApproverSaltUsed),
13243 #[allow(missing_docs)]
13244 InputLengthMismatch(InputLengthMismatch),
13245 #[allow(missing_docs)]
13246 InsufficientStakeForChurn(InsufficientStakeForChurn),
13247 #[allow(missing_docs)]
13248 InvalidAVS(InvalidAVS),
13249 #[allow(missing_docs)]
13250 InvalidRegistrationType(InvalidRegistrationType),
13251 #[allow(missing_docs)]
13252 LookAheadPeriodTooLong(LookAheadPeriodTooLong),
13253 #[allow(missing_docs)]
13254 MaxOperatorCountReached(MaxOperatorCountReached),
13255 #[allow(missing_docs)]
13256 MaxQuorumsReached(MaxQuorumsReached),
13257 #[allow(missing_docs)]
13258 NotRegistered(NotRegistered),
13259 #[allow(missing_docs)]
13260 NotRegisteredForQuorum(NotRegisteredForQuorum),
13261 #[allow(missing_docs)]
13262 NotSorted(NotSorted),
13263 #[allow(missing_docs)]
13264 OnlyAllocationManager(OnlyAllocationManager),
13265 #[allow(missing_docs)]
13266 OnlyEjector(OnlyEjector),
13267 #[allow(missing_docs)]
13268 OperatorNotRegistered(OperatorNotRegistered),
13269 #[allow(missing_docs)]
13270 QuorumDoesNotExist(QuorumDoesNotExist),
13271 #[allow(missing_docs)]
13272 QuorumOperatorCountMismatch(QuorumOperatorCountMismatch),
13273 }
13274 #[automatically_derived]
13275 impl ISlashingRegistryCoordinatorErrors {
13276 pub const SELECTORS: &'static [[u8; 4usize]] = &[
13283 [12u8, 104u8, 22u8, 205u8],
13284 [19u8, 202u8, 70u8, 87u8],
13285 [35u8, 216u8, 113u8, 165u8],
13286 [37u8, 236u8, 108u8, 31u8],
13287 [47u8, 81u8, 6u8, 228u8],
13288 [50u8, 208u8, 206u8, 250u8],
13289 [53u8, 75u8, 184u8, 171u8],
13290 [60u8, 184u8, 156u8, 151u8],
13291 [76u8, 68u8, 153u8, 93u8],
13292 [102u8, 229u8, 101u8, 223u8],
13293 [142u8, 90u8, 238u8, 231u8],
13294 [170u8, 173u8, 19u8, 247u8],
13295 [171u8, 164u8, 115u8, 57u8],
13296 [172u8, 45u8, 22u8, 130u8],
13297 [177u8, 135u8, 232u8, 105u8],
13298 [186u8, 80u8, 249u8, 17u8],
13299 [198u8, 185u8, 231u8, 103u8],
13300 [208u8, 83u8, 170u8, 33u8],
13301 [209u8, 109u8, 80u8, 234u8],
13302 [223u8, 125u8, 253u8, 134u8],
13303 [230u8, 33u8, 159u8, 234u8],
13304 [237u8, 177u8, 86u8, 46u8],
13305 ];
13306 }
13307 #[automatically_derived]
13308 impl alloy_sol_types::SolInterface for ISlashingRegistryCoordinatorErrors {
13309 const NAME: &'static str = "ISlashingRegistryCoordinatorErrors";
13310 const MIN_DATA_LENGTH: usize = 0usize;
13311 const COUNT: usize = 22usize;
13312 #[inline]
13313 fn selector(&self) -> [u8; 4] {
13314 match self {
13315 Self::AlreadyRegisteredForQuorums(_) => {
13316 <AlreadyRegisteredForQuorums as alloy_sol_types::SolError>::SELECTOR
13317 }
13318 Self::BitmapCannotBeZero(_) => {
13319 <BitmapCannotBeZero as alloy_sol_types::SolError>::SELECTOR
13320 }
13321 Self::BitmapEmpty(_) => {
13322 <BitmapEmpty as alloy_sol_types::SolError>::SELECTOR
13323 }
13324 Self::CannotChurnSelf(_) => {
13325 <CannotChurnSelf as alloy_sol_types::SolError>::SELECTOR
13326 }
13327 Self::CannotKickOperatorAboveThreshold(_) => {
13328 <CannotKickOperatorAboveThreshold as alloy_sol_types::SolError>::SELECTOR
13329 }
13330 Self::CannotReregisterYet(_) => {
13331 <CannotReregisterYet as alloy_sol_types::SolError>::SELECTOR
13332 }
13333 Self::ChurnApproverSaltUsed(_) => {
13334 <ChurnApproverSaltUsed as alloy_sol_types::SolError>::SELECTOR
13335 }
13336 Self::InputLengthMismatch(_) => {
13337 <InputLengthMismatch as alloy_sol_types::SolError>::SELECTOR
13338 }
13339 Self::InsufficientStakeForChurn(_) => {
13340 <InsufficientStakeForChurn as alloy_sol_types::SolError>::SELECTOR
13341 }
13342 Self::InvalidAVS(_) => {
13343 <InvalidAVS as alloy_sol_types::SolError>::SELECTOR
13344 }
13345 Self::InvalidRegistrationType(_) => {
13346 <InvalidRegistrationType as alloy_sol_types::SolError>::SELECTOR
13347 }
13348 Self::LookAheadPeriodTooLong(_) => {
13349 <LookAheadPeriodTooLong as alloy_sol_types::SolError>::SELECTOR
13350 }
13351 Self::MaxOperatorCountReached(_) => {
13352 <MaxOperatorCountReached as alloy_sol_types::SolError>::SELECTOR
13353 }
13354 Self::MaxQuorumsReached(_) => {
13355 <MaxQuorumsReached as alloy_sol_types::SolError>::SELECTOR
13356 }
13357 Self::NotRegistered(_) => {
13358 <NotRegistered as alloy_sol_types::SolError>::SELECTOR
13359 }
13360 Self::NotRegisteredForQuorum(_) => {
13361 <NotRegisteredForQuorum as alloy_sol_types::SolError>::SELECTOR
13362 }
13363 Self::NotSorted(_) => <NotSorted as alloy_sol_types::SolError>::SELECTOR,
13364 Self::OnlyAllocationManager(_) => {
13365 <OnlyAllocationManager as alloy_sol_types::SolError>::SELECTOR
13366 }
13367 Self::OnlyEjector(_) => {
13368 <OnlyEjector as alloy_sol_types::SolError>::SELECTOR
13369 }
13370 Self::OperatorNotRegistered(_) => {
13371 <OperatorNotRegistered as alloy_sol_types::SolError>::SELECTOR
13372 }
13373 Self::QuorumDoesNotExist(_) => {
13374 <QuorumDoesNotExist as alloy_sol_types::SolError>::SELECTOR
13375 }
13376 Self::QuorumOperatorCountMismatch(_) => {
13377 <QuorumOperatorCountMismatch as alloy_sol_types::SolError>::SELECTOR
13378 }
13379 }
13380 }
13381 #[inline]
13382 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
13383 Self::SELECTORS.get(i).copied()
13384 }
13385 #[inline]
13386 fn valid_selector(selector: [u8; 4]) -> bool {
13387 Self::SELECTORS.binary_search(&selector).is_ok()
13388 }
13389 #[inline]
13390 #[allow(non_snake_case)]
13391 fn abi_decode_raw(
13392 selector: [u8; 4],
13393 data: &[u8],
13394 validate: bool,
13395 ) -> alloy_sol_types::Result<Self> {
13396 static DECODE_SHIMS: &[fn(
13397 &[u8],
13398 bool,
13399 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors>] = &[
13400 {
13401 fn AlreadyRegisteredForQuorums(
13402 data: &[u8],
13403 validate: bool,
13404 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13405 <AlreadyRegisteredForQuorums as alloy_sol_types::SolError>::abi_decode_raw(
13406 data,
13407 validate,
13408 )
13409 .map(
13410 ISlashingRegistryCoordinatorErrors::AlreadyRegisteredForQuorums,
13411 )
13412 }
13413 AlreadyRegisteredForQuorums
13414 },
13415 {
13416 fn BitmapEmpty(
13417 data: &[u8],
13418 validate: bool,
13419 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13420 <BitmapEmpty as alloy_sol_types::SolError>::abi_decode_raw(
13421 data,
13422 validate,
13423 )
13424 .map(ISlashingRegistryCoordinatorErrors::BitmapEmpty)
13425 }
13426 BitmapEmpty
13427 },
13428 {
13429 fn OnlyAllocationManager(
13430 data: &[u8],
13431 validate: bool,
13432 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13433 <OnlyAllocationManager as alloy_sol_types::SolError>::abi_decode_raw(
13434 data,
13435 validate,
13436 )
13437 .map(
13438 ISlashingRegistryCoordinatorErrors::OnlyAllocationManager,
13439 )
13440 }
13441 OnlyAllocationManager
13442 },
13443 {
13444 fn OperatorNotRegistered(
13445 data: &[u8],
13446 validate: bool,
13447 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13448 <OperatorNotRegistered as alloy_sol_types::SolError>::abi_decode_raw(
13449 data,
13450 validate,
13451 )
13452 .map(
13453 ISlashingRegistryCoordinatorErrors::OperatorNotRegistered,
13454 )
13455 }
13456 OperatorNotRegistered
13457 },
13458 {
13459 fn LookAheadPeriodTooLong(
13460 data: &[u8],
13461 validate: bool,
13462 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13463 <LookAheadPeriodTooLong as alloy_sol_types::SolError>::abi_decode_raw(
13464 data,
13465 validate,
13466 )
13467 .map(
13468 ISlashingRegistryCoordinatorErrors::LookAheadPeriodTooLong,
13469 )
13470 }
13471 LookAheadPeriodTooLong
13472 },
13473 {
13474 fn CannotReregisterYet(
13475 data: &[u8],
13476 validate: bool,
13477 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13478 <CannotReregisterYet as alloy_sol_types::SolError>::abi_decode_raw(
13479 data,
13480 validate,
13481 )
13482 .map(ISlashingRegistryCoordinatorErrors::CannotReregisterYet)
13483 }
13484 CannotReregisterYet
13485 },
13486 {
13487 fn InvalidRegistrationType(
13488 data: &[u8],
13489 validate: bool,
13490 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13491 <InvalidRegistrationType as alloy_sol_types::SolError>::abi_decode_raw(
13492 data,
13493 validate,
13494 )
13495 .map(
13496 ISlashingRegistryCoordinatorErrors::InvalidRegistrationType,
13497 )
13498 }
13499 InvalidRegistrationType
13500 },
13501 {
13502 fn MaxQuorumsReached(
13503 data: &[u8],
13504 validate: bool,
13505 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13506 <MaxQuorumsReached as alloy_sol_types::SolError>::abi_decode_raw(
13507 data,
13508 validate,
13509 )
13510 .map(ISlashingRegistryCoordinatorErrors::MaxQuorumsReached)
13511 }
13512 MaxQuorumsReached
13513 },
13514 {
13515 fn InsufficientStakeForChurn(
13516 data: &[u8],
13517 validate: bool,
13518 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13519 <InsufficientStakeForChurn as alloy_sol_types::SolError>::abi_decode_raw(
13520 data,
13521 validate,
13522 )
13523 .map(
13524 ISlashingRegistryCoordinatorErrors::InsufficientStakeForChurn,
13525 )
13526 }
13527 InsufficientStakeForChurn
13528 },
13529 {
13530 fn InvalidAVS(
13531 data: &[u8],
13532 validate: bool,
13533 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13534 <InvalidAVS as alloy_sol_types::SolError>::abi_decode_raw(
13535 data,
13536 validate,
13537 )
13538 .map(ISlashingRegistryCoordinatorErrors::InvalidAVS)
13539 }
13540 InvalidAVS
13541 },
13542 {
13543 fn QuorumOperatorCountMismatch(
13544 data: &[u8],
13545 validate: bool,
13546 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13547 <QuorumOperatorCountMismatch as alloy_sol_types::SolError>::abi_decode_raw(
13548 data,
13549 validate,
13550 )
13551 .map(
13552 ISlashingRegistryCoordinatorErrors::QuorumOperatorCountMismatch,
13553 )
13554 }
13555 QuorumOperatorCountMismatch
13556 },
13557 {
13558 fn InputLengthMismatch(
13559 data: &[u8],
13560 validate: bool,
13561 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13562 <InputLengthMismatch as alloy_sol_types::SolError>::abi_decode_raw(
13563 data,
13564 validate,
13565 )
13566 .map(ISlashingRegistryCoordinatorErrors::InputLengthMismatch)
13567 }
13568 InputLengthMismatch
13569 },
13570 {
13571 fn NotRegistered(
13572 data: &[u8],
13573 validate: bool,
13574 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13575 <NotRegistered as alloy_sol_types::SolError>::abi_decode_raw(
13576 data,
13577 validate,
13578 )
13579 .map(ISlashingRegistryCoordinatorErrors::NotRegistered)
13580 }
13581 NotRegistered
13582 },
13583 {
13584 fn CannotChurnSelf(
13585 data: &[u8],
13586 validate: bool,
13587 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13588 <CannotChurnSelf as alloy_sol_types::SolError>::abi_decode_raw(
13589 data,
13590 validate,
13591 )
13592 .map(ISlashingRegistryCoordinatorErrors::CannotChurnSelf)
13593 }
13594 CannotChurnSelf
13595 },
13596 {
13597 fn CannotKickOperatorAboveThreshold(
13598 data: &[u8],
13599 validate: bool,
13600 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13601 <CannotKickOperatorAboveThreshold as alloy_sol_types::SolError>::abi_decode_raw(
13602 data,
13603 validate,
13604 )
13605 .map(
13606 ISlashingRegistryCoordinatorErrors::CannotKickOperatorAboveThreshold,
13607 )
13608 }
13609 CannotKickOperatorAboveThreshold
13610 },
13611 {
13612 fn NotSorted(
13613 data: &[u8],
13614 validate: bool,
13615 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13616 <NotSorted as alloy_sol_types::SolError>::abi_decode_raw(
13617 data,
13618 validate,
13619 )
13620 .map(ISlashingRegistryCoordinatorErrors::NotSorted)
13621 }
13622 NotSorted
13623 },
13624 {
13625 fn MaxOperatorCountReached(
13626 data: &[u8],
13627 validate: bool,
13628 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13629 <MaxOperatorCountReached as alloy_sol_types::SolError>::abi_decode_raw(
13630 data,
13631 validate,
13632 )
13633 .map(
13634 ISlashingRegistryCoordinatorErrors::MaxOperatorCountReached,
13635 )
13636 }
13637 MaxOperatorCountReached
13638 },
13639 {
13640 fn NotRegisteredForQuorum(
13641 data: &[u8],
13642 validate: bool,
13643 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13644 <NotRegisteredForQuorum as alloy_sol_types::SolError>::abi_decode_raw(
13645 data,
13646 validate,
13647 )
13648 .map(
13649 ISlashingRegistryCoordinatorErrors::NotRegisteredForQuorum,
13650 )
13651 }
13652 NotRegisteredForQuorum
13653 },
13654 {
13655 fn BitmapCannotBeZero(
13656 data: &[u8],
13657 validate: bool,
13658 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13659 <BitmapCannotBeZero as alloy_sol_types::SolError>::abi_decode_raw(
13660 data,
13661 validate,
13662 )
13663 .map(ISlashingRegistryCoordinatorErrors::BitmapCannotBeZero)
13664 }
13665 BitmapCannotBeZero
13666 },
13667 {
13668 fn ChurnApproverSaltUsed(
13669 data: &[u8],
13670 validate: bool,
13671 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13672 <ChurnApproverSaltUsed as alloy_sol_types::SolError>::abi_decode_raw(
13673 data,
13674 validate,
13675 )
13676 .map(
13677 ISlashingRegistryCoordinatorErrors::ChurnApproverSaltUsed,
13678 )
13679 }
13680 ChurnApproverSaltUsed
13681 },
13682 {
13683 fn QuorumDoesNotExist(
13684 data: &[u8],
13685 validate: bool,
13686 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13687 <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw(
13688 data,
13689 validate,
13690 )
13691 .map(ISlashingRegistryCoordinatorErrors::QuorumDoesNotExist)
13692 }
13693 QuorumDoesNotExist
13694 },
13695 {
13696 fn OnlyEjector(
13697 data: &[u8],
13698 validate: bool,
13699 ) -> alloy_sol_types::Result<ISlashingRegistryCoordinatorErrors> {
13700 <OnlyEjector as alloy_sol_types::SolError>::abi_decode_raw(
13701 data,
13702 validate,
13703 )
13704 .map(ISlashingRegistryCoordinatorErrors::OnlyEjector)
13705 }
13706 OnlyEjector
13707 },
13708 ];
13709 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
13710 return Err(
13711 alloy_sol_types::Error::unknown_selector(
13712 <Self as alloy_sol_types::SolInterface>::NAME,
13713 selector,
13714 ),
13715 );
13716 };
13717 DECODE_SHIMS[idx](data, validate)
13718 }
13719 #[inline]
13720 fn abi_encoded_size(&self) -> usize {
13721 match self {
13722 Self::AlreadyRegisteredForQuorums(inner) => {
13723 <AlreadyRegisteredForQuorums as alloy_sol_types::SolError>::abi_encoded_size(
13724 inner,
13725 )
13726 }
13727 Self::BitmapCannotBeZero(inner) => {
13728 <BitmapCannotBeZero as alloy_sol_types::SolError>::abi_encoded_size(
13729 inner,
13730 )
13731 }
13732 Self::BitmapEmpty(inner) => {
13733 <BitmapEmpty as alloy_sol_types::SolError>::abi_encoded_size(inner)
13734 }
13735 Self::CannotChurnSelf(inner) => {
13736 <CannotChurnSelf as alloy_sol_types::SolError>::abi_encoded_size(
13737 inner,
13738 )
13739 }
13740 Self::CannotKickOperatorAboveThreshold(inner) => {
13741 <CannotKickOperatorAboveThreshold as alloy_sol_types::SolError>::abi_encoded_size(
13742 inner,
13743 )
13744 }
13745 Self::CannotReregisterYet(inner) => {
13746 <CannotReregisterYet as alloy_sol_types::SolError>::abi_encoded_size(
13747 inner,
13748 )
13749 }
13750 Self::ChurnApproverSaltUsed(inner) => {
13751 <ChurnApproverSaltUsed as alloy_sol_types::SolError>::abi_encoded_size(
13752 inner,
13753 )
13754 }
13755 Self::InputLengthMismatch(inner) => {
13756 <InputLengthMismatch as alloy_sol_types::SolError>::abi_encoded_size(
13757 inner,
13758 )
13759 }
13760 Self::InsufficientStakeForChurn(inner) => {
13761 <InsufficientStakeForChurn as alloy_sol_types::SolError>::abi_encoded_size(
13762 inner,
13763 )
13764 }
13765 Self::InvalidAVS(inner) => {
13766 <InvalidAVS as alloy_sol_types::SolError>::abi_encoded_size(inner)
13767 }
13768 Self::InvalidRegistrationType(inner) => {
13769 <InvalidRegistrationType as alloy_sol_types::SolError>::abi_encoded_size(
13770 inner,
13771 )
13772 }
13773 Self::LookAheadPeriodTooLong(inner) => {
13774 <LookAheadPeriodTooLong as alloy_sol_types::SolError>::abi_encoded_size(
13775 inner,
13776 )
13777 }
13778 Self::MaxOperatorCountReached(inner) => {
13779 <MaxOperatorCountReached as alloy_sol_types::SolError>::abi_encoded_size(
13780 inner,
13781 )
13782 }
13783 Self::MaxQuorumsReached(inner) => {
13784 <MaxQuorumsReached as alloy_sol_types::SolError>::abi_encoded_size(
13785 inner,
13786 )
13787 }
13788 Self::NotRegistered(inner) => {
13789 <NotRegistered as alloy_sol_types::SolError>::abi_encoded_size(inner)
13790 }
13791 Self::NotRegisteredForQuorum(inner) => {
13792 <NotRegisteredForQuorum as alloy_sol_types::SolError>::abi_encoded_size(
13793 inner,
13794 )
13795 }
13796 Self::NotSorted(inner) => {
13797 <NotSorted as alloy_sol_types::SolError>::abi_encoded_size(inner)
13798 }
13799 Self::OnlyAllocationManager(inner) => {
13800 <OnlyAllocationManager as alloy_sol_types::SolError>::abi_encoded_size(
13801 inner,
13802 )
13803 }
13804 Self::OnlyEjector(inner) => {
13805 <OnlyEjector as alloy_sol_types::SolError>::abi_encoded_size(inner)
13806 }
13807 Self::OperatorNotRegistered(inner) => {
13808 <OperatorNotRegistered as alloy_sol_types::SolError>::abi_encoded_size(
13809 inner,
13810 )
13811 }
13812 Self::QuorumDoesNotExist(inner) => {
13813 <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_encoded_size(
13814 inner,
13815 )
13816 }
13817 Self::QuorumOperatorCountMismatch(inner) => {
13818 <QuorumOperatorCountMismatch as alloy_sol_types::SolError>::abi_encoded_size(
13819 inner,
13820 )
13821 }
13822 }
13823 }
13824 #[inline]
13825 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
13826 match self {
13827 Self::AlreadyRegisteredForQuorums(inner) => {
13828 <AlreadyRegisteredForQuorums as alloy_sol_types::SolError>::abi_encode_raw(
13829 inner,
13830 out,
13831 )
13832 }
13833 Self::BitmapCannotBeZero(inner) => {
13834 <BitmapCannotBeZero as alloy_sol_types::SolError>::abi_encode_raw(
13835 inner,
13836 out,
13837 )
13838 }
13839 Self::BitmapEmpty(inner) => {
13840 <BitmapEmpty as alloy_sol_types::SolError>::abi_encode_raw(
13841 inner,
13842 out,
13843 )
13844 }
13845 Self::CannotChurnSelf(inner) => {
13846 <CannotChurnSelf as alloy_sol_types::SolError>::abi_encode_raw(
13847 inner,
13848 out,
13849 )
13850 }
13851 Self::CannotKickOperatorAboveThreshold(inner) => {
13852 <CannotKickOperatorAboveThreshold as alloy_sol_types::SolError>::abi_encode_raw(
13853 inner,
13854 out,
13855 )
13856 }
13857 Self::CannotReregisterYet(inner) => {
13858 <CannotReregisterYet as alloy_sol_types::SolError>::abi_encode_raw(
13859 inner,
13860 out,
13861 )
13862 }
13863 Self::ChurnApproverSaltUsed(inner) => {
13864 <ChurnApproverSaltUsed as alloy_sol_types::SolError>::abi_encode_raw(
13865 inner,
13866 out,
13867 )
13868 }
13869 Self::InputLengthMismatch(inner) => {
13870 <InputLengthMismatch as alloy_sol_types::SolError>::abi_encode_raw(
13871 inner,
13872 out,
13873 )
13874 }
13875 Self::InsufficientStakeForChurn(inner) => {
13876 <InsufficientStakeForChurn as alloy_sol_types::SolError>::abi_encode_raw(
13877 inner,
13878 out,
13879 )
13880 }
13881 Self::InvalidAVS(inner) => {
13882 <InvalidAVS as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
13883 }
13884 Self::InvalidRegistrationType(inner) => {
13885 <InvalidRegistrationType as alloy_sol_types::SolError>::abi_encode_raw(
13886 inner,
13887 out,
13888 )
13889 }
13890 Self::LookAheadPeriodTooLong(inner) => {
13891 <LookAheadPeriodTooLong as alloy_sol_types::SolError>::abi_encode_raw(
13892 inner,
13893 out,
13894 )
13895 }
13896 Self::MaxOperatorCountReached(inner) => {
13897 <MaxOperatorCountReached as alloy_sol_types::SolError>::abi_encode_raw(
13898 inner,
13899 out,
13900 )
13901 }
13902 Self::MaxQuorumsReached(inner) => {
13903 <MaxQuorumsReached as alloy_sol_types::SolError>::abi_encode_raw(
13904 inner,
13905 out,
13906 )
13907 }
13908 Self::NotRegistered(inner) => {
13909 <NotRegistered as alloy_sol_types::SolError>::abi_encode_raw(
13910 inner,
13911 out,
13912 )
13913 }
13914 Self::NotRegisteredForQuorum(inner) => {
13915 <NotRegisteredForQuorum as alloy_sol_types::SolError>::abi_encode_raw(
13916 inner,
13917 out,
13918 )
13919 }
13920 Self::NotSorted(inner) => {
13921 <NotSorted as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
13922 }
13923 Self::OnlyAllocationManager(inner) => {
13924 <OnlyAllocationManager as alloy_sol_types::SolError>::abi_encode_raw(
13925 inner,
13926 out,
13927 )
13928 }
13929 Self::OnlyEjector(inner) => {
13930 <OnlyEjector as alloy_sol_types::SolError>::abi_encode_raw(
13931 inner,
13932 out,
13933 )
13934 }
13935 Self::OperatorNotRegistered(inner) => {
13936 <OperatorNotRegistered as alloy_sol_types::SolError>::abi_encode_raw(
13937 inner,
13938 out,
13939 )
13940 }
13941 Self::QuorumDoesNotExist(inner) => {
13942 <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_encode_raw(
13943 inner,
13944 out,
13945 )
13946 }
13947 Self::QuorumOperatorCountMismatch(inner) => {
13948 <QuorumOperatorCountMismatch as alloy_sol_types::SolError>::abi_encode_raw(
13949 inner,
13950 out,
13951 )
13952 }
13953 }
13954 }
13955 }
13956 #[derive(Debug, PartialEq, Eq, Hash)]
13958 pub enum ISlashingRegistryCoordinatorEvents {
13959 #[allow(missing_docs)]
13960 AVSUpdated(AVSUpdated),
13961 #[allow(missing_docs)]
13962 ChurnApproverUpdated(ChurnApproverUpdated),
13963 #[allow(missing_docs)]
13964 EjectionCooldownUpdated(EjectionCooldownUpdated),
13965 #[allow(missing_docs)]
13966 EjectorUpdated(EjectorUpdated),
13967 #[allow(missing_docs)]
13968 OperatorDeregistered(OperatorDeregistered),
13969 #[allow(missing_docs)]
13970 OperatorRegistered(OperatorRegistered),
13971 #[allow(missing_docs)]
13972 OperatorSetParamsUpdated(OperatorSetParamsUpdated),
13973 #[allow(missing_docs)]
13974 OperatorSocketUpdate(OperatorSocketUpdate),
13975 #[allow(missing_docs)]
13976 QuorumBlockNumberUpdated(QuorumBlockNumberUpdated),
13977 #[allow(missing_docs)]
13978 QuorumCreated(QuorumCreated),
13979 }
13980 #[automatically_derived]
13981 impl ISlashingRegistryCoordinatorEvents {
13982 pub const SELECTORS: &'static [[u8; 32usize]] = &[
13989 [
13990 49u8, 84u8, 87u8, 216u8, 168u8, 254u8, 96u8, 240u8, 74u8, 241u8, 124u8,
13991 22u8, 226u8, 245u8, 165u8, 225u8, 219u8, 97u8, 43u8, 49u8, 100u8, 142u8,
13992 88u8, 3u8, 3u8, 96u8, 117u8, 158u8, 248u8, 243u8, 82u8, 140u8,
13993 ],
13994 [
13995 57u8, 111u8, 220u8, 177u8, 128u8, 203u8, 15u8, 234u8, 38u8, 146u8, 129u8,
13996 19u8, 251u8, 15u8, 209u8, 195u8, 84u8, 152u8, 99u8, 249u8, 205u8, 86u8,
13997 62u8, 106u8, 24u8, 79u8, 29u8, 87u8, 129u8, 22u8, 200u8, 228u8,
13998 ],
13999 [
14000 62u8, 230u8, 254u8, 141u8, 84u8, 97u8, 2u8, 68u8, 195u8, 233u8, 211u8,
14001 192u8, 102u8, 174u8, 74u8, 238u8, 153u8, 120u8, 132u8, 170u8, 40u8,
14002 241u8, 6u8, 22u8, 174u8, 130u8, 25u8, 37u8, 64u8, 19u8, 24u8, 172u8,
14003 ],
14004 [
14005 70u8, 7u8, 125u8, 85u8, 51u8, 7u8, 99u8, 241u8, 98u8, 105u8, 253u8,
14006 117u8, 229u8, 118u8, 22u8, 99u8, 244u8, 25u8, 45u8, 39u8, 145u8, 116u8,
14007 124u8, 1u8, 137u8, 177u8, 106u8, 211u8, 29u8, 176u8, 125u8, 180u8,
14008 ],
14009 [
14010 143u8, 48u8, 171u8, 9u8, 244u8, 58u8, 108u8, 21u8, 125u8, 127u8, 206u8,
14011 126u8, 10u8, 19u8, 192u8, 3u8, 4u8, 44u8, 28u8, 149u8, 232u8, 167u8,
14012 46u8, 122u8, 20u8, 106u8, 33u8, 192u8, 202u8, 162u8, 77u8, 201u8,
14013 ],
14014 [
14015 151u8, 112u8, 243u8, 202u8, 223u8, 220u8, 187u8, 111u8, 147u8, 175u8,
14016 147u8, 94u8, 134u8, 4u8, 113u8, 17u8, 89u8, 12u8, 55u8, 104u8, 39u8,
14017 29u8, 35u8, 126u8, 74u8, 43u8, 192u8, 184u8, 116u8, 190u8, 214u8, 147u8,
14018 ],
14019 [
14020 163u8, 72u8, 53u8, 188u8, 43u8, 103u8, 62u8, 195u8, 127u8, 207u8, 21u8,
14021 145u8, 169u8, 18u8, 149u8, 177u8, 99u8, 252u8, 46u8, 24u8, 30u8, 78u8,
14022 164u8, 231u8, 51u8, 190u8, 178u8, 125u8, 225u8, 206u8, 172u8, 76u8,
14023 ],
14024 [
14025 167u8, 122u8, 145u8, 190u8, 167u8, 182u8, 217u8, 90u8, 142u8, 181u8,
14026 165u8, 72u8, 120u8, 161u8, 217u8, 227u8, 200u8, 117u8, 226u8, 108u8,
14027 134u8, 169u8, 183u8, 14u8, 52u8, 32u8, 197u8, 197u8, 219u8, 25u8, 59u8,
14028 98u8,
14029 ],
14030 [
14031 232u8, 230u8, 140u8, 239u8, 28u8, 58u8, 118u8, 30u8, 215u8, 190u8, 126u8,
14032 132u8, 99u8, 163u8, 117u8, 242u8, 127u8, 123u8, 195u8, 53u8, 229u8, 24u8,
14033 36u8, 34u8, 60u8, 172u8, 206u8, 99u8, 110u8, 197u8, 195u8, 254u8,
14034 ],
14035 [
14036 236u8, 41u8, 99u8, 171u8, 33u8, 193u8, 229u8, 14u8, 30u8, 88u8, 42u8,
14037 165u8, 66u8, 175u8, 46u8, 75u8, 247u8, 191u8, 56u8, 230u8, 225u8, 64u8,
14038 60u8, 39u8, 180u8, 46u8, 28u8, 93u8, 110u8, 98u8, 30u8, 170u8,
14039 ],
14040 ];
14041 }
14042 #[automatically_derived]
14043 impl alloy_sol_types::SolEventInterface for ISlashingRegistryCoordinatorEvents {
14044 const NAME: &'static str = "ISlashingRegistryCoordinatorEvents";
14045 const COUNT: usize = 10usize;
14046 fn decode_raw_log(
14047 topics: &[alloy_sol_types::Word],
14048 data: &[u8],
14049 validate: bool,
14050 ) -> alloy_sol_types::Result<Self> {
14051 match topics.first().copied() {
14052 Some(<AVSUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
14053 <AVSUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14054 topics,
14055 data,
14056 validate,
14057 )
14058 .map(Self::AVSUpdated)
14059 }
14060 Some(
14061 <ChurnApproverUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14062 ) => {
14063 <ChurnApproverUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14064 topics,
14065 data,
14066 validate,
14067 )
14068 .map(Self::ChurnApproverUpdated)
14069 }
14070 Some(
14071 <EjectionCooldownUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14072 ) => {
14073 <EjectionCooldownUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14074 topics,
14075 data,
14076 validate,
14077 )
14078 .map(Self::EjectionCooldownUpdated)
14079 }
14080 Some(<EjectorUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
14081 <EjectorUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14082 topics,
14083 data,
14084 validate,
14085 )
14086 .map(Self::EjectorUpdated)
14087 }
14088 Some(
14089 <OperatorDeregistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14090 ) => {
14091 <OperatorDeregistered as alloy_sol_types::SolEvent>::decode_raw_log(
14092 topics,
14093 data,
14094 validate,
14095 )
14096 .map(Self::OperatorDeregistered)
14097 }
14098 Some(
14099 <OperatorRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14100 ) => {
14101 <OperatorRegistered as alloy_sol_types::SolEvent>::decode_raw_log(
14102 topics,
14103 data,
14104 validate,
14105 )
14106 .map(Self::OperatorRegistered)
14107 }
14108 Some(
14109 <OperatorSetParamsUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14110 ) => {
14111 <OperatorSetParamsUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14112 topics,
14113 data,
14114 validate,
14115 )
14116 .map(Self::OperatorSetParamsUpdated)
14117 }
14118 Some(
14119 <OperatorSocketUpdate as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14120 ) => {
14121 <OperatorSocketUpdate as alloy_sol_types::SolEvent>::decode_raw_log(
14122 topics,
14123 data,
14124 validate,
14125 )
14126 .map(Self::OperatorSocketUpdate)
14127 }
14128 Some(
14129 <QuorumBlockNumberUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14130 ) => {
14131 <QuorumBlockNumberUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14132 topics,
14133 data,
14134 validate,
14135 )
14136 .map(Self::QuorumBlockNumberUpdated)
14137 }
14138 Some(<QuorumCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
14139 <QuorumCreated as alloy_sol_types::SolEvent>::decode_raw_log(
14140 topics,
14141 data,
14142 validate,
14143 )
14144 .map(Self::QuorumCreated)
14145 }
14146 _ => {
14147 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
14148 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
14149 log: alloy_sol_types::private::Box::new(
14150 alloy_sol_types::private::LogData::new_unchecked(
14151 topics.to_vec(),
14152 data.to_vec().into(),
14153 ),
14154 ),
14155 })
14156 }
14157 }
14158 }
14159 }
14160 #[automatically_derived]
14161 impl alloy_sol_types::private::IntoLogData for ISlashingRegistryCoordinatorEvents {
14162 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
14163 match self {
14164 Self::AVSUpdated(inner) => {
14165 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14166 }
14167 Self::ChurnApproverUpdated(inner) => {
14168 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14169 }
14170 Self::EjectionCooldownUpdated(inner) => {
14171 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14172 }
14173 Self::EjectorUpdated(inner) => {
14174 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14175 }
14176 Self::OperatorDeregistered(inner) => {
14177 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14178 }
14179 Self::OperatorRegistered(inner) => {
14180 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14181 }
14182 Self::OperatorSetParamsUpdated(inner) => {
14183 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14184 }
14185 Self::OperatorSocketUpdate(inner) => {
14186 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14187 }
14188 Self::QuorumBlockNumberUpdated(inner) => {
14189 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14190 }
14191 Self::QuorumCreated(inner) => {
14192 alloy_sol_types::private::IntoLogData::to_log_data(inner)
14193 }
14194 }
14195 }
14196 fn into_log_data(self) -> alloy_sol_types::private::LogData {
14197 match self {
14198 Self::AVSUpdated(inner) => {
14199 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14200 }
14201 Self::ChurnApproverUpdated(inner) => {
14202 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14203 }
14204 Self::EjectionCooldownUpdated(inner) => {
14205 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14206 }
14207 Self::EjectorUpdated(inner) => {
14208 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14209 }
14210 Self::OperatorDeregistered(inner) => {
14211 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14212 }
14213 Self::OperatorRegistered(inner) => {
14214 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14215 }
14216 Self::OperatorSetParamsUpdated(inner) => {
14217 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14218 }
14219 Self::OperatorSocketUpdate(inner) => {
14220 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14221 }
14222 Self::QuorumBlockNumberUpdated(inner) => {
14223 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14224 }
14225 Self::QuorumCreated(inner) => {
14226 alloy_sol_types::private::IntoLogData::into_log_data(inner)
14227 }
14228 }
14229 }
14230 }
14231 use alloy::contract as alloy_contract;
14232 #[inline]
14236 pub const fn new<
14237 T: alloy_contract::private::Transport + ::core::clone::Clone,
14238 P: alloy_contract::private::Provider<T, N>,
14239 N: alloy_contract::private::Network,
14240 >(
14241 address: alloy_sol_types::private::Address,
14242 provider: P,
14243 ) -> ISlashingRegistryCoordinatorInstance<T, P, N> {
14244 ISlashingRegistryCoordinatorInstance::<T, P, N>::new(address, provider)
14245 }
14246 #[inline]
14252 pub fn deploy<
14253 T: alloy_contract::private::Transport + ::core::clone::Clone,
14254 P: alloy_contract::private::Provider<T, N>,
14255 N: alloy_contract::private::Network,
14256 >(
14257 provider: P,
14258 ) -> impl ::core::future::Future<
14259 Output = alloy_contract::Result<ISlashingRegistryCoordinatorInstance<T, P, N>>,
14260 > {
14261 ISlashingRegistryCoordinatorInstance::<T, P, N>::deploy(provider)
14262 }
14263 #[inline]
14269 pub fn deploy_builder<
14270 T: alloy_contract::private::Transport + ::core::clone::Clone,
14271 P: alloy_contract::private::Provider<T, N>,
14272 N: alloy_contract::private::Network,
14273 >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
14274 ISlashingRegistryCoordinatorInstance::<T, P, N>::deploy_builder(provider)
14275 }
14276 #[derive(Clone)]
14288 pub struct ISlashingRegistryCoordinatorInstance<
14289 T,
14290 P,
14291 N = alloy_contract::private::Ethereum,
14292 > {
14293 address: alloy_sol_types::private::Address,
14294 provider: P,
14295 _network_transport: ::core::marker::PhantomData<(N, T)>,
14296 }
14297 #[automatically_derived]
14298 impl<T, P, N> ::core::fmt::Debug for ISlashingRegistryCoordinatorInstance<T, P, N> {
14299 #[inline]
14300 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14301 f.debug_tuple("ISlashingRegistryCoordinatorInstance")
14302 .field(&self.address)
14303 .finish()
14304 }
14305 }
14306 #[automatically_derived]
14308 impl<
14309 T: alloy_contract::private::Transport + ::core::clone::Clone,
14310 P: alloy_contract::private::Provider<T, N>,
14311 N: alloy_contract::private::Network,
14312 > ISlashingRegistryCoordinatorInstance<T, P, N> {
14313 #[inline]
14317 pub const fn new(
14318 address: alloy_sol_types::private::Address,
14319 provider: P,
14320 ) -> Self {
14321 Self {
14322 address,
14323 provider,
14324 _network_transport: ::core::marker::PhantomData,
14325 }
14326 }
14327 #[inline]
14333 pub async fn deploy(
14334 provider: P,
14335 ) -> alloy_contract::Result<ISlashingRegistryCoordinatorInstance<T, P, N>> {
14336 let call_builder = Self::deploy_builder(provider);
14337 let contract_address = call_builder.deploy().await?;
14338 Ok(Self::new(contract_address, call_builder.provider))
14339 }
14340 #[inline]
14346 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
14347 alloy_contract::RawCallBuilder::new_raw_deploy(
14348 provider,
14349 ::core::clone::Clone::clone(&BYTECODE),
14350 )
14351 }
14352 #[inline]
14354 pub const fn address(&self) -> &alloy_sol_types::private::Address {
14355 &self.address
14356 }
14357 #[inline]
14359 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
14360 self.address = address;
14361 }
14362 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
14364 self.set_address(address);
14365 self
14366 }
14367 #[inline]
14369 pub const fn provider(&self) -> &P {
14370 &self.provider
14371 }
14372 }
14373 impl<T, P: ::core::clone::Clone, N> ISlashingRegistryCoordinatorInstance<T, &P, N> {
14374 #[inline]
14376 pub fn with_cloned_provider(
14377 self,
14378 ) -> ISlashingRegistryCoordinatorInstance<T, P, N> {
14379 ISlashingRegistryCoordinatorInstance {
14380 address: self.address,
14381 provider: ::core::clone::Clone::clone(&self.provider),
14382 _network_transport: ::core::marker::PhantomData,
14383 }
14384 }
14385 }
14386 #[automatically_derived]
14388 impl<
14389 T: alloy_contract::private::Transport + ::core::clone::Clone,
14390 P: alloy_contract::private::Provider<T, N>,
14391 N: alloy_contract::private::Network,
14392 > ISlashingRegistryCoordinatorInstance<T, P, N> {
14393 pub fn call_builder<C: alloy_sol_types::SolCall>(
14398 &self,
14399 call: &C,
14400 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
14401 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
14402 }
14403 pub fn OPERATOR_CHURN_APPROVAL_TYPEHASH(
14405 &self,
14406 ) -> alloy_contract::SolCallBuilder<
14407 T,
14408 &P,
14409 OPERATOR_CHURN_APPROVAL_TYPEHASHCall,
14410 N,
14411 > {
14412 self.call_builder(
14413 &OPERATOR_CHURN_APPROVAL_TYPEHASHCall {
14414 },
14415 )
14416 }
14417 pub fn PUBKEY_REGISTRATION_TYPEHASH(
14419 &self,
14420 ) -> alloy_contract::SolCallBuilder<T, &P, PUBKEY_REGISTRATION_TYPEHASHCall, N> {
14421 self.call_builder(
14422 &PUBKEY_REGISTRATION_TYPEHASHCall {
14423 },
14424 )
14425 }
14426 pub fn allocationManager(
14428 &self,
14429 ) -> alloy_contract::SolCallBuilder<T, &P, allocationManagerCall, N> {
14430 self.call_builder(&allocationManagerCall {})
14431 }
14432 pub fn avs(&self) -> alloy_contract::SolCallBuilder<T, &P, avsCall, N> {
14434 self.call_builder(&avsCall {})
14435 }
14436 pub fn blsApkRegistry(
14438 &self,
14439 ) -> alloy_contract::SolCallBuilder<T, &P, blsApkRegistryCall, N> {
14440 self.call_builder(&blsApkRegistryCall {})
14441 }
14442 pub fn calculateOperatorChurnApprovalDigestHash(
14444 &self,
14445 registeringOperator: alloy::sol_types::private::Address,
14446 registeringOperatorId: alloy::sol_types::private::FixedBytes<32>,
14447 operatorKickParams: alloy::sol_types::private::Vec<
14448 <ISlashingRegistryCoordinatorTypes::OperatorKickParam as alloy::sol_types::SolType>::RustType,
14449 >,
14450 salt: alloy::sol_types::private::FixedBytes<32>,
14451 expiry: alloy::sol_types::private::primitives::aliases::U256,
14452 ) -> alloy_contract::SolCallBuilder<
14453 T,
14454 &P,
14455 calculateOperatorChurnApprovalDigestHashCall,
14456 N,
14457 > {
14458 self.call_builder(
14459 &calculateOperatorChurnApprovalDigestHashCall {
14460 registeringOperator,
14461 registeringOperatorId,
14462 operatorKickParams,
14463 salt,
14464 expiry,
14465 },
14466 )
14467 }
14468 pub fn calculatePubkeyRegistrationMessageHash(
14470 &self,
14471 operator: alloy::sol_types::private::Address,
14472 ) -> alloy_contract::SolCallBuilder<
14473 T,
14474 &P,
14475 calculatePubkeyRegistrationMessageHashCall,
14476 N,
14477 > {
14478 self.call_builder(
14479 &calculatePubkeyRegistrationMessageHashCall {
14480 operator,
14481 },
14482 )
14483 }
14484 pub fn churnApprover(
14486 &self,
14487 ) -> alloy_contract::SolCallBuilder<T, &P, churnApproverCall, N> {
14488 self.call_builder(&churnApproverCall {})
14489 }
14490 pub fn createSlashableStakeQuorum(
14492 &self,
14493 operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
14494 minimumStake: alloy::sol_types::private::primitives::aliases::U96,
14495 strategyParams: alloy::sol_types::private::Vec<
14496 <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
14497 >,
14498 lookAheadPeriod: u32,
14499 ) -> alloy_contract::SolCallBuilder<T, &P, createSlashableStakeQuorumCall, N> {
14500 self.call_builder(
14501 &createSlashableStakeQuorumCall {
14502 operatorSetParams,
14503 minimumStake,
14504 strategyParams,
14505 lookAheadPeriod,
14506 },
14507 )
14508 }
14509 pub fn createTotalDelegatedStakeQuorum(
14511 &self,
14512 operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
14513 minimumStake: alloy::sol_types::private::primitives::aliases::U96,
14514 strategyParams: alloy::sol_types::private::Vec<
14515 <IStakeRegistryTypes::StrategyParams as alloy::sol_types::SolType>::RustType,
14516 >,
14517 ) -> alloy_contract::SolCallBuilder<
14518 T,
14519 &P,
14520 createTotalDelegatedStakeQuorumCall,
14521 N,
14522 > {
14523 self.call_builder(
14524 &createTotalDelegatedStakeQuorumCall {
14525 operatorSetParams,
14526 minimumStake,
14527 strategyParams,
14528 },
14529 )
14530 }
14531 pub fn deregisterOperator(
14533 &self,
14534 operator: alloy::sol_types::private::Address,
14535 avs: alloy::sol_types::private::Address,
14536 operatorSetIds: alloy::sol_types::private::Vec<u32>,
14537 ) -> alloy_contract::SolCallBuilder<T, &P, deregisterOperatorCall, N> {
14538 self.call_builder(
14539 &deregisterOperatorCall {
14540 operator,
14541 avs,
14542 operatorSetIds,
14543 },
14544 )
14545 }
14546 pub fn ejectOperator(
14548 &self,
14549 operator: alloy::sol_types::private::Address,
14550 quorumNumbers: alloy::sol_types::private::Bytes,
14551 ) -> alloy_contract::SolCallBuilder<T, &P, ejectOperatorCall, N> {
14552 self.call_builder(
14553 &ejectOperatorCall {
14554 operator,
14555 quorumNumbers,
14556 },
14557 )
14558 }
14559 pub fn ejectionCooldown(
14561 &self,
14562 ) -> alloy_contract::SolCallBuilder<T, &P, ejectionCooldownCall, N> {
14563 self.call_builder(&ejectionCooldownCall {})
14564 }
14565 pub fn ejector(&self) -> alloy_contract::SolCallBuilder<T, &P, ejectorCall, N> {
14567 self.call_builder(&ejectorCall {})
14568 }
14569 pub fn getCurrentQuorumBitmap(
14571 &self,
14572 operatorId: alloy::sol_types::private::FixedBytes<32>,
14573 ) -> alloy_contract::SolCallBuilder<T, &P, getCurrentQuorumBitmapCall, N> {
14574 self.call_builder(
14575 &getCurrentQuorumBitmapCall {
14576 operatorId,
14577 },
14578 )
14579 }
14580 pub fn getOperator(
14582 &self,
14583 operator: alloy::sol_types::private::Address,
14584 ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorCall, N> {
14585 self.call_builder(&getOperatorCall { operator })
14586 }
14587 pub fn getOperatorFromId(
14589 &self,
14590 operatorId: alloy::sol_types::private::FixedBytes<32>,
14591 ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorFromIdCall, N> {
14592 self.call_builder(
14593 &getOperatorFromIdCall {
14594 operatorId,
14595 },
14596 )
14597 }
14598 pub fn getOperatorId(
14600 &self,
14601 operator: alloy::sol_types::private::Address,
14602 ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorIdCall, N> {
14603 self.call_builder(&getOperatorIdCall { operator })
14604 }
14605 pub fn getOperatorSetParams(
14607 &self,
14608 quorumNumber: u8,
14609 ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorSetParamsCall, N> {
14610 self.call_builder(
14611 &getOperatorSetParamsCall {
14612 quorumNumber,
14613 },
14614 )
14615 }
14616 pub fn getOperatorStatus(
14618 &self,
14619 operator: alloy::sol_types::private::Address,
14620 ) -> alloy_contract::SolCallBuilder<T, &P, getOperatorStatusCall, N> {
14621 self.call_builder(&getOperatorStatusCall { operator })
14622 }
14623 pub fn getQuorumBitmapAtBlockNumberByIndex(
14625 &self,
14626 operatorId: alloy::sol_types::private::FixedBytes<32>,
14627 blockNumber: u32,
14628 index: alloy::sol_types::private::primitives::aliases::U256,
14629 ) -> alloy_contract::SolCallBuilder<
14630 T,
14631 &P,
14632 getQuorumBitmapAtBlockNumberByIndexCall,
14633 N,
14634 > {
14635 self.call_builder(
14636 &getQuorumBitmapAtBlockNumberByIndexCall {
14637 operatorId,
14638 blockNumber,
14639 index,
14640 },
14641 )
14642 }
14643 pub fn getQuorumBitmapHistoryLength(
14645 &self,
14646 operatorId: alloy::sol_types::private::FixedBytes<32>,
14647 ) -> alloy_contract::SolCallBuilder<T, &P, getQuorumBitmapHistoryLengthCall, N> {
14648 self.call_builder(
14649 &getQuorumBitmapHistoryLengthCall {
14650 operatorId,
14651 },
14652 )
14653 }
14654 pub fn getQuorumBitmapIndicesAtBlockNumber(
14656 &self,
14657 blockNumber: u32,
14658 operatorIds: alloy::sol_types::private::Vec<
14659 alloy::sol_types::private::FixedBytes<32>,
14660 >,
14661 ) -> alloy_contract::SolCallBuilder<
14662 T,
14663 &P,
14664 getQuorumBitmapIndicesAtBlockNumberCall,
14665 N,
14666 > {
14667 self.call_builder(
14668 &getQuorumBitmapIndicesAtBlockNumberCall {
14669 blockNumber,
14670 operatorIds,
14671 },
14672 )
14673 }
14674 pub fn getQuorumBitmapUpdateByIndex(
14676 &self,
14677 operatorId: alloy::sol_types::private::FixedBytes<32>,
14678 index: alloy::sol_types::private::primitives::aliases::U256,
14679 ) -> alloy_contract::SolCallBuilder<T, &P, getQuorumBitmapUpdateByIndexCall, N> {
14680 self.call_builder(
14681 &getQuorumBitmapUpdateByIndexCall {
14682 operatorId,
14683 index,
14684 },
14685 )
14686 }
14687 pub fn indexRegistry(
14689 &self,
14690 ) -> alloy_contract::SolCallBuilder<T, &P, indexRegistryCall, N> {
14691 self.call_builder(&indexRegistryCall {})
14692 }
14693 pub fn isChurnApproverSaltUsed(
14695 &self,
14696 salt: alloy::sol_types::private::FixedBytes<32>,
14697 ) -> alloy_contract::SolCallBuilder<T, &P, isChurnApproverSaltUsedCall, N> {
14698 self.call_builder(
14699 &isChurnApproverSaltUsedCall {
14700 salt,
14701 },
14702 )
14703 }
14704 pub fn lastEjectionTimestamp(
14706 &self,
14707 operator: alloy::sol_types::private::Address,
14708 ) -> alloy_contract::SolCallBuilder<T, &P, lastEjectionTimestampCall, N> {
14709 self.call_builder(
14710 &lastEjectionTimestampCall {
14711 operator,
14712 },
14713 )
14714 }
14715 pub fn pubkeyRegistrationMessageHash(
14717 &self,
14718 operator: alloy::sol_types::private::Address,
14719 ) -> alloy_contract::SolCallBuilder<
14720 T,
14721 &P,
14722 pubkeyRegistrationMessageHashCall,
14723 N,
14724 > {
14725 self.call_builder(
14726 &pubkeyRegistrationMessageHashCall {
14727 operator,
14728 },
14729 )
14730 }
14731 pub fn quorumCount(
14733 &self,
14734 ) -> alloy_contract::SolCallBuilder<T, &P, quorumCountCall, N> {
14735 self.call_builder(&quorumCountCall {})
14736 }
14737 pub fn quorumUpdateBlockNumber(
14739 &self,
14740 quorumNumber: u8,
14741 ) -> alloy_contract::SolCallBuilder<T, &P, quorumUpdateBlockNumberCall, N> {
14742 self.call_builder(
14743 &quorumUpdateBlockNumberCall {
14744 quorumNumber,
14745 },
14746 )
14747 }
14748 pub fn registerOperator(
14750 &self,
14751 operator: alloy::sol_types::private::Address,
14752 avs: alloy::sol_types::private::Address,
14753 operatorSetIds: alloy::sol_types::private::Vec<u32>,
14754 data: alloy::sol_types::private::Bytes,
14755 ) -> alloy_contract::SolCallBuilder<T, &P, registerOperatorCall, N> {
14756 self.call_builder(
14757 ®isterOperatorCall {
14758 operator,
14759 avs,
14760 operatorSetIds,
14761 data,
14762 },
14763 )
14764 }
14765 pub fn setAVS(
14767 &self,
14768 _avs: alloy::sol_types::private::Address,
14769 ) -> alloy_contract::SolCallBuilder<T, &P, setAVSCall, N> {
14770 self.call_builder(&setAVSCall { _avs })
14771 }
14772 pub fn setChurnApprover(
14774 &self,
14775 _churnApprover: alloy::sol_types::private::Address,
14776 ) -> alloy_contract::SolCallBuilder<T, &P, setChurnApproverCall, N> {
14777 self.call_builder(
14778 &setChurnApproverCall {
14779 _churnApprover,
14780 },
14781 )
14782 }
14783 pub fn setEjectionCooldown(
14785 &self,
14786 _ejectionCooldown: alloy::sol_types::private::primitives::aliases::U256,
14787 ) -> alloy_contract::SolCallBuilder<T, &P, setEjectionCooldownCall, N> {
14788 self.call_builder(
14789 &setEjectionCooldownCall {
14790 _ejectionCooldown,
14791 },
14792 )
14793 }
14794 pub fn setEjector(
14796 &self,
14797 _ejector: alloy::sol_types::private::Address,
14798 ) -> alloy_contract::SolCallBuilder<T, &P, setEjectorCall, N> {
14799 self.call_builder(&setEjectorCall { _ejector })
14800 }
14801 pub fn setOperatorSetParams(
14803 &self,
14804 quorumNumber: u8,
14805 operatorSetParams: <ISlashingRegistryCoordinatorTypes::OperatorSetParam as alloy::sol_types::SolType>::RustType,
14806 ) -> alloy_contract::SolCallBuilder<T, &P, setOperatorSetParamsCall, N> {
14807 self.call_builder(
14808 &setOperatorSetParamsCall {
14809 quorumNumber,
14810 operatorSetParams,
14811 },
14812 )
14813 }
14814 pub fn socketRegistry(
14816 &self,
14817 ) -> alloy_contract::SolCallBuilder<T, &P, socketRegistryCall, N> {
14818 self.call_builder(&socketRegistryCall {})
14819 }
14820 pub fn stakeRegistry(
14822 &self,
14823 ) -> alloy_contract::SolCallBuilder<T, &P, stakeRegistryCall, N> {
14824 self.call_builder(&stakeRegistryCall {})
14825 }
14826 pub fn supportsAVS(
14828 &self,
14829 avs: alloy::sol_types::private::Address,
14830 ) -> alloy_contract::SolCallBuilder<T, &P, supportsAVSCall, N> {
14831 self.call_builder(&supportsAVSCall { avs })
14832 }
14833 pub fn updateOperators(
14835 &self,
14836 operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
14837 ) -> alloy_contract::SolCallBuilder<T, &P, updateOperatorsCall, N> {
14838 self.call_builder(&updateOperatorsCall { operators })
14839 }
14840 pub fn updateOperatorsForQuorum(
14842 &self,
14843 operatorsPerQuorum: alloy::sol_types::private::Vec<
14844 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
14845 >,
14846 quorumNumbers: alloy::sol_types::private::Bytes,
14847 ) -> alloy_contract::SolCallBuilder<T, &P, updateOperatorsForQuorumCall, N> {
14848 self.call_builder(
14849 &updateOperatorsForQuorumCall {
14850 operatorsPerQuorum,
14851 quorumNumbers,
14852 },
14853 )
14854 }
14855 pub fn updateSocket(
14857 &self,
14858 socket: alloy::sol_types::private::String,
14859 ) -> alloy_contract::SolCallBuilder<T, &P, updateSocketCall, N> {
14860 self.call_builder(&updateSocketCall { socket })
14861 }
14862 }
14863 #[automatically_derived]
14865 impl<
14866 T: alloy_contract::private::Transport + ::core::clone::Clone,
14867 P: alloy_contract::private::Provider<T, N>,
14868 N: alloy_contract::private::Network,
14869 > ISlashingRegistryCoordinatorInstance<T, P, N> {
14870 pub fn event_filter<E: alloy_sol_types::SolEvent>(
14875 &self,
14876 ) -> alloy_contract::Event<T, &P, E, N> {
14877 alloy_contract::Event::new_sol(&self.provider, &self.address)
14878 }
14879 pub fn AVSUpdated_filter(&self) -> alloy_contract::Event<T, &P, AVSUpdated, N> {
14881 self.event_filter::<AVSUpdated>()
14882 }
14883 pub fn ChurnApproverUpdated_filter(
14885 &self,
14886 ) -> alloy_contract::Event<T, &P, ChurnApproverUpdated, N> {
14887 self.event_filter::<ChurnApproverUpdated>()
14888 }
14889 pub fn EjectionCooldownUpdated_filter(
14891 &self,
14892 ) -> alloy_contract::Event<T, &P, EjectionCooldownUpdated, N> {
14893 self.event_filter::<EjectionCooldownUpdated>()
14894 }
14895 pub fn EjectorUpdated_filter(
14897 &self,
14898 ) -> alloy_contract::Event<T, &P, EjectorUpdated, N> {
14899 self.event_filter::<EjectorUpdated>()
14900 }
14901 pub fn OperatorDeregistered_filter(
14903 &self,
14904 ) -> alloy_contract::Event<T, &P, OperatorDeregistered, N> {
14905 self.event_filter::<OperatorDeregistered>()
14906 }
14907 pub fn OperatorRegistered_filter(
14909 &self,
14910 ) -> alloy_contract::Event<T, &P, OperatorRegistered, N> {
14911 self.event_filter::<OperatorRegistered>()
14912 }
14913 pub fn OperatorSetParamsUpdated_filter(
14915 &self,
14916 ) -> alloy_contract::Event<T, &P, OperatorSetParamsUpdated, N> {
14917 self.event_filter::<OperatorSetParamsUpdated>()
14918 }
14919 pub fn OperatorSocketUpdate_filter(
14921 &self,
14922 ) -> alloy_contract::Event<T, &P, OperatorSocketUpdate, N> {
14923 self.event_filter::<OperatorSocketUpdate>()
14924 }
14925 pub fn QuorumBlockNumberUpdated_filter(
14927 &self,
14928 ) -> alloy_contract::Event<T, &P, QuorumBlockNumberUpdated, N> {
14929 self.event_filter::<QuorumBlockNumberUpdated>()
14930 }
14931 pub fn QuorumCreated_filter(
14933 &self,
14934 ) -> alloy_contract::Event<T, &P, QuorumCreated, N> {
14935 self.event_filter::<QuorumCreated>()
14936 }
14937 }
14938}