hotshot_contract_adapter/bindings/
stake_table.rs

1///Module containing a contract's types and functions.
2/**
3
4```solidity
5library BN254 {
6    type BaseField is uint256;
7    struct G1Point { BaseField x; BaseField y; }
8    struct G2Point { BaseField x0; BaseField x1; BaseField y0; BaseField y1; }
9}
10```*/
11#[allow(
12    non_camel_case_types,
13    non_snake_case,
14    clippy::pub_underscore_fields,
15    clippy::style,
16    clippy::empty_structs_with_brackets
17)]
18pub mod BN254 {
19    use super::*;
20    use alloy::sol_types as alloy_sol_types;
21    #[derive(serde::Serialize, serde::Deserialize)]
22    #[derive(Default, Debug, PartialEq, Eq, Hash)]
23    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
24    #[derive(Clone)]
25    pub struct BaseField(alloy::sol_types::private::primitives::aliases::U256);
26    const _: () = {
27        use alloy::sol_types as alloy_sol_types;
28        #[automatically_derived]
29        impl alloy_sol_types::private::SolTypeValue<BaseField>
30        for alloy::sol_types::private::primitives::aliases::U256 {
31            #[inline]
32            fn stv_to_tokens(
33                &self,
34            ) -> <alloy::sol_types::sol_data::Uint<
35                256,
36            > as alloy_sol_types::SolType>::Token<'_> {
37                alloy_sol_types::private::SolTypeValue::<
38                    alloy::sol_types::sol_data::Uint<256>,
39                >::stv_to_tokens(self)
40            }
41            #[inline]
42            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
43                <alloy::sol_types::sol_data::Uint<
44                    256,
45                > as alloy_sol_types::SolType>::tokenize(self)
46                    .0
47            }
48            #[inline]
49            fn stv_abi_encode_packed_to(
50                &self,
51                out: &mut alloy_sol_types::private::Vec<u8>,
52            ) {
53                <alloy::sol_types::sol_data::Uint<
54                    256,
55                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
56            }
57            #[inline]
58            fn stv_abi_packed_encoded_size(&self) -> usize {
59                <alloy::sol_types::sol_data::Uint<
60                    256,
61                > as alloy_sol_types::SolType>::abi_encoded_size(self)
62            }
63        }
64        impl BaseField {
65            /// The Solidity type name.
66            pub const NAME: &'static str = stringify!(@ name);
67            /// Convert from the underlying value type.
68            #[inline]
69            pub const fn from_underlying(
70                value: alloy::sol_types::private::primitives::aliases::U256,
71            ) -> Self {
72                Self(value)
73            }
74            /// Return the underlying value.
75            #[inline]
76            pub const fn into_underlying(
77                self,
78            ) -> alloy::sol_types::private::primitives::aliases::U256 {
79                self.0
80            }
81            /// Return the single encoding of this value, delegating to the
82            /// underlying type.
83            #[inline]
84            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
85                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
86            }
87            /// Return the packed encoding of this value, delegating to the
88            /// underlying type.
89            #[inline]
90            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
91                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
92            }
93        }
94        #[automatically_derived]
95        impl From<alloy::sol_types::private::primitives::aliases::U256> for BaseField {
96            fn from(
97                value: alloy::sol_types::private::primitives::aliases::U256,
98            ) -> Self {
99                Self::from_underlying(value)
100            }
101        }
102        #[automatically_derived]
103        impl From<BaseField> for alloy::sol_types::private::primitives::aliases::U256 {
104            fn from(value: BaseField) -> Self {
105                value.into_underlying()
106            }
107        }
108        #[automatically_derived]
109        impl alloy_sol_types::SolType for BaseField {
110            type RustType = alloy::sol_types::private::primitives::aliases::U256;
111            type Token<'a> = <alloy::sol_types::sol_data::Uint<
112                256,
113            > as alloy_sol_types::SolType>::Token<'a>;
114            const SOL_NAME: &'static str = Self::NAME;
115            const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
116                256,
117            > as alloy_sol_types::SolType>::ENCODED_SIZE;
118            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
119                256,
120            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
121            #[inline]
122            fn valid_token(token: &Self::Token<'_>) -> bool {
123                Self::type_check(token).is_ok()
124            }
125            #[inline]
126            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
127                <alloy::sol_types::sol_data::Uint<
128                    256,
129                > as alloy_sol_types::SolType>::type_check(token)
130            }
131            #[inline]
132            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
133                <alloy::sol_types::sol_data::Uint<
134                    256,
135                > as alloy_sol_types::SolType>::detokenize(token)
136            }
137        }
138        #[automatically_derived]
139        impl alloy_sol_types::EventTopic for BaseField {
140            #[inline]
141            fn topic_preimage_length(rust: &Self::RustType) -> usize {
142                <alloy::sol_types::sol_data::Uint<
143                    256,
144                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
145            }
146            #[inline]
147            fn encode_topic_preimage(
148                rust: &Self::RustType,
149                out: &mut alloy_sol_types::private::Vec<u8>,
150            ) {
151                <alloy::sol_types::sol_data::Uint<
152                    256,
153                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
154            }
155            #[inline]
156            fn encode_topic(
157                rust: &Self::RustType,
158            ) -> alloy_sol_types::abi::token::WordToken {
159                <alloy::sol_types::sol_data::Uint<
160                    256,
161                > as alloy_sol_types::EventTopic>::encode_topic(rust)
162            }
163        }
164    };
165    #[derive(serde::Serialize, serde::Deserialize)]
166    #[derive(Default, Debug, PartialEq, Eq, Hash)]
167    /**```solidity
168struct G1Point { BaseField x; BaseField y; }
169```*/
170    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
171    #[derive(Clone)]
172    pub struct G1Point {
173        #[allow(missing_docs)]
174        pub x: <BaseField as alloy::sol_types::SolType>::RustType,
175        #[allow(missing_docs)]
176        pub y: <BaseField as alloy::sol_types::SolType>::RustType,
177    }
178    #[allow(
179        non_camel_case_types,
180        non_snake_case,
181        clippy::pub_underscore_fields,
182        clippy::style
183    )]
184    const _: () = {
185        use alloy::sol_types as alloy_sol_types;
186        #[doc(hidden)]
187        #[allow(dead_code)]
188        type UnderlyingSolTuple<'a> = (BaseField, BaseField);
189        #[doc(hidden)]
190        type UnderlyingRustTuple<'a> = (
191            <BaseField as alloy::sol_types::SolType>::RustType,
192            <BaseField as alloy::sol_types::SolType>::RustType,
193        );
194        #[cfg(test)]
195        #[allow(dead_code, unreachable_patterns)]
196        fn _type_assertion(
197            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
198        ) {
199            match _t {
200                alloy_sol_types::private::AssertTypeEq::<
201                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
202                >(_) => {}
203            }
204        }
205        #[automatically_derived]
206        #[doc(hidden)]
207        impl ::core::convert::From<G1Point> for UnderlyingRustTuple<'_> {
208            fn from(value: G1Point) -> Self {
209                (value.x, value.y)
210            }
211        }
212        #[automatically_derived]
213        #[doc(hidden)]
214        impl ::core::convert::From<UnderlyingRustTuple<'_>> for G1Point {
215            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
216                Self { x: tuple.0, y: tuple.1 }
217            }
218        }
219        #[automatically_derived]
220        impl alloy_sol_types::SolValue for G1Point {
221            type SolType = Self;
222        }
223        #[automatically_derived]
224        impl alloy_sol_types::private::SolTypeValue<Self> for G1Point {
225            #[inline]
226            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
227                (
228                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.x),
229                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.y),
230                )
231            }
232            #[inline]
233            fn stv_abi_encoded_size(&self) -> usize {
234                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
235                    return size;
236                }
237                let tuple = <UnderlyingRustTuple<
238                    '_,
239                > as ::core::convert::From<Self>>::from(self.clone());
240                <UnderlyingSolTuple<
241                    '_,
242                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
243            }
244            #[inline]
245            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
246                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
247            }
248            #[inline]
249            fn stv_abi_encode_packed_to(
250                &self,
251                out: &mut alloy_sol_types::private::Vec<u8>,
252            ) {
253                let tuple = <UnderlyingRustTuple<
254                    '_,
255                > as ::core::convert::From<Self>>::from(self.clone());
256                <UnderlyingSolTuple<
257                    '_,
258                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
259            }
260            #[inline]
261            fn stv_abi_packed_encoded_size(&self) -> usize {
262                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
263                    return size;
264                }
265                let tuple = <UnderlyingRustTuple<
266                    '_,
267                > as ::core::convert::From<Self>>::from(self.clone());
268                <UnderlyingSolTuple<
269                    '_,
270                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
271            }
272        }
273        #[automatically_derived]
274        impl alloy_sol_types::SolType for G1Point {
275            type RustType = Self;
276            type Token<'a> = <UnderlyingSolTuple<
277                'a,
278            > as alloy_sol_types::SolType>::Token<'a>;
279            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
280            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
281                '_,
282            > as alloy_sol_types::SolType>::ENCODED_SIZE;
283            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
284                '_,
285            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
286            #[inline]
287            fn valid_token(token: &Self::Token<'_>) -> bool {
288                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
289            }
290            #[inline]
291            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
292                let tuple = <UnderlyingSolTuple<
293                    '_,
294                > as alloy_sol_types::SolType>::detokenize(token);
295                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
296            }
297        }
298        #[automatically_derived]
299        impl alloy_sol_types::SolStruct for G1Point {
300            const NAME: &'static str = "G1Point";
301            #[inline]
302            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
303                alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 x,uint256 y)")
304            }
305            #[inline]
306            fn eip712_components() -> alloy_sol_types::private::Vec<
307                alloy_sol_types::private::Cow<'static, str>,
308            > {
309                alloy_sol_types::private::Vec::new()
310            }
311            #[inline]
312            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
313                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
314            }
315            #[inline]
316            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
317                [
318                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.x).0,
319                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.y).0,
320                ]
321                    .concat()
322            }
323        }
324        #[automatically_derived]
325        impl alloy_sol_types::EventTopic for G1Point {
326            #[inline]
327            fn topic_preimage_length(rust: &Self::RustType) -> usize {
328                0usize
329                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(
330                        &rust.x,
331                    )
332                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(
333                        &rust.y,
334                    )
335            }
336            #[inline]
337            fn encode_topic_preimage(
338                rust: &Self::RustType,
339                out: &mut alloy_sol_types::private::Vec<u8>,
340            ) {
341                out.reserve(
342                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
343                );
344                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(
345                    &rust.x,
346                    out,
347                );
348                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(
349                    &rust.y,
350                    out,
351                );
352            }
353            #[inline]
354            fn encode_topic(
355                rust: &Self::RustType,
356            ) -> alloy_sol_types::abi::token::WordToken {
357                let mut out = alloy_sol_types::private::Vec::new();
358                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
359                    rust,
360                    &mut out,
361                );
362                alloy_sol_types::abi::token::WordToken(
363                    alloy_sol_types::private::keccak256(out),
364                )
365            }
366        }
367    };
368    #[derive(serde::Serialize, serde::Deserialize)]
369    #[derive(Default, Debug, PartialEq, Eq, Hash)]
370    /**```solidity
371struct G2Point { BaseField x0; BaseField x1; BaseField y0; BaseField y1; }
372```*/
373    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
374    #[derive(Clone)]
375    pub struct G2Point {
376        #[allow(missing_docs)]
377        pub x0: <BaseField as alloy::sol_types::SolType>::RustType,
378        #[allow(missing_docs)]
379        pub x1: <BaseField as alloy::sol_types::SolType>::RustType,
380        #[allow(missing_docs)]
381        pub y0: <BaseField as alloy::sol_types::SolType>::RustType,
382        #[allow(missing_docs)]
383        pub y1: <BaseField as alloy::sol_types::SolType>::RustType,
384    }
385    #[allow(
386        non_camel_case_types,
387        non_snake_case,
388        clippy::pub_underscore_fields,
389        clippy::style
390    )]
391    const _: () = {
392        use alloy::sol_types as alloy_sol_types;
393        #[doc(hidden)]
394        #[allow(dead_code)]
395        type UnderlyingSolTuple<'a> = (BaseField, BaseField, BaseField, BaseField);
396        #[doc(hidden)]
397        type UnderlyingRustTuple<'a> = (
398            <BaseField as alloy::sol_types::SolType>::RustType,
399            <BaseField as alloy::sol_types::SolType>::RustType,
400            <BaseField as alloy::sol_types::SolType>::RustType,
401            <BaseField as alloy::sol_types::SolType>::RustType,
402        );
403        #[cfg(test)]
404        #[allow(dead_code, unreachable_patterns)]
405        fn _type_assertion(
406            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
407        ) {
408            match _t {
409                alloy_sol_types::private::AssertTypeEq::<
410                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
411                >(_) => {}
412            }
413        }
414        #[automatically_derived]
415        #[doc(hidden)]
416        impl ::core::convert::From<G2Point> for UnderlyingRustTuple<'_> {
417            fn from(value: G2Point) -> Self {
418                (value.x0, value.x1, value.y0, value.y1)
419            }
420        }
421        #[automatically_derived]
422        #[doc(hidden)]
423        impl ::core::convert::From<UnderlyingRustTuple<'_>> for G2Point {
424            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
425                Self {
426                    x0: tuple.0,
427                    x1: tuple.1,
428                    y0: tuple.2,
429                    y1: tuple.3,
430                }
431            }
432        }
433        #[automatically_derived]
434        impl alloy_sol_types::SolValue for G2Point {
435            type SolType = Self;
436        }
437        #[automatically_derived]
438        impl alloy_sol_types::private::SolTypeValue<Self> for G2Point {
439            #[inline]
440            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
441                (
442                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.x0),
443                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.x1),
444                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.y0),
445                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.y1),
446                )
447            }
448            #[inline]
449            fn stv_abi_encoded_size(&self) -> usize {
450                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
451                    return size;
452                }
453                let tuple = <UnderlyingRustTuple<
454                    '_,
455                > as ::core::convert::From<Self>>::from(self.clone());
456                <UnderlyingSolTuple<
457                    '_,
458                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
459            }
460            #[inline]
461            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
462                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
463            }
464            #[inline]
465            fn stv_abi_encode_packed_to(
466                &self,
467                out: &mut alloy_sol_types::private::Vec<u8>,
468            ) {
469                let tuple = <UnderlyingRustTuple<
470                    '_,
471                > as ::core::convert::From<Self>>::from(self.clone());
472                <UnderlyingSolTuple<
473                    '_,
474                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
475            }
476            #[inline]
477            fn stv_abi_packed_encoded_size(&self) -> usize {
478                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
479                    return size;
480                }
481                let tuple = <UnderlyingRustTuple<
482                    '_,
483                > as ::core::convert::From<Self>>::from(self.clone());
484                <UnderlyingSolTuple<
485                    '_,
486                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
487            }
488        }
489        #[automatically_derived]
490        impl alloy_sol_types::SolType for G2Point {
491            type RustType = Self;
492            type Token<'a> = <UnderlyingSolTuple<
493                'a,
494            > as alloy_sol_types::SolType>::Token<'a>;
495            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
496            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
497                '_,
498            > as alloy_sol_types::SolType>::ENCODED_SIZE;
499            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
500                '_,
501            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
502            #[inline]
503            fn valid_token(token: &Self::Token<'_>) -> bool {
504                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
505            }
506            #[inline]
507            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
508                let tuple = <UnderlyingSolTuple<
509                    '_,
510                > as alloy_sol_types::SolType>::detokenize(token);
511                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
512            }
513        }
514        #[automatically_derived]
515        impl alloy_sol_types::SolStruct for G2Point {
516            const NAME: &'static str = "G2Point";
517            #[inline]
518            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
519                alloy_sol_types::private::Cow::Borrowed(
520                    "G2Point(uint256 x0,uint256 x1,uint256 y0,uint256 y1)",
521                )
522            }
523            #[inline]
524            fn eip712_components() -> alloy_sol_types::private::Vec<
525                alloy_sol_types::private::Cow<'static, str>,
526            > {
527                alloy_sol_types::private::Vec::new()
528            }
529            #[inline]
530            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
531                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
532            }
533            #[inline]
534            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
535                [
536                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.x0)
537                        .0,
538                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.x1)
539                        .0,
540                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.y0)
541                        .0,
542                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.y1).0,
543                ]
544                    .concat()
545            }
546        }
547        #[automatically_derived]
548        impl alloy_sol_types::EventTopic for G2Point {
549            #[inline]
550            fn topic_preimage_length(rust: &Self::RustType) -> usize {
551                0usize
552                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(
553                        &rust.x0,
554                    )
555                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(
556                        &rust.x1,
557                    )
558                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(
559                        &rust.y0,
560                    )
561                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(
562                        &rust.y1,
563                    )
564            }
565            #[inline]
566            fn encode_topic_preimage(
567                rust: &Self::RustType,
568                out: &mut alloy_sol_types::private::Vec<u8>,
569            ) {
570                out.reserve(
571                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
572                );
573                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(
574                    &rust.x0,
575                    out,
576                );
577                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(
578                    &rust.x1,
579                    out,
580                );
581                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(
582                    &rust.y0,
583                    out,
584                );
585                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(
586                    &rust.y1,
587                    out,
588                );
589            }
590            #[inline]
591            fn encode_topic(
592                rust: &Self::RustType,
593            ) -> alloy_sol_types::abi::token::WordToken {
594                let mut out = alloy_sol_types::private::Vec::new();
595                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
596                    rust,
597                    &mut out,
598                );
599                alloy_sol_types::abi::token::WordToken(
600                    alloy_sol_types::private::keccak256(out),
601                )
602            }
603        }
604    };
605    use alloy::contract as alloy_contract;
606    /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance.
607
608See the [wrapper's documentation](`BN254Instance`) for more details.*/
609    #[inline]
610    pub const fn new<
611        P: alloy_contract::private::Provider<N>,
612        N: alloy_contract::private::Network,
613    >(address: alloy_sol_types::private::Address, __provider: P) -> BN254Instance<P, N> {
614        BN254Instance::<P, N>::new(address, __provider)
615    }
616    /**A [`BN254`](self) instance.
617
618Contains type-safe methods for interacting with an on-chain instance of the
619[`BN254`](self) contract located at a given `address`, using a given
620provider `P`.
621
622If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
623documentation on how to provide it), the `deploy` and `deploy_builder` methods can
624be used to deploy a new instance of the contract.
625
626See the [module-level documentation](self) for all the available methods.*/
627    #[derive(Clone)]
628    pub struct BN254Instance<P, N = alloy_contract::private::Ethereum> {
629        address: alloy_sol_types::private::Address,
630        provider: P,
631        _network: ::core::marker::PhantomData<N>,
632    }
633    #[automatically_derived]
634    impl<P, N> ::core::fmt::Debug for BN254Instance<P, N> {
635        #[inline]
636        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
637            f.debug_tuple("BN254Instance").field(&self.address).finish()
638        }
639    }
640    /// Instantiation and getters/setters.
641    impl<
642        P: alloy_contract::private::Provider<N>,
643        N: alloy_contract::private::Network,
644    > BN254Instance<P, N> {
645        /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance.
646
647See the [wrapper's documentation](`BN254Instance`) for more details.*/
648        #[inline]
649        pub const fn new(
650            address: alloy_sol_types::private::Address,
651            __provider: P,
652        ) -> Self {
653            Self {
654                address,
655                provider: __provider,
656                _network: ::core::marker::PhantomData,
657            }
658        }
659        /// Returns a reference to the address.
660        #[inline]
661        pub const fn address(&self) -> &alloy_sol_types::private::Address {
662            &self.address
663        }
664        /// Sets the address.
665        #[inline]
666        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
667            self.address = address;
668        }
669        /// Sets the address and returns `self`.
670        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
671            self.set_address(address);
672            self
673        }
674        /// Returns a reference to the provider.
675        #[inline]
676        pub const fn provider(&self) -> &P {
677            &self.provider
678        }
679    }
680    impl<P: ::core::clone::Clone, N> BN254Instance<&P, N> {
681        /// Clones the provider and returns a new instance with the cloned provider.
682        #[inline]
683        pub fn with_cloned_provider(self) -> BN254Instance<P, N> {
684            BN254Instance {
685                address: self.address,
686                provider: ::core::clone::Clone::clone(&self.provider),
687                _network: ::core::marker::PhantomData,
688            }
689        }
690    }
691    /// Function calls.
692    impl<
693        P: alloy_contract::private::Provider<N>,
694        N: alloy_contract::private::Network,
695    > BN254Instance<P, N> {
696        /// Creates a new call builder using this contract instance's provider and address.
697        ///
698        /// Note that the call can be any function call, not just those defined in this
699        /// contract. Prefer using the other methods for building type-safe contract calls.
700        pub fn call_builder<C: alloy_sol_types::SolCall>(
701            &self,
702            call: &C,
703        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
704            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
705        }
706    }
707    /// Event filters.
708    impl<
709        P: alloy_contract::private::Provider<N>,
710        N: alloy_contract::private::Network,
711    > BN254Instance<P, N> {
712        /// Creates a new event filter using this contract instance's provider and address.
713        ///
714        /// Note that the type can be any event, not just those defined in this contract.
715        /// Prefer using the other methods for building type-safe event filters.
716        pub fn event_filter<E: alloy_sol_types::SolEvent>(
717            &self,
718        ) -> alloy_contract::Event<&P, E, N> {
719            alloy_contract::Event::new_sol(&self.provider, &self.address)
720        }
721    }
722}
723///Module containing a contract's types and functions.
724/**
725
726```solidity
727library EdOnBN254 {
728    struct EdOnBN254Point { uint256 x; uint256 y; }
729}
730```*/
731#[allow(
732    non_camel_case_types,
733    non_snake_case,
734    clippy::pub_underscore_fields,
735    clippy::style,
736    clippy::empty_structs_with_brackets
737)]
738pub mod EdOnBN254 {
739    use super::*;
740    use alloy::sol_types as alloy_sol_types;
741    #[derive(serde::Serialize, serde::Deserialize)]
742    #[derive(Default, Debug, PartialEq, Eq, Hash)]
743    /**```solidity
744struct EdOnBN254Point { uint256 x; uint256 y; }
745```*/
746    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
747    #[derive(Clone)]
748    pub struct EdOnBN254Point {
749        #[allow(missing_docs)]
750        pub x: alloy::sol_types::private::primitives::aliases::U256,
751        #[allow(missing_docs)]
752        pub y: alloy::sol_types::private::primitives::aliases::U256,
753    }
754    #[allow(
755        non_camel_case_types,
756        non_snake_case,
757        clippy::pub_underscore_fields,
758        clippy::style
759    )]
760    const _: () = {
761        use alloy::sol_types as alloy_sol_types;
762        #[doc(hidden)]
763        #[allow(dead_code)]
764        type UnderlyingSolTuple<'a> = (
765            alloy::sol_types::sol_data::Uint<256>,
766            alloy::sol_types::sol_data::Uint<256>,
767        );
768        #[doc(hidden)]
769        type UnderlyingRustTuple<'a> = (
770            alloy::sol_types::private::primitives::aliases::U256,
771            alloy::sol_types::private::primitives::aliases::U256,
772        );
773        #[cfg(test)]
774        #[allow(dead_code, unreachable_patterns)]
775        fn _type_assertion(
776            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
777        ) {
778            match _t {
779                alloy_sol_types::private::AssertTypeEq::<
780                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
781                >(_) => {}
782            }
783        }
784        #[automatically_derived]
785        #[doc(hidden)]
786        impl ::core::convert::From<EdOnBN254Point> for UnderlyingRustTuple<'_> {
787            fn from(value: EdOnBN254Point) -> Self {
788                (value.x, value.y)
789            }
790        }
791        #[automatically_derived]
792        #[doc(hidden)]
793        impl ::core::convert::From<UnderlyingRustTuple<'_>> for EdOnBN254Point {
794            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
795                Self { x: tuple.0, y: tuple.1 }
796            }
797        }
798        #[automatically_derived]
799        impl alloy_sol_types::SolValue for EdOnBN254Point {
800            type SolType = Self;
801        }
802        #[automatically_derived]
803        impl alloy_sol_types::private::SolTypeValue<Self> for EdOnBN254Point {
804            #[inline]
805            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
806                (
807                    <alloy::sol_types::sol_data::Uint<
808                        256,
809                    > as alloy_sol_types::SolType>::tokenize(&self.x),
810                    <alloy::sol_types::sol_data::Uint<
811                        256,
812                    > as alloy_sol_types::SolType>::tokenize(&self.y),
813                )
814            }
815            #[inline]
816            fn stv_abi_encoded_size(&self) -> usize {
817                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
818                    return size;
819                }
820                let tuple = <UnderlyingRustTuple<
821                    '_,
822                > as ::core::convert::From<Self>>::from(self.clone());
823                <UnderlyingSolTuple<
824                    '_,
825                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
826            }
827            #[inline]
828            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
829                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
830            }
831            #[inline]
832            fn stv_abi_encode_packed_to(
833                &self,
834                out: &mut alloy_sol_types::private::Vec<u8>,
835            ) {
836                let tuple = <UnderlyingRustTuple<
837                    '_,
838                > as ::core::convert::From<Self>>::from(self.clone());
839                <UnderlyingSolTuple<
840                    '_,
841                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
842            }
843            #[inline]
844            fn stv_abi_packed_encoded_size(&self) -> usize {
845                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
846                    return size;
847                }
848                let tuple = <UnderlyingRustTuple<
849                    '_,
850                > as ::core::convert::From<Self>>::from(self.clone());
851                <UnderlyingSolTuple<
852                    '_,
853                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
854            }
855        }
856        #[automatically_derived]
857        impl alloy_sol_types::SolType for EdOnBN254Point {
858            type RustType = Self;
859            type Token<'a> = <UnderlyingSolTuple<
860                'a,
861            > as alloy_sol_types::SolType>::Token<'a>;
862            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
863            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
864                '_,
865            > as alloy_sol_types::SolType>::ENCODED_SIZE;
866            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
867                '_,
868            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
869            #[inline]
870            fn valid_token(token: &Self::Token<'_>) -> bool {
871                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
872            }
873            #[inline]
874            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
875                let tuple = <UnderlyingSolTuple<
876                    '_,
877                > as alloy_sol_types::SolType>::detokenize(token);
878                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
879            }
880        }
881        #[automatically_derived]
882        impl alloy_sol_types::SolStruct for EdOnBN254Point {
883            const NAME: &'static str = "EdOnBN254Point";
884            #[inline]
885            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
886                alloy_sol_types::private::Cow::Borrowed(
887                    "EdOnBN254Point(uint256 x,uint256 y)",
888                )
889            }
890            #[inline]
891            fn eip712_components() -> alloy_sol_types::private::Vec<
892                alloy_sol_types::private::Cow<'static, str>,
893            > {
894                alloy_sol_types::private::Vec::new()
895            }
896            #[inline]
897            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
898                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
899            }
900            #[inline]
901            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
902                [
903                    <alloy::sol_types::sol_data::Uint<
904                        256,
905                    > as alloy_sol_types::SolType>::eip712_data_word(&self.x)
906                        .0,
907                    <alloy::sol_types::sol_data::Uint<
908                        256,
909                    > as alloy_sol_types::SolType>::eip712_data_word(&self.y)
910                        .0,
911                ]
912                    .concat()
913            }
914        }
915        #[automatically_derived]
916        impl alloy_sol_types::EventTopic for EdOnBN254Point {
917            #[inline]
918            fn topic_preimage_length(rust: &Self::RustType) -> usize {
919                0usize
920                    + <alloy::sol_types::sol_data::Uint<
921                        256,
922                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.x)
923                    + <alloy::sol_types::sol_data::Uint<
924                        256,
925                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.y)
926            }
927            #[inline]
928            fn encode_topic_preimage(
929                rust: &Self::RustType,
930                out: &mut alloy_sol_types::private::Vec<u8>,
931            ) {
932                out.reserve(
933                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
934                );
935                <alloy::sol_types::sol_data::Uint<
936                    256,
937                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.x, out);
938                <alloy::sol_types::sol_data::Uint<
939                    256,
940                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.y, out);
941            }
942            #[inline]
943            fn encode_topic(
944                rust: &Self::RustType,
945            ) -> alloy_sol_types::abi::token::WordToken {
946                let mut out = alloy_sol_types::private::Vec::new();
947                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
948                    rust,
949                    &mut out,
950                );
951                alloy_sol_types::abi::token::WordToken(
952                    alloy_sol_types::private::keccak256(out),
953                )
954            }
955        }
956    };
957    use alloy::contract as alloy_contract;
958    /**Creates a new wrapper around an on-chain [`EdOnBN254`](self) contract instance.
959
960See the [wrapper's documentation](`EdOnBN254Instance`) for more details.*/
961    #[inline]
962    pub const fn new<
963        P: alloy_contract::private::Provider<N>,
964        N: alloy_contract::private::Network,
965    >(
966        address: alloy_sol_types::private::Address,
967        __provider: P,
968    ) -> EdOnBN254Instance<P, N> {
969        EdOnBN254Instance::<P, N>::new(address, __provider)
970    }
971    /**A [`EdOnBN254`](self) instance.
972
973Contains type-safe methods for interacting with an on-chain instance of the
974[`EdOnBN254`](self) contract located at a given `address`, using a given
975provider `P`.
976
977If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
978documentation on how to provide it), the `deploy` and `deploy_builder` methods can
979be used to deploy a new instance of the contract.
980
981See the [module-level documentation](self) for all the available methods.*/
982    #[derive(Clone)]
983    pub struct EdOnBN254Instance<P, N = alloy_contract::private::Ethereum> {
984        address: alloy_sol_types::private::Address,
985        provider: P,
986        _network: ::core::marker::PhantomData<N>,
987    }
988    #[automatically_derived]
989    impl<P, N> ::core::fmt::Debug for EdOnBN254Instance<P, N> {
990        #[inline]
991        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
992            f.debug_tuple("EdOnBN254Instance").field(&self.address).finish()
993        }
994    }
995    /// Instantiation and getters/setters.
996    impl<
997        P: alloy_contract::private::Provider<N>,
998        N: alloy_contract::private::Network,
999    > EdOnBN254Instance<P, N> {
1000        /**Creates a new wrapper around an on-chain [`EdOnBN254`](self) contract instance.
1001
1002See the [wrapper's documentation](`EdOnBN254Instance`) for more details.*/
1003        #[inline]
1004        pub const fn new(
1005            address: alloy_sol_types::private::Address,
1006            __provider: P,
1007        ) -> Self {
1008            Self {
1009                address,
1010                provider: __provider,
1011                _network: ::core::marker::PhantomData,
1012            }
1013        }
1014        /// Returns a reference to the address.
1015        #[inline]
1016        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1017            &self.address
1018        }
1019        /// Sets the address.
1020        #[inline]
1021        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1022            self.address = address;
1023        }
1024        /// Sets the address and returns `self`.
1025        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1026            self.set_address(address);
1027            self
1028        }
1029        /// Returns a reference to the provider.
1030        #[inline]
1031        pub const fn provider(&self) -> &P {
1032            &self.provider
1033        }
1034    }
1035    impl<P: ::core::clone::Clone, N> EdOnBN254Instance<&P, N> {
1036        /// Clones the provider and returns a new instance with the cloned provider.
1037        #[inline]
1038        pub fn with_cloned_provider(self) -> EdOnBN254Instance<P, N> {
1039            EdOnBN254Instance {
1040                address: self.address,
1041                provider: ::core::clone::Clone::clone(&self.provider),
1042                _network: ::core::marker::PhantomData,
1043            }
1044        }
1045    }
1046    /// Function calls.
1047    impl<
1048        P: alloy_contract::private::Provider<N>,
1049        N: alloy_contract::private::Network,
1050    > EdOnBN254Instance<P, N> {
1051        /// Creates a new call builder using this contract instance's provider and address.
1052        ///
1053        /// Note that the call can be any function call, not just those defined in this
1054        /// contract. Prefer using the other methods for building type-safe contract calls.
1055        pub fn call_builder<C: alloy_sol_types::SolCall>(
1056            &self,
1057            call: &C,
1058        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1059            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1060        }
1061    }
1062    /// Event filters.
1063    impl<
1064        P: alloy_contract::private::Provider<N>,
1065        N: alloy_contract::private::Network,
1066    > EdOnBN254Instance<P, N> {
1067        /// Creates a new event filter using this contract instance's provider and address.
1068        ///
1069        /// Note that the type can be any event, not just those defined in this contract.
1070        /// Prefer using the other methods for building type-safe event filters.
1071        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1072            &self,
1073        ) -> alloy_contract::Event<&P, E, N> {
1074            alloy_contract::Event::new_sol(&self.provider, &self.address)
1075        }
1076    }
1077}
1078/**
1079
1080Generated by the following Solidity interface...
1081```solidity
1082library BN254 {
1083    type BaseField is uint256;
1084    struct G1Point {
1085        BaseField x;
1086        BaseField y;
1087    }
1088    struct G2Point {
1089        BaseField x0;
1090        BaseField x1;
1091        BaseField y0;
1092        BaseField y1;
1093    }
1094}
1095
1096library EdOnBN254 {
1097    struct EdOnBN254Point {
1098        uint256 x;
1099        uint256 y;
1100    }
1101}
1102
1103interface StakeTable {
1104    type ValidatorStatus is uint8;
1105
1106    error AddressEmptyCode(address target);
1107    error BLSSigIsInfinity();
1108    error BLSSigVerificationFailed();
1109    error BLSVKIsInfinity();
1110    error BN254PairingProdFailed();
1111    error BlsKeyAlreadyUsed();
1112    error ERC1967InvalidImplementation(address implementation);
1113    error ERC1967NonPayable();
1114    error ExitEscrowPeriodInvalid();
1115    error FailedInnerCall();
1116    error InsufficientAllowance(uint256, uint256);
1117    error InsufficientBalance(uint256);
1118    error InvalidCommission();
1119    error InvalidG1();
1120    error InvalidInitialization();
1121    error InvalidSchnorrVK();
1122    error NotInitializing();
1123    error NothingToWithdraw();
1124    error OwnableInvalidOwner(address owner);
1125    error OwnableUnauthorizedAccount(address account);
1126    error OwnershipCannotBeRenounced();
1127    error PowPrecompileFailed();
1128    error PrematureWithdrawal();
1129    error UUPSUnauthorizedCallContext();
1130    error UUPSUnsupportedProxiableUUID(bytes32 slot);
1131    error UndelegationAlreadyExists();
1132    error ValidatorAlreadyExited();
1133    error ValidatorAlreadyRegistered();
1134    error ValidatorInactive();
1135    error ValidatorNotExited();
1136    error ZeroAddress();
1137    error ZeroAmount();
1138
1139    event ConsensusKeysUpdated(address indexed account, BN254.G2Point blsVK, EdOnBN254.EdOnBN254Point schnorrVK);
1140    event Delegated(address indexed delegator, address indexed validator, uint256 amount);
1141    event Initialized(uint64 version);
1142    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
1143    event Undelegated(address indexed delegator, address indexed validator, uint256 amount);
1144    event Upgraded(address indexed implementation);
1145    event ValidatorExit(address indexed validator);
1146    event ValidatorRegistered(address indexed account, BN254.G2Point blsVk, EdOnBN254.EdOnBN254Point schnorrVk, uint16 commission);
1147    event Withdrawal(address indexed account, uint256 amount);
1148
1149    constructor();
1150
1151    function UPGRADE_INTERFACE_VERSION() external view returns (string memory);
1152    function _hashBlsKey(BN254.G2Point memory blsVK) external pure returns (bytes32);
1153    function blsKeys(bytes32 blsKeyHash) external view returns (bool used);
1154    function claimValidatorExit(address validator) external;
1155    function claimWithdrawal(address validator) external;
1156    function delegate(address validator, uint256 amount) external;
1157    function delegations(address validator, address delegator) external view returns (uint256 amount);
1158    function deregisterValidator() external;
1159    function exitEscrowPeriod() external view returns (uint256);
1160    function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion);
1161    function initialize(address _tokenAddress, address _lightClientAddress, uint256 _exitEscrowPeriod, address _timelock) external;
1162    function initializedAtBlock() external view returns (uint256);
1163    function lightClient() external view returns (address);
1164    function owner() external view returns (address);
1165    function proxiableUUID() external view returns (bytes32);
1166    function registerValidator(BN254.G2Point memory blsVK, EdOnBN254.EdOnBN254Point memory schnorrVK, BN254.G1Point memory blsSig, uint16 commission) external;
1167    function renounceOwnership() external;
1168    function token() external view returns (address);
1169    function transferOwnership(address newOwner) external;
1170    function undelegate(address validator, uint256 amount) external;
1171    function undelegations(address validator, address delegator) external view returns (uint256 amount, uint256 unlocksAt);
1172    function updateConsensusKeys(BN254.G2Point memory newBlsVK, EdOnBN254.EdOnBN254Point memory newSchnorrVK, BN254.G1Point memory newBlsSig) external;
1173    function upgradeToAndCall(address newImplementation, bytes memory data) external payable;
1174    function validatorExits(address validator) external view returns (uint256 unlocksAt);
1175    function validators(address account) external view returns (uint256 delegatedAmount, ValidatorStatus status);
1176}
1177```
1178
1179...which was generated by the following JSON ABI:
1180```json
1181[
1182  {
1183    "type": "constructor",
1184    "inputs": [],
1185    "stateMutability": "nonpayable"
1186  },
1187  {
1188    "type": "function",
1189    "name": "UPGRADE_INTERFACE_VERSION",
1190    "inputs": [],
1191    "outputs": [
1192      {
1193        "name": "",
1194        "type": "string",
1195        "internalType": "string"
1196      }
1197    ],
1198    "stateMutability": "view"
1199  },
1200  {
1201    "type": "function",
1202    "name": "_hashBlsKey",
1203    "inputs": [
1204      {
1205        "name": "blsVK",
1206        "type": "tuple",
1207        "internalType": "struct BN254.G2Point",
1208        "components": [
1209          {
1210            "name": "x0",
1211            "type": "uint256",
1212            "internalType": "BN254.BaseField"
1213          },
1214          {
1215            "name": "x1",
1216            "type": "uint256",
1217            "internalType": "BN254.BaseField"
1218          },
1219          {
1220            "name": "y0",
1221            "type": "uint256",
1222            "internalType": "BN254.BaseField"
1223          },
1224          {
1225            "name": "y1",
1226            "type": "uint256",
1227            "internalType": "BN254.BaseField"
1228          }
1229        ]
1230      }
1231    ],
1232    "outputs": [
1233      {
1234        "name": "",
1235        "type": "bytes32",
1236        "internalType": "bytes32"
1237      }
1238    ],
1239    "stateMutability": "pure"
1240  },
1241  {
1242    "type": "function",
1243    "name": "blsKeys",
1244    "inputs": [
1245      {
1246        "name": "blsKeyHash",
1247        "type": "bytes32",
1248        "internalType": "bytes32"
1249      }
1250    ],
1251    "outputs": [
1252      {
1253        "name": "used",
1254        "type": "bool",
1255        "internalType": "bool"
1256      }
1257    ],
1258    "stateMutability": "view"
1259  },
1260  {
1261    "type": "function",
1262    "name": "claimValidatorExit",
1263    "inputs": [
1264      {
1265        "name": "validator",
1266        "type": "address",
1267        "internalType": "address"
1268      }
1269    ],
1270    "outputs": [],
1271    "stateMutability": "nonpayable"
1272  },
1273  {
1274    "type": "function",
1275    "name": "claimWithdrawal",
1276    "inputs": [
1277      {
1278        "name": "validator",
1279        "type": "address",
1280        "internalType": "address"
1281      }
1282    ],
1283    "outputs": [],
1284    "stateMutability": "nonpayable"
1285  },
1286  {
1287    "type": "function",
1288    "name": "delegate",
1289    "inputs": [
1290      {
1291        "name": "validator",
1292        "type": "address",
1293        "internalType": "address"
1294      },
1295      {
1296        "name": "amount",
1297        "type": "uint256",
1298        "internalType": "uint256"
1299      }
1300    ],
1301    "outputs": [],
1302    "stateMutability": "nonpayable"
1303  },
1304  {
1305    "type": "function",
1306    "name": "delegations",
1307    "inputs": [
1308      {
1309        "name": "validator",
1310        "type": "address",
1311        "internalType": "address"
1312      },
1313      {
1314        "name": "delegator",
1315        "type": "address",
1316        "internalType": "address"
1317      }
1318    ],
1319    "outputs": [
1320      {
1321        "name": "amount",
1322        "type": "uint256",
1323        "internalType": "uint256"
1324      }
1325    ],
1326    "stateMutability": "view"
1327  },
1328  {
1329    "type": "function",
1330    "name": "deregisterValidator",
1331    "inputs": [],
1332    "outputs": [],
1333    "stateMutability": "nonpayable"
1334  },
1335  {
1336    "type": "function",
1337    "name": "exitEscrowPeriod",
1338    "inputs": [],
1339    "outputs": [
1340      {
1341        "name": "",
1342        "type": "uint256",
1343        "internalType": "uint256"
1344      }
1345    ],
1346    "stateMutability": "view"
1347  },
1348  {
1349    "type": "function",
1350    "name": "getVersion",
1351    "inputs": [],
1352    "outputs": [
1353      {
1354        "name": "majorVersion",
1355        "type": "uint8",
1356        "internalType": "uint8"
1357      },
1358      {
1359        "name": "minorVersion",
1360        "type": "uint8",
1361        "internalType": "uint8"
1362      },
1363      {
1364        "name": "patchVersion",
1365        "type": "uint8",
1366        "internalType": "uint8"
1367      }
1368    ],
1369    "stateMutability": "pure"
1370  },
1371  {
1372    "type": "function",
1373    "name": "initialize",
1374    "inputs": [
1375      {
1376        "name": "_tokenAddress",
1377        "type": "address",
1378        "internalType": "address"
1379      },
1380      {
1381        "name": "_lightClientAddress",
1382        "type": "address",
1383        "internalType": "address"
1384      },
1385      {
1386        "name": "_exitEscrowPeriod",
1387        "type": "uint256",
1388        "internalType": "uint256"
1389      },
1390      {
1391        "name": "_timelock",
1392        "type": "address",
1393        "internalType": "address"
1394      }
1395    ],
1396    "outputs": [],
1397    "stateMutability": "nonpayable"
1398  },
1399  {
1400    "type": "function",
1401    "name": "initializedAtBlock",
1402    "inputs": [],
1403    "outputs": [
1404      {
1405        "name": "",
1406        "type": "uint256",
1407        "internalType": "uint256"
1408      }
1409    ],
1410    "stateMutability": "view"
1411  },
1412  {
1413    "type": "function",
1414    "name": "lightClient",
1415    "inputs": [],
1416    "outputs": [
1417      {
1418        "name": "",
1419        "type": "address",
1420        "internalType": "contract ILightClient"
1421      }
1422    ],
1423    "stateMutability": "view"
1424  },
1425  {
1426    "type": "function",
1427    "name": "owner",
1428    "inputs": [],
1429    "outputs": [
1430      {
1431        "name": "",
1432        "type": "address",
1433        "internalType": "address"
1434      }
1435    ],
1436    "stateMutability": "view"
1437  },
1438  {
1439    "type": "function",
1440    "name": "proxiableUUID",
1441    "inputs": [],
1442    "outputs": [
1443      {
1444        "name": "",
1445        "type": "bytes32",
1446        "internalType": "bytes32"
1447      }
1448    ],
1449    "stateMutability": "view"
1450  },
1451  {
1452    "type": "function",
1453    "name": "registerValidator",
1454    "inputs": [
1455      {
1456        "name": "blsVK",
1457        "type": "tuple",
1458        "internalType": "struct BN254.G2Point",
1459        "components": [
1460          {
1461            "name": "x0",
1462            "type": "uint256",
1463            "internalType": "BN254.BaseField"
1464          },
1465          {
1466            "name": "x1",
1467            "type": "uint256",
1468            "internalType": "BN254.BaseField"
1469          },
1470          {
1471            "name": "y0",
1472            "type": "uint256",
1473            "internalType": "BN254.BaseField"
1474          },
1475          {
1476            "name": "y1",
1477            "type": "uint256",
1478            "internalType": "BN254.BaseField"
1479          }
1480        ]
1481      },
1482      {
1483        "name": "schnorrVK",
1484        "type": "tuple",
1485        "internalType": "struct EdOnBN254.EdOnBN254Point",
1486        "components": [
1487          {
1488            "name": "x",
1489            "type": "uint256",
1490            "internalType": "uint256"
1491          },
1492          {
1493            "name": "y",
1494            "type": "uint256",
1495            "internalType": "uint256"
1496          }
1497        ]
1498      },
1499      {
1500        "name": "blsSig",
1501        "type": "tuple",
1502        "internalType": "struct BN254.G1Point",
1503        "components": [
1504          {
1505            "name": "x",
1506            "type": "uint256",
1507            "internalType": "BN254.BaseField"
1508          },
1509          {
1510            "name": "y",
1511            "type": "uint256",
1512            "internalType": "BN254.BaseField"
1513          }
1514        ]
1515      },
1516      {
1517        "name": "commission",
1518        "type": "uint16",
1519        "internalType": "uint16"
1520      }
1521    ],
1522    "outputs": [],
1523    "stateMutability": "nonpayable"
1524  },
1525  {
1526    "type": "function",
1527    "name": "renounceOwnership",
1528    "inputs": [],
1529    "outputs": [],
1530    "stateMutability": "nonpayable"
1531  },
1532  {
1533    "type": "function",
1534    "name": "token",
1535    "inputs": [],
1536    "outputs": [
1537      {
1538        "name": "",
1539        "type": "address",
1540        "internalType": "contract ERC20"
1541      }
1542    ],
1543    "stateMutability": "view"
1544  },
1545  {
1546    "type": "function",
1547    "name": "transferOwnership",
1548    "inputs": [
1549      {
1550        "name": "newOwner",
1551        "type": "address",
1552        "internalType": "address"
1553      }
1554    ],
1555    "outputs": [],
1556    "stateMutability": "nonpayable"
1557  },
1558  {
1559    "type": "function",
1560    "name": "undelegate",
1561    "inputs": [
1562      {
1563        "name": "validator",
1564        "type": "address",
1565        "internalType": "address"
1566      },
1567      {
1568        "name": "amount",
1569        "type": "uint256",
1570        "internalType": "uint256"
1571      }
1572    ],
1573    "outputs": [],
1574    "stateMutability": "nonpayable"
1575  },
1576  {
1577    "type": "function",
1578    "name": "undelegations",
1579    "inputs": [
1580      {
1581        "name": "validator",
1582        "type": "address",
1583        "internalType": "address"
1584      },
1585      {
1586        "name": "delegator",
1587        "type": "address",
1588        "internalType": "address"
1589      }
1590    ],
1591    "outputs": [
1592      {
1593        "name": "amount",
1594        "type": "uint256",
1595        "internalType": "uint256"
1596      },
1597      {
1598        "name": "unlocksAt",
1599        "type": "uint256",
1600        "internalType": "uint256"
1601      }
1602    ],
1603    "stateMutability": "view"
1604  },
1605  {
1606    "type": "function",
1607    "name": "updateConsensusKeys",
1608    "inputs": [
1609      {
1610        "name": "newBlsVK",
1611        "type": "tuple",
1612        "internalType": "struct BN254.G2Point",
1613        "components": [
1614          {
1615            "name": "x0",
1616            "type": "uint256",
1617            "internalType": "BN254.BaseField"
1618          },
1619          {
1620            "name": "x1",
1621            "type": "uint256",
1622            "internalType": "BN254.BaseField"
1623          },
1624          {
1625            "name": "y0",
1626            "type": "uint256",
1627            "internalType": "BN254.BaseField"
1628          },
1629          {
1630            "name": "y1",
1631            "type": "uint256",
1632            "internalType": "BN254.BaseField"
1633          }
1634        ]
1635      },
1636      {
1637        "name": "newSchnorrVK",
1638        "type": "tuple",
1639        "internalType": "struct EdOnBN254.EdOnBN254Point",
1640        "components": [
1641          {
1642            "name": "x",
1643            "type": "uint256",
1644            "internalType": "uint256"
1645          },
1646          {
1647            "name": "y",
1648            "type": "uint256",
1649            "internalType": "uint256"
1650          }
1651        ]
1652      },
1653      {
1654        "name": "newBlsSig",
1655        "type": "tuple",
1656        "internalType": "struct BN254.G1Point",
1657        "components": [
1658          {
1659            "name": "x",
1660            "type": "uint256",
1661            "internalType": "BN254.BaseField"
1662          },
1663          {
1664            "name": "y",
1665            "type": "uint256",
1666            "internalType": "BN254.BaseField"
1667          }
1668        ]
1669      }
1670    ],
1671    "outputs": [],
1672    "stateMutability": "nonpayable"
1673  },
1674  {
1675    "type": "function",
1676    "name": "upgradeToAndCall",
1677    "inputs": [
1678      {
1679        "name": "newImplementation",
1680        "type": "address",
1681        "internalType": "address"
1682      },
1683      {
1684        "name": "data",
1685        "type": "bytes",
1686        "internalType": "bytes"
1687      }
1688    ],
1689    "outputs": [],
1690    "stateMutability": "payable"
1691  },
1692  {
1693    "type": "function",
1694    "name": "validatorExits",
1695    "inputs": [
1696      {
1697        "name": "validator",
1698        "type": "address",
1699        "internalType": "address"
1700      }
1701    ],
1702    "outputs": [
1703      {
1704        "name": "unlocksAt",
1705        "type": "uint256",
1706        "internalType": "uint256"
1707      }
1708    ],
1709    "stateMutability": "view"
1710  },
1711  {
1712    "type": "function",
1713    "name": "validators",
1714    "inputs": [
1715      {
1716        "name": "account",
1717        "type": "address",
1718        "internalType": "address"
1719      }
1720    ],
1721    "outputs": [
1722      {
1723        "name": "delegatedAmount",
1724        "type": "uint256",
1725        "internalType": "uint256"
1726      },
1727      {
1728        "name": "status",
1729        "type": "uint8",
1730        "internalType": "enum StakeTable.ValidatorStatus"
1731      }
1732    ],
1733    "stateMutability": "view"
1734  },
1735  {
1736    "type": "event",
1737    "name": "ConsensusKeysUpdated",
1738    "inputs": [
1739      {
1740        "name": "account",
1741        "type": "address",
1742        "indexed": true,
1743        "internalType": "address"
1744      },
1745      {
1746        "name": "blsVK",
1747        "type": "tuple",
1748        "indexed": false,
1749        "internalType": "struct BN254.G2Point",
1750        "components": [
1751          {
1752            "name": "x0",
1753            "type": "uint256",
1754            "internalType": "BN254.BaseField"
1755          },
1756          {
1757            "name": "x1",
1758            "type": "uint256",
1759            "internalType": "BN254.BaseField"
1760          },
1761          {
1762            "name": "y0",
1763            "type": "uint256",
1764            "internalType": "BN254.BaseField"
1765          },
1766          {
1767            "name": "y1",
1768            "type": "uint256",
1769            "internalType": "BN254.BaseField"
1770          }
1771        ]
1772      },
1773      {
1774        "name": "schnorrVK",
1775        "type": "tuple",
1776        "indexed": false,
1777        "internalType": "struct EdOnBN254.EdOnBN254Point",
1778        "components": [
1779          {
1780            "name": "x",
1781            "type": "uint256",
1782            "internalType": "uint256"
1783          },
1784          {
1785            "name": "y",
1786            "type": "uint256",
1787            "internalType": "uint256"
1788          }
1789        ]
1790      }
1791    ],
1792    "anonymous": false
1793  },
1794  {
1795    "type": "event",
1796    "name": "Delegated",
1797    "inputs": [
1798      {
1799        "name": "delegator",
1800        "type": "address",
1801        "indexed": true,
1802        "internalType": "address"
1803      },
1804      {
1805        "name": "validator",
1806        "type": "address",
1807        "indexed": true,
1808        "internalType": "address"
1809      },
1810      {
1811        "name": "amount",
1812        "type": "uint256",
1813        "indexed": false,
1814        "internalType": "uint256"
1815      }
1816    ],
1817    "anonymous": false
1818  },
1819  {
1820    "type": "event",
1821    "name": "Initialized",
1822    "inputs": [
1823      {
1824        "name": "version",
1825        "type": "uint64",
1826        "indexed": false,
1827        "internalType": "uint64"
1828      }
1829    ],
1830    "anonymous": false
1831  },
1832  {
1833    "type": "event",
1834    "name": "OwnershipTransferred",
1835    "inputs": [
1836      {
1837        "name": "previousOwner",
1838        "type": "address",
1839        "indexed": true,
1840        "internalType": "address"
1841      },
1842      {
1843        "name": "newOwner",
1844        "type": "address",
1845        "indexed": true,
1846        "internalType": "address"
1847      }
1848    ],
1849    "anonymous": false
1850  },
1851  {
1852    "type": "event",
1853    "name": "Undelegated",
1854    "inputs": [
1855      {
1856        "name": "delegator",
1857        "type": "address",
1858        "indexed": true,
1859        "internalType": "address"
1860      },
1861      {
1862        "name": "validator",
1863        "type": "address",
1864        "indexed": true,
1865        "internalType": "address"
1866      },
1867      {
1868        "name": "amount",
1869        "type": "uint256",
1870        "indexed": false,
1871        "internalType": "uint256"
1872      }
1873    ],
1874    "anonymous": false
1875  },
1876  {
1877    "type": "event",
1878    "name": "Upgraded",
1879    "inputs": [
1880      {
1881        "name": "implementation",
1882        "type": "address",
1883        "indexed": true,
1884        "internalType": "address"
1885      }
1886    ],
1887    "anonymous": false
1888  },
1889  {
1890    "type": "event",
1891    "name": "ValidatorExit",
1892    "inputs": [
1893      {
1894        "name": "validator",
1895        "type": "address",
1896        "indexed": true,
1897        "internalType": "address"
1898      }
1899    ],
1900    "anonymous": false
1901  },
1902  {
1903    "type": "event",
1904    "name": "ValidatorRegistered",
1905    "inputs": [
1906      {
1907        "name": "account",
1908        "type": "address",
1909        "indexed": true,
1910        "internalType": "address"
1911      },
1912      {
1913        "name": "blsVk",
1914        "type": "tuple",
1915        "indexed": false,
1916        "internalType": "struct BN254.G2Point",
1917        "components": [
1918          {
1919            "name": "x0",
1920            "type": "uint256",
1921            "internalType": "BN254.BaseField"
1922          },
1923          {
1924            "name": "x1",
1925            "type": "uint256",
1926            "internalType": "BN254.BaseField"
1927          },
1928          {
1929            "name": "y0",
1930            "type": "uint256",
1931            "internalType": "BN254.BaseField"
1932          },
1933          {
1934            "name": "y1",
1935            "type": "uint256",
1936            "internalType": "BN254.BaseField"
1937          }
1938        ]
1939      },
1940      {
1941        "name": "schnorrVk",
1942        "type": "tuple",
1943        "indexed": false,
1944        "internalType": "struct EdOnBN254.EdOnBN254Point",
1945        "components": [
1946          {
1947            "name": "x",
1948            "type": "uint256",
1949            "internalType": "uint256"
1950          },
1951          {
1952            "name": "y",
1953            "type": "uint256",
1954            "internalType": "uint256"
1955          }
1956        ]
1957      },
1958      {
1959        "name": "commission",
1960        "type": "uint16",
1961        "indexed": false,
1962        "internalType": "uint16"
1963      }
1964    ],
1965    "anonymous": false
1966  },
1967  {
1968    "type": "event",
1969    "name": "Withdrawal",
1970    "inputs": [
1971      {
1972        "name": "account",
1973        "type": "address",
1974        "indexed": true,
1975        "internalType": "address"
1976      },
1977      {
1978        "name": "amount",
1979        "type": "uint256",
1980        "indexed": false,
1981        "internalType": "uint256"
1982      }
1983    ],
1984    "anonymous": false
1985  },
1986  {
1987    "type": "error",
1988    "name": "AddressEmptyCode",
1989    "inputs": [
1990      {
1991        "name": "target",
1992        "type": "address",
1993        "internalType": "address"
1994      }
1995    ]
1996  },
1997  {
1998    "type": "error",
1999    "name": "BLSSigIsInfinity",
2000    "inputs": []
2001  },
2002  {
2003    "type": "error",
2004    "name": "BLSSigVerificationFailed",
2005    "inputs": []
2006  },
2007  {
2008    "type": "error",
2009    "name": "BLSVKIsInfinity",
2010    "inputs": []
2011  },
2012  {
2013    "type": "error",
2014    "name": "BN254PairingProdFailed",
2015    "inputs": []
2016  },
2017  {
2018    "type": "error",
2019    "name": "BlsKeyAlreadyUsed",
2020    "inputs": []
2021  },
2022  {
2023    "type": "error",
2024    "name": "ERC1967InvalidImplementation",
2025    "inputs": [
2026      {
2027        "name": "implementation",
2028        "type": "address",
2029        "internalType": "address"
2030      }
2031    ]
2032  },
2033  {
2034    "type": "error",
2035    "name": "ERC1967NonPayable",
2036    "inputs": []
2037  },
2038  {
2039    "type": "error",
2040    "name": "ExitEscrowPeriodInvalid",
2041    "inputs": []
2042  },
2043  {
2044    "type": "error",
2045    "name": "FailedInnerCall",
2046    "inputs": []
2047  },
2048  {
2049    "type": "error",
2050    "name": "InsufficientAllowance",
2051    "inputs": [
2052      {
2053        "name": "",
2054        "type": "uint256",
2055        "internalType": "uint256"
2056      },
2057      {
2058        "name": "",
2059        "type": "uint256",
2060        "internalType": "uint256"
2061      }
2062    ]
2063  },
2064  {
2065    "type": "error",
2066    "name": "InsufficientBalance",
2067    "inputs": [
2068      {
2069        "name": "",
2070        "type": "uint256",
2071        "internalType": "uint256"
2072      }
2073    ]
2074  },
2075  {
2076    "type": "error",
2077    "name": "InvalidCommission",
2078    "inputs": []
2079  },
2080  {
2081    "type": "error",
2082    "name": "InvalidG1",
2083    "inputs": []
2084  },
2085  {
2086    "type": "error",
2087    "name": "InvalidInitialization",
2088    "inputs": []
2089  },
2090  {
2091    "type": "error",
2092    "name": "InvalidSchnorrVK",
2093    "inputs": []
2094  },
2095  {
2096    "type": "error",
2097    "name": "NotInitializing",
2098    "inputs": []
2099  },
2100  {
2101    "type": "error",
2102    "name": "NothingToWithdraw",
2103    "inputs": []
2104  },
2105  {
2106    "type": "error",
2107    "name": "OwnableInvalidOwner",
2108    "inputs": [
2109      {
2110        "name": "owner",
2111        "type": "address",
2112        "internalType": "address"
2113      }
2114    ]
2115  },
2116  {
2117    "type": "error",
2118    "name": "OwnableUnauthorizedAccount",
2119    "inputs": [
2120      {
2121        "name": "account",
2122        "type": "address",
2123        "internalType": "address"
2124      }
2125    ]
2126  },
2127  {
2128    "type": "error",
2129    "name": "OwnershipCannotBeRenounced",
2130    "inputs": []
2131  },
2132  {
2133    "type": "error",
2134    "name": "PowPrecompileFailed",
2135    "inputs": []
2136  },
2137  {
2138    "type": "error",
2139    "name": "PrematureWithdrawal",
2140    "inputs": []
2141  },
2142  {
2143    "type": "error",
2144    "name": "UUPSUnauthorizedCallContext",
2145    "inputs": []
2146  },
2147  {
2148    "type": "error",
2149    "name": "UUPSUnsupportedProxiableUUID",
2150    "inputs": [
2151      {
2152        "name": "slot",
2153        "type": "bytes32",
2154        "internalType": "bytes32"
2155      }
2156    ]
2157  },
2158  {
2159    "type": "error",
2160    "name": "UndelegationAlreadyExists",
2161    "inputs": []
2162  },
2163  {
2164    "type": "error",
2165    "name": "ValidatorAlreadyExited",
2166    "inputs": []
2167  },
2168  {
2169    "type": "error",
2170    "name": "ValidatorAlreadyRegistered",
2171    "inputs": []
2172  },
2173  {
2174    "type": "error",
2175    "name": "ValidatorInactive",
2176    "inputs": []
2177  },
2178  {
2179    "type": "error",
2180    "name": "ValidatorNotExited",
2181    "inputs": []
2182  },
2183  {
2184    "type": "error",
2185    "name": "ZeroAddress",
2186    "inputs": []
2187  },
2188  {
2189    "type": "error",
2190    "name": "ZeroAmount",
2191    "inputs": []
2192  }
2193]
2194```*/
2195#[allow(
2196    non_camel_case_types,
2197    non_snake_case,
2198    clippy::pub_underscore_fields,
2199    clippy::style,
2200    clippy::empty_structs_with_brackets
2201)]
2202pub mod StakeTable {
2203    use super::*;
2204    use alloy::sol_types as alloy_sol_types;
2205    /// The creation / init bytecode of the contract.
2206    ///
2207    /// ```text
2208    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
2209    /// ```
2210    #[rustfmt::skip]
2211    #[allow(clippy::all)]
2212    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
2213        b"`\xA0`@R0`\x80R4\x80\x15a\0\x13W__\xFD[Pa\0\x1Ca\0)V[a\0$a\0)V[a\0\xDBV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80Th\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\0yW`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80T`\x01`\x01`@\x1B\x03\x90\x81\x16\x14a\0\xD8W\x80T`\x01`\x01`@\x1B\x03\x19\x16`\x01`\x01`@\x1B\x03\x90\x81\x17\x82U`@Q\x90\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PV[`\x80Qa*\xF3a\x01\x01_9_\x81\x81a\x13\xA5\x01R\x81\x81a\x13\xCE\x01Ra\x15\x14\x01Ra*\xF3_\xF3\xFE`\x80`@R`\x046\x10a\x01aW_5`\xE0\x1C\x80c\x9B0\xA5\xE6\x11a\0\xCDW\x80c\xB5p\x0Eh\x11a\0\x87W\x80c\xC6H\x14\xDD\x11a\0bW\x80c\xC6H\x14\xDD\x14a\x04|W\x80c\xF2\xFD\xE3\x8B\x14a\x04\xB2W\x80c\xFAR\xC7\xD8\x14a\x04\xD1W\x80c\xFC\x0CTj\x14a\x05\x14W__\xFD[\x80c\xB5p\x0Eh\x14a\x04\x13W\x80c\xB5\xEC\xB3D\x14a\x042W\x80c\xBE 0\x94\x14a\x04]W__\xFD[\x80c\x9B0\xA5\xE6\x14a\x02\xF3W\x80c\x9E\x9A\x8F1\x14a\x03\x12W\x80c\xA2\xD7\x8D\xD5\x14a\x03'W\x80c\xA3\x06j\xAB\x14a\x03yW\x80c\xAD<\xB1\xCC\x14a\x03\x98W\x80c\xB3\xE6\xEB\xD5\x14a\x03\xD5W__\xFD[\x80cO\x1E\xF2\x86\x11a\x01\x1EW\x80cO\x1E\xF2\x86\x14a\x025W\x80cR\xD1\x90-\x14a\x02HW\x80cUD\xC2\xF1\x14a\x02\\W\x80cj\x91\x1C\xCF\x14a\x02{W\x80cqP\x18\xA6\x14a\x02\x8FW\x80c\x8D\xA5\xCB[\x14a\x02\xA3W__\xFD[\x80c\x02n@+\x14a\x01eW\x80c\r\x8En,\x14a\x01\x86W\x80c\x13\xB9\x05z\x14a\x01\xB6W\x80c!@\xFE\xCD\x14a\x01\xD5W\x80c>\x9D\xF9\xB5\x14a\x01\xF4W\x80cM\x99\xDD\x16\x14a\x02\x16W[__\xFD[4\x80\x15a\x01pW__\xFD[Pa\x01\x84a\x01\x7F6`\x04a#\xF1V[a\x053V[\0[4\x80\x15a\x01\x91W__\xFD[P`@\x80Q`\x01\x81R_` \x82\x01\x81\x90R\x91\x81\x01\x91\x90\x91R``\x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xC1W__\xFD[Pa\x01\x84a\x01\xD06`\x04a%\x17V[a\x06\xD6V[4\x80\x15a\x01\xE0W__\xFD[Pa\x01\x84a\x01\xEF6`\x04a%uV[a\x08iV[4\x80\x15a\x01\xFFW__\xFD[Pa\x02\x08_T\x81V[`@Q\x90\x81R` \x01a\x01\xADV[4\x80\x15a\x02!W__\xFD[Pa\x01\x84a\x0206`\x04a#\xF1V[a\t\x8AV[a\x01\x84a\x02C6`\x04a%\x8EV[a\x0B<V[4\x80\x15a\x02SW__\xFD[Pa\x02\x08a\x0B[V[4\x80\x15a\x02gW__\xFD[Pa\x01\x84a\x02v6`\x04a&3V[a\x0BvV[4\x80\x15a\x02\x86W__\xFD[Pa\x01\x84a\x0C?V[4\x80\x15a\x02\x9AW__\xFD[Pa\x01\x84a\x0C\xCDV[4\x80\x15a\x02\xAEW__\xFD[P\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\xADV[4\x80\x15a\x02\xFEW__\xFD[Pa\x02\x08a\x03\r6`\x04a&wV[a\x0C\xEEV[4\x80\x15a\x03\x1DW__\xFD[Pa\x02\x08`\x08T\x81V[4\x80\x15a\x032W__\xFD[Pa\x03da\x03A6`\x04a&\x91V[`\x07` \x90\x81R_\x92\x83R`@\x80\x84 \x90\x91R\x90\x82R\x90 \x80T`\x01\x90\x91\x01T\x82V[`@\x80Q\x92\x83R` \x83\x01\x91\x90\x91R\x01a\x01\xADV[4\x80\x15a\x03\x84W__\xFD[Pa\x01\x84a\x03\x936`\x04a%uV[a\rHV[4\x80\x15a\x03\xA3W__\xFD[Pa\x03\xC8`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d\x03R\xE3\x02\xE3`\xDC\x1B\x81RP\x81V[`@Qa\x01\xAD\x91\x90a&\xC2V[4\x80\x15a\x03\xE0W__\xFD[Pa\x04\x03a\x03\xEF6`\x04a&\xF7V[`\x04` R_\x90\x81R`@\x90 T`\xFF\x16\x81V[`@Q\x90\x15\x15\x81R` \x01a\x01\xADV[4\x80\x15a\x04\x1EW__\xFD[P`\x01Ta\x02\xDB\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[4\x80\x15a\x04=W__\xFD[Pa\x02\x08a\x04L6`\x04a%uV[`\x05` R_\x90\x81R`@\x90 T\x81V[4\x80\x15a\x04hW__\xFD[Pa\x01\x84a\x04w6`\x04a'\x0EV[a\x0EXV[4\x80\x15a\x04\x87W__\xFD[Pa\x02\x08a\x04\x966`\x04a&\x91V[`\x06` \x90\x81R_\x92\x83R`@\x80\x84 \x90\x91R\x90\x82R\x90 T\x81V[4\x80\x15a\x04\xBDW__\xFD[Pa\x01\x84a\x04\xCC6`\x04a%uV[a\x0F\x84V[4\x80\x15a\x04\xDCW__\xFD[Pa\x05\x06a\x04\xEB6`\x04a%uV[`\x03` R_\x90\x81R`@\x90 \x80T`\x01\x90\x91\x01T`\xFF\x16\x82V[`@Qa\x01\xAD\x92\x91\x90a'lV[4\x80\x15a\x05\x1FW__\xFD[P`\x02Ta\x02\xDB\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x05<\x82a\x0F\xC1V[3_\x82\x90\x03a\x05^W`@Qc\x1F* \x05`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02T`@Qcn\xB1v\x9F`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R0`$\x83\x01R_\x92\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xACW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xD0\x91\x90a'\x9CV[\x90P\x82\x81\x10\x15a\x06\x02W`@Qc\x05Ce\xBB`\xE3\x1B\x81R`\x04\x81\x01\x82\x90R`$\x81\x01\x84\x90R`D\x01[`@Q\x80\x91\x03\x90\xFD[`\x02Ta\x06\x1A\x90`\x01`\x01`\xA0\x1B\x03\x16\x830\x86a\x10BV[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\x03` R`@\x81 \x80T\x85\x92\x90a\x06A\x90\x84\x90a'\xC7V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R\x90\x81 \x80T\x85\x92\x90a\x06|\x90\x84\x90a'\xC7V[\x92PP\x81\x90UP\x83`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x7F\xE5T\x1Aka\x03\xD4\xFA~\x02\x1E\xD5O\xAD9\xC6o'\xA7k\xD1=7L\xF6$\n\xE6\xBD\x0B\xB7+\x85`@Qa\x06\xC8\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[3a\x06\xE0\x81a\x10\xE6V[a\x06\xE9\x84a\x113V[a\x06\xF2\x85a\x11\xC6V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x83\x16` \x82\x01R_\x91\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90Pa\x07$\x81\x85\x88a\x12\x02V[a'\x10\x83a\xFF\xFF\x16\x11\x15a\x07KW`@Qc\xDC\x81\xDB\x85`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x04_a\x07Y\x89a\x0C\xEEV[\x81R` \x01\x90\x81R` \x01_ _a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`@Q\x80`@\x01`@R\x80_\x81R` \x01`\x01`\x02\x81\x11\x15a\x07\xA0Wa\x07\xA0a'XV[\x90R`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x03` \x90\x81R`@\x90\x91 \x82Q\x81U\x90\x82\x01Q`\x01\x80\x83\x01\x80T\x90\x91`\xFF\x19\x90\x91\x16\x90\x83`\x02\x81\x11\x15a\x07\xE6Wa\x07\xE6a'XV[\x02\x17\x90UPP`@\x80Q\x88Q\x81R` \x80\x8A\x01Q\x81\x83\x01R\x89\x83\x01Q\x82\x84\x01R``\x80\x8B\x01Q\x90\x83\x01R\x88Q`\x80\x83\x01R\x88\x01Q`\xA0\x82\x01Ra\xFF\xFF\x86\x16`\xC0\x82\x01R\x90Q`\x01`\x01`\xA0\x1B\x03\x85\x16\x92P\x7F\xF6\xE85\x9CWR\x0BF\x964sk\xFC;\xB7\xEC\\\xBD\x1A\x0B\xD2\x8B\x10\xA8'W\x93\xBBs\x0By\x7F\x91\x81\x90\x03`\xE0\x01\x90\xA2PPPPPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x05` R`@\x81 T3\x91\x81\x90\x03a\x08\xA3W`@Qcy)\x8AS`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80B\x10\x15a\x08\xC4W`@QcZwCW`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R\x90\x81 T\x90\x81\x90\x03a\t\x0CW`@Qc\x06\x86\x82{`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x87\x85\x16\x84R\x90\x91R\x81 U`\x02Ta\tA\x91\x16\x84\x83a\x13\x0BV[\x82`\x01`\x01`\xA0\x1B\x03\x16\x7F\x7F\xCFS,\x15\xF0\xA6\xDB\x0B\xD6\xD0\xE08\xBE\xA7\x1D0\xD8\x08\xC7\xD9\x8C\xB3\xBFrh\xA9[\xF5\x08\x1Be\x82`@Qa\t|\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2PPPPV[a\t\x93\x82a\x0F\xC1V[3_\x82\x90\x03a\t\xB5W`@Qc\x1F* \x05`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x07` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R\x92\x90R T\x15a\t\xF8W`@Qc\xD4#\xA4\xF1`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R\x92\x90R T\x82\x81\x10\x15a\nAW`@Qc\x92fSQ`\xE0\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x05\xF9V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R\x90\x81 \x80T\x85\x92\x90a\nw\x90\x84\x90a'\xDAV[\x92PP\x81\x90UP`@Q\x80`@\x01`@R\x80\x84\x81R` \x01`\x08TBa\n\x9D\x91\x90a'\xC7V[\x90R`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x81\x81R`\x07` \x90\x81R`@\x80\x83 \x94\x88\x16\x83R\x93\x81R\x83\x82 \x85Q\x81U\x94\x81\x01Q`\x01\x90\x95\x01\x94\x90\x94U\x90\x81R`\x03\x90\x92R\x81 \x80T\x85\x92\x90a\n\xF0\x90\x84\x90a'\xDAV[\x92PP\x81\x90UP\x83`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x7FM\x10\xBD\x04\x97u\xC7{\xD7\xF2U\x19Z\xFB\xA5\x08\x80(\xEC\xB3\xC7\xC2w\xD3\x93\xCC\xFFy4\xF2\xF9,\x85`@Qa\x06\xC8\x91\x81R` \x01\x90V[a\x0BDa\x13\x9AV[a\x0BM\x82a\x14@V[a\x0BW\x82\x82a\x14HV[PPV[_a\x0Bda\x15\tV[P_Q` a*\xC7_9_Q\x90_R\x90V[3a\x0B\x80\x81a\x0F\xC1V[a\x0B\x89\x83a\x113V[a\x0B\x92\x84a\x11\xC6V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x83\x16` \x82\x01R_\x91\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90Pa\x0B\xC4\x81\x84\x87a\x12\x02V[`\x01`\x04_a\x0B\xD2\x88a\x0C\xEEV[\x81R` \x01\x90\x81R` \x01_ _a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x81`\x01`\x01`\xA0\x1B\x03\x16\x7F\x80\xD8\xA4\xA1f3(\xA9\x98\xD4U[\xA2\x1D\x8B\xBAn\xF1Wj\x8C^\x9D'\xF9\xC5E\xF1\xA3\xD5+\x1D\x86\x86`@Qa\x0C0\x92\x91\x90a'\xEDV[`@Q\x80\x91\x03\x90\xA2PPPPPV[3a\x0CI\x81a\x0F\xC1V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x03` R`@\x90 `\x01\x01\x80T`\xFF\x19\x16`\x02\x17\x90U`\x08Ta\x0C{\x90Ba'\xC7V[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x81\x81R`\x05` \x90\x81R`@\x80\x83 \x94\x90\x94U`\x03\x90R\x82\x81 \x81\x90U\x91Q\x90\x91\x7F\xFB$0ST\xC8wb\xD5WHz\xE4\xA5d\xE8\xD0>\xCB\xB9\xA9}\xD8\xAF\xFF\x8E\x1Fo\xCA\xF0\xDD\x16\x91\xA2PV[a\x0C\xD5a\x15RV[`@Qc\x17\xD5\xC9e`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81_\x01Q\x82` \x01Q\x83`@\x01Q\x84``\x01Q`@Q` \x01a\r+\x94\x93\x92\x91\x90\x93\x84R` \x84\x01\x92\x90\x92R`@\x83\x01R``\x82\x01R`\x80\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x07` \x90\x81R`@\x80\x83 3\x80\x85R\x92R\x82 T\x90\x91\x81\x90\x03a\r\x8DW`@Qc\x06\x86\x82{`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x07` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R `\x01\x01TB\x10\x15a\r\xD5W`@QcZwCW`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x07` \x90\x81R`@\x80\x83 \x86\x85\x16\x84R\x90\x91R\x81 \x81\x81U`\x01\x01U`\x02Ta\x0E\x10\x91\x16\x83\x83a\x13\x0BV[\x81`\x01`\x01`\xA0\x1B\x03\x16\x7F\x7F\xCFS,\x15\xF0\xA6\xDB\x0B\xD6\xD0\xE08\xBE\xA7\x1D0\xD8\x08\xC7\xD9\x8C\xB3\xBFrh\xA9[\xF5\x08\x1Be\x82`@Qa\x0EK\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2PPPV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x81\x15\x80\x15a\x0E\x9DWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x0E\xB9WP0;\x15[\x90P\x81\x15\x80\x15a\x0E\xC7WP\x80\x15[\x15a\x0E\xE5W`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x0F\x0FW\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x0F\x18\x86a\x15\xADV[a\x0F a\x15\xBEV[a\x0F(a\x15\xC6V[a\x0F3\x89\x89\x89a\x16\xCCV[\x83\x15a\x0FyW\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPPPPV[a\x0F\x8Ca\x15RV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x0F\xB5W`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x05\xF9V[a\x0F\xBE\x81a\x17wV[PV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x03` R`@\x81 `\x01\x01T`\xFF\x16\x90\x81`\x02\x81\x11\x15a\x0F\xF2Wa\x0F\xF2a'XV[\x03a\x10\x10W`@QcP\x8Ay?`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x81`\x02\x81\x11\x15a\x10$Wa\x10$a'XV[\x03a\x0BWW`@Qc\xEA\xB4\xA9c`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_`@Qc#\xB8r\xDD`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R\x82`D\x82\x01R` _`d\x83_\x8AZ\xF1\x91PP\x80`\x1F=\x11`\x01_Q\x14\x16\x15\x16\x15a\x10\x9BWP\x83;\x15=\x17\x15[\x80a\x10\xDFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01Rs\x15\x14\x90S\x94\xD1\x91T\x97\xD1\x94\x93\xD3W\xD1\x90RS\x11Q`b\x1B`D\x82\x01R`d\x01a\x05\xF9V[PPPPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x03` R`@\x81 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x11\x15Wa\x11\x15a'XV[\x14a\x0F\xBEW`@Qc\x13.~\xFB`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Q\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X](3\xE8Hy\xB9p\x91C\xE1\xF5\x93\xF0\0\0\x01\x11\x15\x80a\x11\x87WP\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X](3\xE8Hy\xB9p\x91C\xE1\xF5\x93\xF0\0\0\x01\x81` \x01Q\x10\x15[\x15a\x11\xA5W`@Qc\x06\xCFC\x8F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Q_\x03a\x0F\xBEW`@Qc\x06\xCFC\x8F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04_a\x11\xD2\x83a\x0C\xEEV[\x81R` \x81\x01\x91\x90\x91R`@\x01_ T`\xFF\x16\x15a\x0F\xBEW`@Qb\xDA\x8AW`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81Q` \x83\x01Q\x15\x90\x15\x16\x15a\x12+W`@Qc:\x13\x91\x99`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Q\x15\x80\x15a\x12<WP` \x81\x01Q\x15[\x80\x15a\x12JWP`@\x81\x01Q\x15[\x80\x15a\x12XWP``\x81\x01Q\x15[\x15a\x12vW`@Qc^Cb\xCD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x12\x7F\x82a\x17\xE7V[_`@Q\x80``\x01`@R\x80`$\x81R` \x01a*\x83`$\x919\x90P_\x84\x82`@Q` \x01a\x12\xAF\x92\x91\x90a(>V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P_a\x12\xCA\x82a\x18NV[\x90Pa\x12\xE7\x81\x85a\x12\xDA\x88a\x19;V[a\x12\xE2a\x19\xB2V[a\x1A\x7FV[a\x13\x03W`@Qb\xCE\xD3\xE5`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPPPV[_`@Qc\xA9\x05\x9C\xBB`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01R\x82`$\x82\x01R` _`D\x83_\x89Z\xF1\x91PP\x80`\x1F=\x11`\x01_Q\x14\x16\x15\x16\x15a\x13UWP\x82;\x15=\x17\x15[\x80a\x13\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x0F`$\x82\x01Rn\x15\x14\x90S\x94\xD1\x91T\x97\xD1\x90RS\x11Q`\x8A\x1B`D\x82\x01R`d\x01a\x05\xF9V[PPPPV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14\x80a\x14 WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16a\x14\x14_Q` a*\xC7_9_Q\x90_RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x14>W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[a\x0F\xBEa\x15RV[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\x14\xA2WP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x14\x9F\x91\x81\x01\x90a'\x9CV[`\x01[a\x14\xCAW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x05\xF9V[_Q` a*\xC7_9_Q\x90_R\x81\x14a\x14\xFAW`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x05\xF9V[a\x15\x04\x83\x83a\x1B.V[PPPV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x14>W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3a\x15\x84\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x14>W`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x05\xF9V[a\x15\xB5a\x1B\x83V[a\x0F\xBE\x81a\x1B\xCCV[a\x14>a\x1B\x83V[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x81\x15\x80\x15a\x16\x0BWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x16'WP0;\x15[\x90P\x81\x15\x80\x15a\x165WP\x80\x15[\x15a\x16SW`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x16}W\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[C_U\x83\x15a\x10\xDFW\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x16\xF3W`@Qc\xD9.#=`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x17\x1AW`@Qc\xD9.#=`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x80T`\x01`\x01`\xA0\x1B\x03\x80\x86\x16`\x01`\x01`\xA0\x1B\x03\x19\x92\x83\x16\x17\x90\x92U`\x01\x80T\x92\x85\x16\x92\x90\x91\x16\x91\x90\x91\x17\x90Ub\x02\xA3\0\x80\x82\x10\x15a\x17oW`@Qc\xB5~!\xDF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x08UPPV[\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x82\x17\x84U`@Q\x92\x16\x91\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPPV[\x80Q` \x82\x01Q_\x91_Q` a*\xA7_9_Q\x90_R\x91\x15\x90\x15\x16\x15a\x18\rWPPPV[\x82Q` \x84\x01Q\x82`\x03\x84\x85\x85\x86\t\x85\t\x08\x83\x82\x83\t\x14\x83\x82\x10\x84\x84\x10\x16\x16\x93PPP\x81a\x15\x04W`@Qc'\x9E4S`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R_a\x18k\x83a\x1B\xD4V[\x90P_Q` a*\xA7_9_Q\x90_R`\x03_\x82\x84\x85\t\x90P\x82\x80a\x18\x92Wa\x18\x92a(ZV[\x84\x82\t\x90P\x82\x80a\x18\xA5Wa\x18\xA5a(ZV[\x82\x82\x08\x90P__a\x18\xB5\x83a\x1D\xDDV[\x92P\x90P[\x80a\x19\x1EW\x84\x80a\x18\xCDWa\x18\xCDa(ZV[`\x01\x87\x08\x95P\x84\x80a\x18\xE1Wa\x18\xE1a(ZV[\x86\x87\t\x92P\x84\x80a\x18\xF4Wa\x18\xF4a(ZV[\x86\x84\t\x92P\x84\x80a\x19\x07Wa\x19\x07a(ZV[\x84\x84\x08\x92Pa\x19\x15\x83a\x1D\xDDV[\x92P\x90Pa\x18\xBAV[P`@\x80Q\x80\x82\x01\x90\x91R\x94\x85R` \x85\x01RP\x91\x94\x93PPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R\x81Q` \x83\x01Q\x15\x90\x15\x16\x15a\x19bWP\x90V[`@Q\x80`@\x01`@R\x80\x83_\x01Q\x81R` \x01_Q` a*\xA7_9_Q\x90_R\x84` \x01Qa\x19\x93\x91\x90a(nV[a\x19\xAA\x90_Q` a*\xA7_9_Q\x90_Ra'\xDAV[\x90R\x92\x91PPV[a\x19\xD9`@Q\x80`\x80\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[`@Q\x80`\x80\x01`@R\x80\x7F\x18\0\xDE\xEF\x12\x1F\x1EvBj\0f^\\DygC\"\xD4\xF7^\xDA\xDDF\xDE\xBD\\\xD9\x92\xF6\xED\x81R` \x01\x7F\x19\x8E\x93\x93\x92\rH:r`\xBF\xB71\xFB]%\xF1\xAAI35\xA9\xE7\x12\x97\xE4\x85\xB7\xAE\xF3\x12\xC2\x81R` \x01\x7F\x12\xC8^\xA5\xDB\x8Cm\xEBJ\xABq\x80\x8D\xCB@\x8F\xE3\xD1\xE7i\x0CC\xD3{L\xE6\xCC\x01f\xFA}\xAA\x81R` \x01\x7F\t\x06\x89\xD0X_\xF0u\xEC\x9E\x99\xADi\x0C3\x95\xBCK13p\xB3\x8E\xF3U\xAC\xDA\xDC\xD1\"\x97[\x81RP\x90P\x90V[___`@Q\x87Q\x81R` \x88\x01Q` \x82\x01R` \x87\x01Q`@\x82\x01R\x86Q``\x82\x01R``\x87\x01Q`\x80\x82\x01R`@\x87\x01Q`\xA0\x82\x01R\x85Q`\xC0\x82\x01R` \x86\x01Q`\xE0\x82\x01R` \x85\x01Qa\x01\0\x82\x01R\x84Qa\x01 \x82\x01R``\x85\x01Qa\x01@\x82\x01R`@\x85\x01Qa\x01`\x82\x01R` _a\x01\x80\x83`\x08Z\xFA\x91PP_Q\x91P\x80a\x1B\"W`@Qc\xC2\x063O`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P\x15\x15\x95\x94PPPPPV[a\x1B7\x82a\x1E\xA5V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\x1B{Wa\x15\x04\x82\x82a\x1F\x08V[a\x0BWa\x1F|V[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0T`\x01`@\x1B\x90\x04`\xFF\x16a\x14>W`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0F\x8Ca\x1B\x83V[__a\x1B\xDF\x83a\x1F\x9BV[\x80Q\x90\x91P`0\x81\x14a\x1B\xF4Wa\x1B\xF4a(\x8DV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C\x0EWa\x1C\x0Ea$\x19V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1C8W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_[\x82\x81\x10\x15a\x1C\xA7W\x83`\x01a\x1CR\x83\x86a'\xDAV[a\x1C\\\x91\x90a'\xDAV[\x81Q\x81\x10a\x1ClWa\x1Cla(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x82\x82\x81Q\x81\x10a\x1C\x89Wa\x1C\x89a(\xA1V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a\x1C=V[P`@\x80Q`\x1F\x80\x82Ra\x04\0\x82\x01\x90\x92R_\x90\x82` \x82\x01a\x03\xE0\x806\x837\x01\x90PP\x90P_[\x82\x81\x10\x15a\x1D7W\x83\x81a\x1C\xE3\x85\x88a'\xDAV[a\x1C\xED\x91\x90a'\xC7V[\x81Q\x81\x10a\x1C\xFDWa\x1C\xFDa(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B`\xF8\x1C\x82\x82\x81Q\x81\x10a\x1D\x1DWa\x1D\x1Da(\xA1V[`\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a\x1C\xCFV[P_a\x1DB\x82a\"\xE7V[\x90Pa\x01\0_Q` a*\xA7_9_Q\x90_R_a\x1D`\x86\x89a'\xDAV[\x90P_[\x81\x81\x10\x15a\x1D\xCDW_\x88`\x01a\x1Dz\x84\x86a'\xDAV[a\x1D\x84\x91\x90a'\xDAV[\x81Q\x81\x10a\x1D\x94Wa\x1D\x94a(\xA1V[\x01` \x01Q`\xF8\x1C\x90P\x83\x80a\x1D\xACWa\x1D\xACa(ZV[\x85\x87\t\x95P\x83\x80a\x1D\xBFWa\x1D\xBFa(ZV[\x81\x87\x08\x95PP`\x01\x01a\x1DdV[P\x92\x9A\x99PPPPPPPPPPV[_____\x7F\x0C\x19\x13\x9C\xB8Lh\nn\x14\x11m\xA0`V\x17e\xE0Z\xA4Z\x1Cr\xA3O\x08#\x05\xB6\x1F?R\x90P__Q` a*\xA7_9_Q\x90_R\x90P`@Q` \x81R` \x80\x82\x01R` `@\x82\x01R\x87``\x82\x01R\x82`\x80\x82\x01R\x81`\xA0\x82\x01R` _`\xC0\x83`\x05Z\xFA\x94PP_Q\x92P\x83a\x1EkW`@Qc\x0C\x9D>\x99`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80`\x01\x84\x90\x1B\x11\x15a\x1E\x84Wa\x1E\x81\x83\x82a'\xDAV[\x92P[\x80\x80a\x1E\x92Wa\x1E\x92a(ZV[\x83\x84\t\x96\x90\x96\x14\x96\x91\x95P\x90\x93PPPPV[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x1E\xDAW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x05\xF9V[_Q` a*\xC7_9_Q\x90_R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``__\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\x1F$\x91\x90a(\xB5V[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x1F\\W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x1FaV[``\x91P[P\x91P\x91Pa\x1Fq\x85\x83\x83a#NV[\x92PPP[\x92\x91PPV[4\x15a\x14>W`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q`0\x80\x82R``\x82\x81\x01\x90\x93R\x90` \x90`\x01`\xF9\x1B\x90_\x90\x84` \x82\x01\x81\x806\x837\x01\x90PP\x90P\x80\x86`@Q` \x01a\x1F\xDB\x92\x91\x90a(>V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P\x80\x84`\xF8\x1B`@Q` \x01a \x02\x92\x91\x90a(\xC0V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P\x80`@Q` \x01a $\x91\x90a(\xEAV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90R\x91Pa\x01\x01`\xF0\x1B\x90a N\x90\x83\x90\x83\x90` \x01a)\x02V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x82\x82R\x80Q` \x91\x82\x01 \x81\x84\x01\x81\x90R`\x01`\xF8\x1B\x84\x84\x01R`\x01`\x01`\xF0\x1B\x03\x19\x85\x16`A\x85\x01R\x82Q`#\x81\x86\x03\x01\x81R`C\x90\x94\x01\x90\x92R\x82Q\x90\x83\x01 \x91\x93P\x90_`\xFF\x88\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \xBEWa \xBEa$\x19V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a \xE8W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_\x82`@Q` \x01a \xFF\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x90P_[\x81Q\x81\x10\x15a!iW\x81\x81\x81Q\x81\x10a!.Wa!.a(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x83\x82\x81Q\x81\x10a!KWa!Ka(\xA1V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a!\x13V[P_\x84`@Q` \x01a!~\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R` \x83\x01\x90\x91R_\x80\x83R\x91\x98P\x91P[\x89\x81\x10\x15a\"\x10W_\x83\x82\x81Q\x81\x10a!\xB7Wa!\xB7a(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x83\x83\x81Q\x81\x10a!\xD4Wa!\xD4a(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x18\x90P\x88\x81`@Q` \x01a!\xF5\x92\x91\x90a)&V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x98PP`\x01\x01a!\x9CV[P\x86\x88\x87`@Q` \x01a\"&\x93\x92\x91\x90a)JV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x96P\x86\x80Q\x90` \x01 \x93P\x83`@Q` \x01a\"T\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x91P_[a\"u\x8A`\xFF\x8D\x16a'\xDAV[\x81\x10\x15a\"\xD6W\x82\x81\x81Q\x81\x10a\"\x8EWa\"\x8Ea(\xA1V[\x01` \x01Q`\x01`\x01`\xF8\x1B\x03\x19\x16\x84a\"\xA8\x83\x8Da'\xC7V[\x81Q\x81\x10a\"\xB8Wa\"\xB8a(\xA1V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a\"hV[P\x91\x9B\x9APPPPPPPPPPPV[_\x80\x80[\x83Q\x81\x10\x15a#GW\x83\x81\x81Q\x81\x10a#\x06Wa#\x06a(\xA1V[` \x02` \x01\x01Q`\xFF\x16\x81`\x08a#\x1E\x91\x90a)}V[a#)\x90`\x02a*wV[a#3\x91\x90a)}V[a#=\x90\x83a'\xC7V[\x91P`\x01\x01a\"\xEBV[P\x92\x91PPV[``\x82a#cWa#^\x82a#\xADV[a#\xA6V[\x81Q\x15\x80\x15a#zWP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a#\xA3W`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\x05\xF9V[P\x80[\x93\x92PPPV[\x80Q\x15a#\xBDW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a#\xECW__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a$\x02W__\xFD[a$\x0B\x83a#\xD6V[\x94` \x93\x90\x93\x015\x93PPPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@\x80Q\x90\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a$PWa$Pa$\x19V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a$\x7FWa$\x7Fa$\x19V[`@R\x91\x90PV[_`\x80\x82\x84\x03\x12\x15a$\x97W__\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a$\xBAWa$\xBAa$\x19V[`@\x90\x81R\x835\x82R` \x80\x85\x015\x90\x83\x01R\x83\x81\x015\x90\x82\x01R``\x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_`@\x82\x84\x03\x12\x15a$\xF8W__\xFD[a%\0a$-V[\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[____a\x01 \x85\x87\x03\x12\x15a%+W__\xFD[a%5\x86\x86a$\x87V[\x93Pa%D\x86`\x80\x87\x01a$\xE8V[\x92Pa%S\x86`\xC0\x87\x01a$\xE8V[\x91Pa\x01\0\x85\x015a\xFF\xFF\x81\x16\x81\x14a%jW__\xFD[\x93\x96\x92\x95P\x90\x93PPV[_` \x82\x84\x03\x12\x15a%\x85W__\xFD[a#\xA6\x82a#\xD6V[__`@\x83\x85\x03\x12\x15a%\x9FW__\xFD[a%\xA8\x83a#\xD6V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%\xC3W__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a%\xD3W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%\xEDWa%\xEDa$\x19V[a&\0`\x1F\x82\x01`\x1F\x19\x16` \x01a$VV[\x81\x81R\x86` \x83\x85\x01\x01\x11\x15a&\x14W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92\x90PV[___a\x01\0\x84\x86\x03\x12\x15a&FW__\xFD[a&P\x85\x85a$\x87V[\x92Pa&_\x85`\x80\x86\x01a$\xE8V[\x91Pa&n\x85`\xC0\x86\x01a$\xE8V[\x90P\x92P\x92P\x92V[_`\x80\x82\x84\x03\x12\x15a&\x87W__\xFD[a#\xA6\x83\x83a$\x87V[__`@\x83\x85\x03\x12\x15a&\xA2W__\xFD[a&\xAB\x83a#\xD6V[\x91Pa&\xB9` \x84\x01a#\xD6V[\x90P\x92P\x92\x90PV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[_` \x82\x84\x03\x12\x15a'\x07W__\xFD[P5\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a'!W__\xFD[a'*\x85a#\xD6V[\x93Pa'8` \x86\x01a#\xD6V[\x92P`@\x85\x015\x91Pa'M``\x86\x01a#\xD6V[\x90P\x92\x95\x91\x94P\x92PV[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x82\x81R`@\x81\x01`\x03\x83\x10a'\x8FWcNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x82` \x83\x01R\x93\x92PPPV[_` \x82\x84\x03\x12\x15a'\xACW__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x1FvWa\x1Fva'\xB3V[\x81\x81\x03\x81\x81\x11\x15a\x1FvWa\x1Fva'\xB3V[\x82Q\x81R` \x80\x84\x01Q\x81\x83\x01R`@\x80\x85\x01Q\x90\x83\x01R``\x80\x85\x01Q\x90\x83\x01R\x82Q`\x80\x83\x01R\x82\x01Q`\xA0\x82\x01R`\xC0\x81\x01a#\xA6V[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a(Ra(L\x83\x86a('V[\x84a('V[\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a(\x88WcNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[P\x06\x90V[cNH{q`\xE0\x1B_R`\x01`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_a#\xA6\x82\x84a('V[_a(\xCB\x82\x85a('V[_\x81R`\x01`\x01`\xF8\x1B\x03\x19\x93\x90\x93\x16`\x01\x84\x01RPP`\x02\x01\x91\x90PV[_a(\xF5\x82\x84a('V[_\x81R`\x01\x01\x93\x92PPPV[_a)\r\x82\x85a('V[`\x01`\x01`\xF0\x1B\x03\x19\x93\x90\x93\x16\x83RPP`\x02\x01\x91\x90PV[_a)1\x82\x85a('V[`\x01`\x01`\xF8\x1B\x03\x19\x93\x90\x93\x16\x83RPP`\x01\x01\x91\x90PV[_a)U\x82\x86a('V[`\x01`\x01`\xF8\x1B\x03\x19\x94\x90\x94\x16\x84RPP`\x01`\x01`\xF0\x1B\x03\x19\x16`\x01\x82\x01R`\x03\x01\x91\x90PV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x1FvWa\x1Fva'\xB3V[`\x01\x81[`\x01\x84\x11\x15a)\xCFW\x80\x85\x04\x81\x11\x15a)\xB3Wa)\xB3a'\xB3V[`\x01\x84\x16\x15a)\xC1W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a)\x98V[\x93P\x93\x91PPV[_\x82a)\xE5WP`\x01a\x1FvV[\x81a)\xF1WP_a\x1FvV[\x81`\x01\x81\x14a*\x07W`\x02\x81\x14a*\x11Wa*-V[`\x01\x91PPa\x1FvV[`\xFF\x84\x11\x15a*\"Wa*\"a'\xB3V[PP`\x01\x82\x1Ba\x1FvV[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a*PWP\x81\x81\na\x1FvV[a*\\_\x19\x84\x84a)\x94V[\x80_\x19\x04\x82\x11\x15a*oWa*oa'\xB3V[\x02\x93\x92PPPV[_a#\xA6\x83\x83a)\xD7V\xFEBLS_SIG_BN254G1_XMD:KECCAK_NCTH_NUL_0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDG6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08#\0\n",
2214    );
2215    /// The runtime bytecode of the contract, as deployed on the network.
2216    ///
2217    /// ```text
2218    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
2219    /// ```
2220    #[rustfmt::skip]
2221    #[allow(clippy::all)]
2222    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
2223        b"`\x80`@R`\x046\x10a\x01aW_5`\xE0\x1C\x80c\x9B0\xA5\xE6\x11a\0\xCDW\x80c\xB5p\x0Eh\x11a\0\x87W\x80c\xC6H\x14\xDD\x11a\0bW\x80c\xC6H\x14\xDD\x14a\x04|W\x80c\xF2\xFD\xE3\x8B\x14a\x04\xB2W\x80c\xFAR\xC7\xD8\x14a\x04\xD1W\x80c\xFC\x0CTj\x14a\x05\x14W__\xFD[\x80c\xB5p\x0Eh\x14a\x04\x13W\x80c\xB5\xEC\xB3D\x14a\x042W\x80c\xBE 0\x94\x14a\x04]W__\xFD[\x80c\x9B0\xA5\xE6\x14a\x02\xF3W\x80c\x9E\x9A\x8F1\x14a\x03\x12W\x80c\xA2\xD7\x8D\xD5\x14a\x03'W\x80c\xA3\x06j\xAB\x14a\x03yW\x80c\xAD<\xB1\xCC\x14a\x03\x98W\x80c\xB3\xE6\xEB\xD5\x14a\x03\xD5W__\xFD[\x80cO\x1E\xF2\x86\x11a\x01\x1EW\x80cO\x1E\xF2\x86\x14a\x025W\x80cR\xD1\x90-\x14a\x02HW\x80cUD\xC2\xF1\x14a\x02\\W\x80cj\x91\x1C\xCF\x14a\x02{W\x80cqP\x18\xA6\x14a\x02\x8FW\x80c\x8D\xA5\xCB[\x14a\x02\xA3W__\xFD[\x80c\x02n@+\x14a\x01eW\x80c\r\x8En,\x14a\x01\x86W\x80c\x13\xB9\x05z\x14a\x01\xB6W\x80c!@\xFE\xCD\x14a\x01\xD5W\x80c>\x9D\xF9\xB5\x14a\x01\xF4W\x80cM\x99\xDD\x16\x14a\x02\x16W[__\xFD[4\x80\x15a\x01pW__\xFD[Pa\x01\x84a\x01\x7F6`\x04a#\xF1V[a\x053V[\0[4\x80\x15a\x01\x91W__\xFD[P`@\x80Q`\x01\x81R_` \x82\x01\x81\x90R\x91\x81\x01\x91\x90\x91R``\x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xC1W__\xFD[Pa\x01\x84a\x01\xD06`\x04a%\x17V[a\x06\xD6V[4\x80\x15a\x01\xE0W__\xFD[Pa\x01\x84a\x01\xEF6`\x04a%uV[a\x08iV[4\x80\x15a\x01\xFFW__\xFD[Pa\x02\x08_T\x81V[`@Q\x90\x81R` \x01a\x01\xADV[4\x80\x15a\x02!W__\xFD[Pa\x01\x84a\x0206`\x04a#\xF1V[a\t\x8AV[a\x01\x84a\x02C6`\x04a%\x8EV[a\x0B<V[4\x80\x15a\x02SW__\xFD[Pa\x02\x08a\x0B[V[4\x80\x15a\x02gW__\xFD[Pa\x01\x84a\x02v6`\x04a&3V[a\x0BvV[4\x80\x15a\x02\x86W__\xFD[Pa\x01\x84a\x0C?V[4\x80\x15a\x02\x9AW__\xFD[Pa\x01\x84a\x0C\xCDV[4\x80\x15a\x02\xAEW__\xFD[P\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\xADV[4\x80\x15a\x02\xFEW__\xFD[Pa\x02\x08a\x03\r6`\x04a&wV[a\x0C\xEEV[4\x80\x15a\x03\x1DW__\xFD[Pa\x02\x08`\x08T\x81V[4\x80\x15a\x032W__\xFD[Pa\x03da\x03A6`\x04a&\x91V[`\x07` \x90\x81R_\x92\x83R`@\x80\x84 \x90\x91R\x90\x82R\x90 \x80T`\x01\x90\x91\x01T\x82V[`@\x80Q\x92\x83R` \x83\x01\x91\x90\x91R\x01a\x01\xADV[4\x80\x15a\x03\x84W__\xFD[Pa\x01\x84a\x03\x936`\x04a%uV[a\rHV[4\x80\x15a\x03\xA3W__\xFD[Pa\x03\xC8`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d\x03R\xE3\x02\xE3`\xDC\x1B\x81RP\x81V[`@Qa\x01\xAD\x91\x90a&\xC2V[4\x80\x15a\x03\xE0W__\xFD[Pa\x04\x03a\x03\xEF6`\x04a&\xF7V[`\x04` R_\x90\x81R`@\x90 T`\xFF\x16\x81V[`@Q\x90\x15\x15\x81R` \x01a\x01\xADV[4\x80\x15a\x04\x1EW__\xFD[P`\x01Ta\x02\xDB\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[4\x80\x15a\x04=W__\xFD[Pa\x02\x08a\x04L6`\x04a%uV[`\x05` R_\x90\x81R`@\x90 T\x81V[4\x80\x15a\x04hW__\xFD[Pa\x01\x84a\x04w6`\x04a'\x0EV[a\x0EXV[4\x80\x15a\x04\x87W__\xFD[Pa\x02\x08a\x04\x966`\x04a&\x91V[`\x06` \x90\x81R_\x92\x83R`@\x80\x84 \x90\x91R\x90\x82R\x90 T\x81V[4\x80\x15a\x04\xBDW__\xFD[Pa\x01\x84a\x04\xCC6`\x04a%uV[a\x0F\x84V[4\x80\x15a\x04\xDCW__\xFD[Pa\x05\x06a\x04\xEB6`\x04a%uV[`\x03` R_\x90\x81R`@\x90 \x80T`\x01\x90\x91\x01T`\xFF\x16\x82V[`@Qa\x01\xAD\x92\x91\x90a'lV[4\x80\x15a\x05\x1FW__\xFD[P`\x02Ta\x02\xDB\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x05<\x82a\x0F\xC1V[3_\x82\x90\x03a\x05^W`@Qc\x1F* \x05`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02T`@Qcn\xB1v\x9F`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R0`$\x83\x01R_\x92\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xACW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xD0\x91\x90a'\x9CV[\x90P\x82\x81\x10\x15a\x06\x02W`@Qc\x05Ce\xBB`\xE3\x1B\x81R`\x04\x81\x01\x82\x90R`$\x81\x01\x84\x90R`D\x01[`@Q\x80\x91\x03\x90\xFD[`\x02Ta\x06\x1A\x90`\x01`\x01`\xA0\x1B\x03\x16\x830\x86a\x10BV[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\x03` R`@\x81 \x80T\x85\x92\x90a\x06A\x90\x84\x90a'\xC7V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R\x90\x81 \x80T\x85\x92\x90a\x06|\x90\x84\x90a'\xC7V[\x92PP\x81\x90UP\x83`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x7F\xE5T\x1Aka\x03\xD4\xFA~\x02\x1E\xD5O\xAD9\xC6o'\xA7k\xD1=7L\xF6$\n\xE6\xBD\x0B\xB7+\x85`@Qa\x06\xC8\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[3a\x06\xE0\x81a\x10\xE6V[a\x06\xE9\x84a\x113V[a\x06\xF2\x85a\x11\xC6V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x83\x16` \x82\x01R_\x91\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90Pa\x07$\x81\x85\x88a\x12\x02V[a'\x10\x83a\xFF\xFF\x16\x11\x15a\x07KW`@Qc\xDC\x81\xDB\x85`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x04_a\x07Y\x89a\x0C\xEEV[\x81R` \x01\x90\x81R` \x01_ _a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`@Q\x80`@\x01`@R\x80_\x81R` \x01`\x01`\x02\x81\x11\x15a\x07\xA0Wa\x07\xA0a'XV[\x90R`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x03` \x90\x81R`@\x90\x91 \x82Q\x81U\x90\x82\x01Q`\x01\x80\x83\x01\x80T\x90\x91`\xFF\x19\x90\x91\x16\x90\x83`\x02\x81\x11\x15a\x07\xE6Wa\x07\xE6a'XV[\x02\x17\x90UPP`@\x80Q\x88Q\x81R` \x80\x8A\x01Q\x81\x83\x01R\x89\x83\x01Q\x82\x84\x01R``\x80\x8B\x01Q\x90\x83\x01R\x88Q`\x80\x83\x01R\x88\x01Q`\xA0\x82\x01Ra\xFF\xFF\x86\x16`\xC0\x82\x01R\x90Q`\x01`\x01`\xA0\x1B\x03\x85\x16\x92P\x7F\xF6\xE85\x9CWR\x0BF\x964sk\xFC;\xB7\xEC\\\xBD\x1A\x0B\xD2\x8B\x10\xA8'W\x93\xBBs\x0By\x7F\x91\x81\x90\x03`\xE0\x01\x90\xA2PPPPPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x05` R`@\x81 T3\x91\x81\x90\x03a\x08\xA3W`@Qcy)\x8AS`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80B\x10\x15a\x08\xC4W`@QcZwCW`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R\x90\x81 T\x90\x81\x90\x03a\t\x0CW`@Qc\x06\x86\x82{`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x87\x85\x16\x84R\x90\x91R\x81 U`\x02Ta\tA\x91\x16\x84\x83a\x13\x0BV[\x82`\x01`\x01`\xA0\x1B\x03\x16\x7F\x7F\xCFS,\x15\xF0\xA6\xDB\x0B\xD6\xD0\xE08\xBE\xA7\x1D0\xD8\x08\xC7\xD9\x8C\xB3\xBFrh\xA9[\xF5\x08\x1Be\x82`@Qa\t|\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2PPPPV[a\t\x93\x82a\x0F\xC1V[3_\x82\x90\x03a\t\xB5W`@Qc\x1F* \x05`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x07` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R\x92\x90R T\x15a\t\xF8W`@Qc\xD4#\xA4\xF1`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R\x92\x90R T\x82\x81\x10\x15a\nAW`@Qc\x92fSQ`\xE0\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x05\xF9V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R`\x06` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R\x90\x81 \x80T\x85\x92\x90a\nw\x90\x84\x90a'\xDAV[\x92PP\x81\x90UP`@Q\x80`@\x01`@R\x80\x84\x81R` \x01`\x08TBa\n\x9D\x91\x90a'\xC7V[\x90R`\x01`\x01`\xA0\x1B\x03\x80\x86\x16_\x81\x81R`\x07` \x90\x81R`@\x80\x83 \x94\x88\x16\x83R\x93\x81R\x83\x82 \x85Q\x81U\x94\x81\x01Q`\x01\x90\x95\x01\x94\x90\x94U\x90\x81R`\x03\x90\x92R\x81 \x80T\x85\x92\x90a\n\xF0\x90\x84\x90a'\xDAV[\x92PP\x81\x90UP\x83`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x7FM\x10\xBD\x04\x97u\xC7{\xD7\xF2U\x19Z\xFB\xA5\x08\x80(\xEC\xB3\xC7\xC2w\xD3\x93\xCC\xFFy4\xF2\xF9,\x85`@Qa\x06\xC8\x91\x81R` \x01\x90V[a\x0BDa\x13\x9AV[a\x0BM\x82a\x14@V[a\x0BW\x82\x82a\x14HV[PPV[_a\x0Bda\x15\tV[P_Q` a*\xC7_9_Q\x90_R\x90V[3a\x0B\x80\x81a\x0F\xC1V[a\x0B\x89\x83a\x113V[a\x0B\x92\x84a\x11\xC6V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x83\x16` \x82\x01R_\x91\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90Pa\x0B\xC4\x81\x84\x87a\x12\x02V[`\x01`\x04_a\x0B\xD2\x88a\x0C\xEEV[\x81R` \x01\x90\x81R` \x01_ _a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x81`\x01`\x01`\xA0\x1B\x03\x16\x7F\x80\xD8\xA4\xA1f3(\xA9\x98\xD4U[\xA2\x1D\x8B\xBAn\xF1Wj\x8C^\x9D'\xF9\xC5E\xF1\xA3\xD5+\x1D\x86\x86`@Qa\x0C0\x92\x91\x90a'\xEDV[`@Q\x80\x91\x03\x90\xA2PPPPPV[3a\x0CI\x81a\x0F\xC1V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x03` R`@\x90 `\x01\x01\x80T`\xFF\x19\x16`\x02\x17\x90U`\x08Ta\x0C{\x90Ba'\xC7V[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x81\x81R`\x05` \x90\x81R`@\x80\x83 \x94\x90\x94U`\x03\x90R\x82\x81 \x81\x90U\x91Q\x90\x91\x7F\xFB$0ST\xC8wb\xD5WHz\xE4\xA5d\xE8\xD0>\xCB\xB9\xA9}\xD8\xAF\xFF\x8E\x1Fo\xCA\xF0\xDD\x16\x91\xA2PV[a\x0C\xD5a\x15RV[`@Qc\x17\xD5\xC9e`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81_\x01Q\x82` \x01Q\x83`@\x01Q\x84``\x01Q`@Q` \x01a\r+\x94\x93\x92\x91\x90\x93\x84R` \x84\x01\x92\x90\x92R`@\x83\x01R``\x82\x01R`\x80\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x07` \x90\x81R`@\x80\x83 3\x80\x85R\x92R\x82 T\x90\x91\x81\x90\x03a\r\x8DW`@Qc\x06\x86\x82{`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x07` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R `\x01\x01TB\x10\x15a\r\xD5W`@QcZwCW`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16_\x90\x81R`\x07` \x90\x81R`@\x80\x83 \x86\x85\x16\x84R\x90\x91R\x81 \x81\x81U`\x01\x01U`\x02Ta\x0E\x10\x91\x16\x83\x83a\x13\x0BV[\x81`\x01`\x01`\xA0\x1B\x03\x16\x7F\x7F\xCFS,\x15\xF0\xA6\xDB\x0B\xD6\xD0\xE08\xBE\xA7\x1D0\xD8\x08\xC7\xD9\x8C\xB3\xBFrh\xA9[\xF5\x08\x1Be\x82`@Qa\x0EK\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2PPPV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x81\x15\x80\x15a\x0E\x9DWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x0E\xB9WP0;\x15[\x90P\x81\x15\x80\x15a\x0E\xC7WP\x80\x15[\x15a\x0E\xE5W`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x0F\x0FW\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x0F\x18\x86a\x15\xADV[a\x0F a\x15\xBEV[a\x0F(a\x15\xC6V[a\x0F3\x89\x89\x89a\x16\xCCV[\x83\x15a\x0FyW\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPPPPV[a\x0F\x8Ca\x15RV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x0F\xB5W`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x05\xF9V[a\x0F\xBE\x81a\x17wV[PV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x03` R`@\x81 `\x01\x01T`\xFF\x16\x90\x81`\x02\x81\x11\x15a\x0F\xF2Wa\x0F\xF2a'XV[\x03a\x10\x10W`@QcP\x8Ay?`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x81`\x02\x81\x11\x15a\x10$Wa\x10$a'XV[\x03a\x0BWW`@Qc\xEA\xB4\xA9c`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_`@Qc#\xB8r\xDD`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R\x82`D\x82\x01R` _`d\x83_\x8AZ\xF1\x91PP\x80`\x1F=\x11`\x01_Q\x14\x16\x15\x16\x15a\x10\x9BWP\x83;\x15=\x17\x15[\x80a\x10\xDFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01Rs\x15\x14\x90S\x94\xD1\x91T\x97\xD1\x94\x93\xD3W\xD1\x90RS\x11Q`b\x1B`D\x82\x01R`d\x01a\x05\xF9V[PPPPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x03` R`@\x81 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x11\x15Wa\x11\x15a'XV[\x14a\x0F\xBEW`@Qc\x13.~\xFB`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Q\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X](3\xE8Hy\xB9p\x91C\xE1\xF5\x93\xF0\0\0\x01\x11\x15\x80a\x11\x87WP\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X](3\xE8Hy\xB9p\x91C\xE1\xF5\x93\xF0\0\0\x01\x81` \x01Q\x10\x15[\x15a\x11\xA5W`@Qc\x06\xCFC\x8F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Q_\x03a\x0F\xBEW`@Qc\x06\xCFC\x8F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04_a\x11\xD2\x83a\x0C\xEEV[\x81R` \x81\x01\x91\x90\x91R`@\x01_ T`\xFF\x16\x15a\x0F\xBEW`@Qb\xDA\x8AW`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81Q` \x83\x01Q\x15\x90\x15\x16\x15a\x12+W`@Qc:\x13\x91\x99`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Q\x15\x80\x15a\x12<WP` \x81\x01Q\x15[\x80\x15a\x12JWP`@\x81\x01Q\x15[\x80\x15a\x12XWP``\x81\x01Q\x15[\x15a\x12vW`@Qc^Cb\xCD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x12\x7F\x82a\x17\xE7V[_`@Q\x80``\x01`@R\x80`$\x81R` \x01a*\x83`$\x919\x90P_\x84\x82`@Q` \x01a\x12\xAF\x92\x91\x90a(>V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P_a\x12\xCA\x82a\x18NV[\x90Pa\x12\xE7\x81\x85a\x12\xDA\x88a\x19;V[a\x12\xE2a\x19\xB2V[a\x1A\x7FV[a\x13\x03W`@Qb\xCE\xD3\xE5`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPPPV[_`@Qc\xA9\x05\x9C\xBB`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01R\x82`$\x82\x01R` _`D\x83_\x89Z\xF1\x91PP\x80`\x1F=\x11`\x01_Q\x14\x16\x15\x16\x15a\x13UWP\x82;\x15=\x17\x15[\x80a\x13\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x0F`$\x82\x01Rn\x15\x14\x90S\x94\xD1\x91T\x97\xD1\x90RS\x11Q`\x8A\x1B`D\x82\x01R`d\x01a\x05\xF9V[PPPPV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14\x80a\x14 WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16a\x14\x14_Q` a*\xC7_9_Q\x90_RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x14>W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[a\x0F\xBEa\x15RV[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\x14\xA2WP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x14\x9F\x91\x81\x01\x90a'\x9CV[`\x01[a\x14\xCAW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x05\xF9V[_Q` a*\xC7_9_Q\x90_R\x81\x14a\x14\xFAW`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x05\xF9V[a\x15\x04\x83\x83a\x1B.V[PPPV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x14>W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3a\x15\x84\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x14>W`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x05\xF9V[a\x15\xB5a\x1B\x83V[a\x0F\xBE\x81a\x1B\xCCV[a\x14>a\x1B\x83V[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x81\x15\x80\x15a\x16\x0BWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x16'WP0;\x15[\x90P\x81\x15\x80\x15a\x165WP\x80\x15[\x15a\x16SW`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x16}W\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[C_U\x83\x15a\x10\xDFW\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x16\xF3W`@Qc\xD9.#=`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x17\x1AW`@Qc\xD9.#=`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x80T`\x01`\x01`\xA0\x1B\x03\x80\x86\x16`\x01`\x01`\xA0\x1B\x03\x19\x92\x83\x16\x17\x90\x92U`\x01\x80T\x92\x85\x16\x92\x90\x91\x16\x91\x90\x91\x17\x90Ub\x02\xA3\0\x80\x82\x10\x15a\x17oW`@Qc\xB5~!\xDF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x08UPPV[\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x82\x17\x84U`@Q\x92\x16\x91\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPPV[\x80Q` \x82\x01Q_\x91_Q` a*\xA7_9_Q\x90_R\x91\x15\x90\x15\x16\x15a\x18\rWPPPV[\x82Q` \x84\x01Q\x82`\x03\x84\x85\x85\x86\t\x85\t\x08\x83\x82\x83\t\x14\x83\x82\x10\x84\x84\x10\x16\x16\x93PPP\x81a\x15\x04W`@Qc'\x9E4S`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R_a\x18k\x83a\x1B\xD4V[\x90P_Q` a*\xA7_9_Q\x90_R`\x03_\x82\x84\x85\t\x90P\x82\x80a\x18\x92Wa\x18\x92a(ZV[\x84\x82\t\x90P\x82\x80a\x18\xA5Wa\x18\xA5a(ZV[\x82\x82\x08\x90P__a\x18\xB5\x83a\x1D\xDDV[\x92P\x90P[\x80a\x19\x1EW\x84\x80a\x18\xCDWa\x18\xCDa(ZV[`\x01\x87\x08\x95P\x84\x80a\x18\xE1Wa\x18\xE1a(ZV[\x86\x87\t\x92P\x84\x80a\x18\xF4Wa\x18\xF4a(ZV[\x86\x84\t\x92P\x84\x80a\x19\x07Wa\x19\x07a(ZV[\x84\x84\x08\x92Pa\x19\x15\x83a\x1D\xDDV[\x92P\x90Pa\x18\xBAV[P`@\x80Q\x80\x82\x01\x90\x91R\x94\x85R` \x85\x01RP\x91\x94\x93PPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R\x81Q` \x83\x01Q\x15\x90\x15\x16\x15a\x19bWP\x90V[`@Q\x80`@\x01`@R\x80\x83_\x01Q\x81R` \x01_Q` a*\xA7_9_Q\x90_R\x84` \x01Qa\x19\x93\x91\x90a(nV[a\x19\xAA\x90_Q` a*\xA7_9_Q\x90_Ra'\xDAV[\x90R\x92\x91PPV[a\x19\xD9`@Q\x80`\x80\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[`@Q\x80`\x80\x01`@R\x80\x7F\x18\0\xDE\xEF\x12\x1F\x1EvBj\0f^\\DygC\"\xD4\xF7^\xDA\xDDF\xDE\xBD\\\xD9\x92\xF6\xED\x81R` \x01\x7F\x19\x8E\x93\x93\x92\rH:r`\xBF\xB71\xFB]%\xF1\xAAI35\xA9\xE7\x12\x97\xE4\x85\xB7\xAE\xF3\x12\xC2\x81R` \x01\x7F\x12\xC8^\xA5\xDB\x8Cm\xEBJ\xABq\x80\x8D\xCB@\x8F\xE3\xD1\xE7i\x0CC\xD3{L\xE6\xCC\x01f\xFA}\xAA\x81R` \x01\x7F\t\x06\x89\xD0X_\xF0u\xEC\x9E\x99\xADi\x0C3\x95\xBCK13p\xB3\x8E\xF3U\xAC\xDA\xDC\xD1\"\x97[\x81RP\x90P\x90V[___`@Q\x87Q\x81R` \x88\x01Q` \x82\x01R` \x87\x01Q`@\x82\x01R\x86Q``\x82\x01R``\x87\x01Q`\x80\x82\x01R`@\x87\x01Q`\xA0\x82\x01R\x85Q`\xC0\x82\x01R` \x86\x01Q`\xE0\x82\x01R` \x85\x01Qa\x01\0\x82\x01R\x84Qa\x01 \x82\x01R``\x85\x01Qa\x01@\x82\x01R`@\x85\x01Qa\x01`\x82\x01R` _a\x01\x80\x83`\x08Z\xFA\x91PP_Q\x91P\x80a\x1B\"W`@Qc\xC2\x063O`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P\x15\x15\x95\x94PPPPPV[a\x1B7\x82a\x1E\xA5V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\x1B{Wa\x15\x04\x82\x82a\x1F\x08V[a\x0BWa\x1F|V[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0T`\x01`@\x1B\x90\x04`\xFF\x16a\x14>W`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0F\x8Ca\x1B\x83V[__a\x1B\xDF\x83a\x1F\x9BV[\x80Q\x90\x91P`0\x81\x14a\x1B\xF4Wa\x1B\xF4a(\x8DV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C\x0EWa\x1C\x0Ea$\x19V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1C8W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_[\x82\x81\x10\x15a\x1C\xA7W\x83`\x01a\x1CR\x83\x86a'\xDAV[a\x1C\\\x91\x90a'\xDAV[\x81Q\x81\x10a\x1ClWa\x1Cla(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x82\x82\x81Q\x81\x10a\x1C\x89Wa\x1C\x89a(\xA1V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a\x1C=V[P`@\x80Q`\x1F\x80\x82Ra\x04\0\x82\x01\x90\x92R_\x90\x82` \x82\x01a\x03\xE0\x806\x837\x01\x90PP\x90P_[\x82\x81\x10\x15a\x1D7W\x83\x81a\x1C\xE3\x85\x88a'\xDAV[a\x1C\xED\x91\x90a'\xC7V[\x81Q\x81\x10a\x1C\xFDWa\x1C\xFDa(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B`\xF8\x1C\x82\x82\x81Q\x81\x10a\x1D\x1DWa\x1D\x1Da(\xA1V[`\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a\x1C\xCFV[P_a\x1DB\x82a\"\xE7V[\x90Pa\x01\0_Q` a*\xA7_9_Q\x90_R_a\x1D`\x86\x89a'\xDAV[\x90P_[\x81\x81\x10\x15a\x1D\xCDW_\x88`\x01a\x1Dz\x84\x86a'\xDAV[a\x1D\x84\x91\x90a'\xDAV[\x81Q\x81\x10a\x1D\x94Wa\x1D\x94a(\xA1V[\x01` \x01Q`\xF8\x1C\x90P\x83\x80a\x1D\xACWa\x1D\xACa(ZV[\x85\x87\t\x95P\x83\x80a\x1D\xBFWa\x1D\xBFa(ZV[\x81\x87\x08\x95PP`\x01\x01a\x1DdV[P\x92\x9A\x99PPPPPPPPPPV[_____\x7F\x0C\x19\x13\x9C\xB8Lh\nn\x14\x11m\xA0`V\x17e\xE0Z\xA4Z\x1Cr\xA3O\x08#\x05\xB6\x1F?R\x90P__Q` a*\xA7_9_Q\x90_R\x90P`@Q` \x81R` \x80\x82\x01R` `@\x82\x01R\x87``\x82\x01R\x82`\x80\x82\x01R\x81`\xA0\x82\x01R` _`\xC0\x83`\x05Z\xFA\x94PP_Q\x92P\x83a\x1EkW`@Qc\x0C\x9D>\x99`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80`\x01\x84\x90\x1B\x11\x15a\x1E\x84Wa\x1E\x81\x83\x82a'\xDAV[\x92P[\x80\x80a\x1E\x92Wa\x1E\x92a(ZV[\x83\x84\t\x96\x90\x96\x14\x96\x91\x95P\x90\x93PPPPV[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x1E\xDAW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x05\xF9V[_Q` a*\xC7_9_Q\x90_R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``__\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\x1F$\x91\x90a(\xB5V[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x1F\\W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x1FaV[``\x91P[P\x91P\x91Pa\x1Fq\x85\x83\x83a#NV[\x92PPP[\x92\x91PPV[4\x15a\x14>W`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q`0\x80\x82R``\x82\x81\x01\x90\x93R\x90` \x90`\x01`\xF9\x1B\x90_\x90\x84` \x82\x01\x81\x806\x837\x01\x90PP\x90P\x80\x86`@Q` \x01a\x1F\xDB\x92\x91\x90a(>V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P\x80\x84`\xF8\x1B`@Q` \x01a \x02\x92\x91\x90a(\xC0V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P\x80`@Q` \x01a $\x91\x90a(\xEAV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90R\x91Pa\x01\x01`\xF0\x1B\x90a N\x90\x83\x90\x83\x90` \x01a)\x02V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x82\x82R\x80Q` \x91\x82\x01 \x81\x84\x01\x81\x90R`\x01`\xF8\x1B\x84\x84\x01R`\x01`\x01`\xF0\x1B\x03\x19\x85\x16`A\x85\x01R\x82Q`#\x81\x86\x03\x01\x81R`C\x90\x94\x01\x90\x92R\x82Q\x90\x83\x01 \x91\x93P\x90_`\xFF\x88\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \xBEWa \xBEa$\x19V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a \xE8W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_\x82`@Q` \x01a \xFF\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x90P_[\x81Q\x81\x10\x15a!iW\x81\x81\x81Q\x81\x10a!.Wa!.a(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x83\x82\x81Q\x81\x10a!KWa!Ka(\xA1V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a!\x13V[P_\x84`@Q` \x01a!~\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R` \x83\x01\x90\x91R_\x80\x83R\x91\x98P\x91P[\x89\x81\x10\x15a\"\x10W_\x83\x82\x81Q\x81\x10a!\xB7Wa!\xB7a(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x83\x83\x81Q\x81\x10a!\xD4Wa!\xD4a(\xA1V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x18\x90P\x88\x81`@Q` \x01a!\xF5\x92\x91\x90a)&V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x98PP`\x01\x01a!\x9CV[P\x86\x88\x87`@Q` \x01a\"&\x93\x92\x91\x90a)JV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x96P\x86\x80Q\x90` \x01 \x93P\x83`@Q` \x01a\"T\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x91P_[a\"u\x8A`\xFF\x8D\x16a'\xDAV[\x81\x10\x15a\"\xD6W\x82\x81\x81Q\x81\x10a\"\x8EWa\"\x8Ea(\xA1V[\x01` \x01Q`\x01`\x01`\xF8\x1B\x03\x19\x16\x84a\"\xA8\x83\x8Da'\xC7V[\x81Q\x81\x10a\"\xB8Wa\"\xB8a(\xA1V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a\"hV[P\x91\x9B\x9APPPPPPPPPPPV[_\x80\x80[\x83Q\x81\x10\x15a#GW\x83\x81\x81Q\x81\x10a#\x06Wa#\x06a(\xA1V[` \x02` \x01\x01Q`\xFF\x16\x81`\x08a#\x1E\x91\x90a)}V[a#)\x90`\x02a*wV[a#3\x91\x90a)}V[a#=\x90\x83a'\xC7V[\x91P`\x01\x01a\"\xEBV[P\x92\x91PPV[``\x82a#cWa#^\x82a#\xADV[a#\xA6V[\x81Q\x15\x80\x15a#zWP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a#\xA3W`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\x05\xF9V[P\x80[\x93\x92PPPV[\x80Q\x15a#\xBDW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a#\xECW__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a$\x02W__\xFD[a$\x0B\x83a#\xD6V[\x94` \x93\x90\x93\x015\x93PPPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@\x80Q\x90\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a$PWa$Pa$\x19V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a$\x7FWa$\x7Fa$\x19V[`@R\x91\x90PV[_`\x80\x82\x84\x03\x12\x15a$\x97W__\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a$\xBAWa$\xBAa$\x19V[`@\x90\x81R\x835\x82R` \x80\x85\x015\x90\x83\x01R\x83\x81\x015\x90\x82\x01R``\x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_`@\x82\x84\x03\x12\x15a$\xF8W__\xFD[a%\0a$-V[\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[____a\x01 \x85\x87\x03\x12\x15a%+W__\xFD[a%5\x86\x86a$\x87V[\x93Pa%D\x86`\x80\x87\x01a$\xE8V[\x92Pa%S\x86`\xC0\x87\x01a$\xE8V[\x91Pa\x01\0\x85\x015a\xFF\xFF\x81\x16\x81\x14a%jW__\xFD[\x93\x96\x92\x95P\x90\x93PPV[_` \x82\x84\x03\x12\x15a%\x85W__\xFD[a#\xA6\x82a#\xD6V[__`@\x83\x85\x03\x12\x15a%\x9FW__\xFD[a%\xA8\x83a#\xD6V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%\xC3W__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a%\xD3W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%\xEDWa%\xEDa$\x19V[a&\0`\x1F\x82\x01`\x1F\x19\x16` \x01a$VV[\x81\x81R\x86` \x83\x85\x01\x01\x11\x15a&\x14W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92\x90PV[___a\x01\0\x84\x86\x03\x12\x15a&FW__\xFD[a&P\x85\x85a$\x87V[\x92Pa&_\x85`\x80\x86\x01a$\xE8V[\x91Pa&n\x85`\xC0\x86\x01a$\xE8V[\x90P\x92P\x92P\x92V[_`\x80\x82\x84\x03\x12\x15a&\x87W__\xFD[a#\xA6\x83\x83a$\x87V[__`@\x83\x85\x03\x12\x15a&\xA2W__\xFD[a&\xAB\x83a#\xD6V[\x91Pa&\xB9` \x84\x01a#\xD6V[\x90P\x92P\x92\x90PV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[_` \x82\x84\x03\x12\x15a'\x07W__\xFD[P5\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a'!W__\xFD[a'*\x85a#\xD6V[\x93Pa'8` \x86\x01a#\xD6V[\x92P`@\x85\x015\x91Pa'M``\x86\x01a#\xD6V[\x90P\x92\x95\x91\x94P\x92PV[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x82\x81R`@\x81\x01`\x03\x83\x10a'\x8FWcNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x82` \x83\x01R\x93\x92PPPV[_` \x82\x84\x03\x12\x15a'\xACW__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x1FvWa\x1Fva'\xB3V[\x81\x81\x03\x81\x81\x11\x15a\x1FvWa\x1Fva'\xB3V[\x82Q\x81R` \x80\x84\x01Q\x81\x83\x01R`@\x80\x85\x01Q\x90\x83\x01R``\x80\x85\x01Q\x90\x83\x01R\x82Q`\x80\x83\x01R\x82\x01Q`\xA0\x82\x01R`\xC0\x81\x01a#\xA6V[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a(Ra(L\x83\x86a('V[\x84a('V[\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a(\x88WcNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[P\x06\x90V[cNH{q`\xE0\x1B_R`\x01`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_a#\xA6\x82\x84a('V[_a(\xCB\x82\x85a('V[_\x81R`\x01`\x01`\xF8\x1B\x03\x19\x93\x90\x93\x16`\x01\x84\x01RPP`\x02\x01\x91\x90PV[_a(\xF5\x82\x84a('V[_\x81R`\x01\x01\x93\x92PPPV[_a)\r\x82\x85a('V[`\x01`\x01`\xF0\x1B\x03\x19\x93\x90\x93\x16\x83RPP`\x02\x01\x91\x90PV[_a)1\x82\x85a('V[`\x01`\x01`\xF8\x1B\x03\x19\x93\x90\x93\x16\x83RPP`\x01\x01\x91\x90PV[_a)U\x82\x86a('V[`\x01`\x01`\xF8\x1B\x03\x19\x94\x90\x94\x16\x84RPP`\x01`\x01`\xF0\x1B\x03\x19\x16`\x01\x82\x01R`\x03\x01\x91\x90PV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x1FvWa\x1Fva'\xB3V[`\x01\x81[`\x01\x84\x11\x15a)\xCFW\x80\x85\x04\x81\x11\x15a)\xB3Wa)\xB3a'\xB3V[`\x01\x84\x16\x15a)\xC1W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a)\x98V[\x93P\x93\x91PPV[_\x82a)\xE5WP`\x01a\x1FvV[\x81a)\xF1WP_a\x1FvV[\x81`\x01\x81\x14a*\x07W`\x02\x81\x14a*\x11Wa*-V[`\x01\x91PPa\x1FvV[`\xFF\x84\x11\x15a*\"Wa*\"a'\xB3V[PP`\x01\x82\x1Ba\x1FvV[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a*PWP\x81\x81\na\x1FvV[a*\\_\x19\x84\x84a)\x94V[\x80_\x19\x04\x82\x11\x15a*oWa*oa'\xB3V[\x02\x93\x92PPPV[_a#\xA6\x83\x83a)\xD7V\xFEBLS_SIG_BN254G1_XMD:KECCAK_NCTH_NUL_0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDG6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08#\0\n",
2224    );
2225    #[derive(serde::Serialize, serde::Deserialize)]
2226    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2227    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2228    #[derive(Clone)]
2229    pub struct ValidatorStatus(u8);
2230    const _: () = {
2231        use alloy::sol_types as alloy_sol_types;
2232        #[automatically_derived]
2233        impl alloy_sol_types::private::SolTypeValue<ValidatorStatus> for u8 {
2234            #[inline]
2235            fn stv_to_tokens(
2236                &self,
2237            ) -> <alloy::sol_types::sol_data::Uint<
2238                8,
2239            > as alloy_sol_types::SolType>::Token<'_> {
2240                alloy_sol_types::private::SolTypeValue::<
2241                    alloy::sol_types::sol_data::Uint<8>,
2242                >::stv_to_tokens(self)
2243            }
2244            #[inline]
2245            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2246                <alloy::sol_types::sol_data::Uint<
2247                    8,
2248                > as alloy_sol_types::SolType>::tokenize(self)
2249                    .0
2250            }
2251            #[inline]
2252            fn stv_abi_encode_packed_to(
2253                &self,
2254                out: &mut alloy_sol_types::private::Vec<u8>,
2255            ) {
2256                <alloy::sol_types::sol_data::Uint<
2257                    8,
2258                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
2259            }
2260            #[inline]
2261            fn stv_abi_packed_encoded_size(&self) -> usize {
2262                <alloy::sol_types::sol_data::Uint<
2263                    8,
2264                > as alloy_sol_types::SolType>::abi_encoded_size(self)
2265            }
2266        }
2267        impl ValidatorStatus {
2268            /// The Solidity type name.
2269            pub const NAME: &'static str = stringify!(@ name);
2270            /// Convert from the underlying value type.
2271            #[inline]
2272            pub const fn from_underlying(value: u8) -> Self {
2273                Self(value)
2274            }
2275            /// Return the underlying value.
2276            #[inline]
2277            pub const fn into_underlying(self) -> u8 {
2278                self.0
2279            }
2280            /// Return the single encoding of this value, delegating to the
2281            /// underlying type.
2282            #[inline]
2283            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
2284                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
2285            }
2286            /// Return the packed encoding of this value, delegating to the
2287            /// underlying type.
2288            #[inline]
2289            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
2290                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
2291            }
2292        }
2293        #[automatically_derived]
2294        impl From<u8> for ValidatorStatus {
2295            fn from(value: u8) -> Self {
2296                Self::from_underlying(value)
2297            }
2298        }
2299        #[automatically_derived]
2300        impl From<ValidatorStatus> for u8 {
2301            fn from(value: ValidatorStatus) -> Self {
2302                value.into_underlying()
2303            }
2304        }
2305        #[automatically_derived]
2306        impl alloy_sol_types::SolType for ValidatorStatus {
2307            type RustType = u8;
2308            type Token<'a> = <alloy::sol_types::sol_data::Uint<
2309                8,
2310            > as alloy_sol_types::SolType>::Token<'a>;
2311            const SOL_NAME: &'static str = Self::NAME;
2312            const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
2313                8,
2314            > as alloy_sol_types::SolType>::ENCODED_SIZE;
2315            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
2316                8,
2317            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2318            #[inline]
2319            fn valid_token(token: &Self::Token<'_>) -> bool {
2320                Self::type_check(token).is_ok()
2321            }
2322            #[inline]
2323            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
2324                <alloy::sol_types::sol_data::Uint<
2325                    8,
2326                > as alloy_sol_types::SolType>::type_check(token)
2327            }
2328            #[inline]
2329            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2330                <alloy::sol_types::sol_data::Uint<
2331                    8,
2332                > as alloy_sol_types::SolType>::detokenize(token)
2333            }
2334        }
2335        #[automatically_derived]
2336        impl alloy_sol_types::EventTopic for ValidatorStatus {
2337            #[inline]
2338            fn topic_preimage_length(rust: &Self::RustType) -> usize {
2339                <alloy::sol_types::sol_data::Uint<
2340                    8,
2341                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
2342            }
2343            #[inline]
2344            fn encode_topic_preimage(
2345                rust: &Self::RustType,
2346                out: &mut alloy_sol_types::private::Vec<u8>,
2347            ) {
2348                <alloy::sol_types::sol_data::Uint<
2349                    8,
2350                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
2351            }
2352            #[inline]
2353            fn encode_topic(
2354                rust: &Self::RustType,
2355            ) -> alloy_sol_types::abi::token::WordToken {
2356                <alloy::sol_types::sol_data::Uint<
2357                    8,
2358                > as alloy_sol_types::EventTopic>::encode_topic(rust)
2359            }
2360        }
2361    };
2362    #[derive(serde::Serialize, serde::Deserialize)]
2363    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2364    /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`.
2365```solidity
2366error AddressEmptyCode(address target);
2367```*/
2368    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2369    #[derive(Clone)]
2370    pub struct AddressEmptyCode {
2371        #[allow(missing_docs)]
2372        pub target: alloy::sol_types::private::Address,
2373    }
2374    #[allow(
2375        non_camel_case_types,
2376        non_snake_case,
2377        clippy::pub_underscore_fields,
2378        clippy::style
2379    )]
2380    const _: () = {
2381        use alloy::sol_types as alloy_sol_types;
2382        #[doc(hidden)]
2383        #[allow(dead_code)]
2384        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2385        #[doc(hidden)]
2386        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2387        #[cfg(test)]
2388        #[allow(dead_code, unreachable_patterns)]
2389        fn _type_assertion(
2390            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2391        ) {
2392            match _t {
2393                alloy_sol_types::private::AssertTypeEq::<
2394                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2395                >(_) => {}
2396            }
2397        }
2398        #[automatically_derived]
2399        #[doc(hidden)]
2400        impl ::core::convert::From<AddressEmptyCode> for UnderlyingRustTuple<'_> {
2401            fn from(value: AddressEmptyCode) -> Self {
2402                (value.target,)
2403            }
2404        }
2405        #[automatically_derived]
2406        #[doc(hidden)]
2407        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressEmptyCode {
2408            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2409                Self { target: tuple.0 }
2410            }
2411        }
2412        #[automatically_derived]
2413        impl alloy_sol_types::SolError for AddressEmptyCode {
2414            type Parameters<'a> = UnderlyingSolTuple<'a>;
2415            type Token<'a> = <Self::Parameters<
2416                'a,
2417            > as alloy_sol_types::SolType>::Token<'a>;
2418            const SIGNATURE: &'static str = "AddressEmptyCode(address)";
2419            const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8];
2420            #[inline]
2421            fn new<'a>(
2422                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2423            ) -> Self {
2424                tuple.into()
2425            }
2426            #[inline]
2427            fn tokenize(&self) -> Self::Token<'_> {
2428                (
2429                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2430                        &self.target,
2431                    ),
2432                )
2433            }
2434            #[inline]
2435            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2436                <Self::Parameters<
2437                    '_,
2438                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2439                    .map(Self::new)
2440            }
2441        }
2442    };
2443    #[derive(serde::Serialize, serde::Deserialize)]
2444    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2445    /**Custom error with signature `BLSSigIsInfinity()` and selector `0x74272332`.
2446```solidity
2447error BLSSigIsInfinity();
2448```*/
2449    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2450    #[derive(Clone)]
2451    pub struct BLSSigIsInfinity;
2452    #[allow(
2453        non_camel_case_types,
2454        non_snake_case,
2455        clippy::pub_underscore_fields,
2456        clippy::style
2457    )]
2458    const _: () = {
2459        use alloy::sol_types as alloy_sol_types;
2460        #[doc(hidden)]
2461        #[allow(dead_code)]
2462        type UnderlyingSolTuple<'a> = ();
2463        #[doc(hidden)]
2464        type UnderlyingRustTuple<'a> = ();
2465        #[cfg(test)]
2466        #[allow(dead_code, unreachable_patterns)]
2467        fn _type_assertion(
2468            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2469        ) {
2470            match _t {
2471                alloy_sol_types::private::AssertTypeEq::<
2472                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2473                >(_) => {}
2474            }
2475        }
2476        #[automatically_derived]
2477        #[doc(hidden)]
2478        impl ::core::convert::From<BLSSigIsInfinity> for UnderlyingRustTuple<'_> {
2479            fn from(value: BLSSigIsInfinity) -> Self {
2480                ()
2481            }
2482        }
2483        #[automatically_derived]
2484        #[doc(hidden)]
2485        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BLSSigIsInfinity {
2486            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2487                Self
2488            }
2489        }
2490        #[automatically_derived]
2491        impl alloy_sol_types::SolError for BLSSigIsInfinity {
2492            type Parameters<'a> = UnderlyingSolTuple<'a>;
2493            type Token<'a> = <Self::Parameters<
2494                'a,
2495            > as alloy_sol_types::SolType>::Token<'a>;
2496            const SIGNATURE: &'static str = "BLSSigIsInfinity()";
2497            const SELECTOR: [u8; 4] = [116u8, 39u8, 35u8, 50u8];
2498            #[inline]
2499            fn new<'a>(
2500                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2501            ) -> Self {
2502                tuple.into()
2503            }
2504            #[inline]
2505            fn tokenize(&self) -> Self::Token<'_> {
2506                ()
2507            }
2508            #[inline]
2509            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2510                <Self::Parameters<
2511                    '_,
2512                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2513                    .map(Self::new)
2514            }
2515        }
2516    };
2517    #[derive(serde::Serialize, serde::Deserialize)]
2518    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2519    /**Custom error with signature `BLSSigVerificationFailed()` and selector `0x0ced3e50`.
2520```solidity
2521error BLSSigVerificationFailed();
2522```*/
2523    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2524    #[derive(Clone)]
2525    pub struct BLSSigVerificationFailed;
2526    #[allow(
2527        non_camel_case_types,
2528        non_snake_case,
2529        clippy::pub_underscore_fields,
2530        clippy::style
2531    )]
2532    const _: () = {
2533        use alloy::sol_types as alloy_sol_types;
2534        #[doc(hidden)]
2535        #[allow(dead_code)]
2536        type UnderlyingSolTuple<'a> = ();
2537        #[doc(hidden)]
2538        type UnderlyingRustTuple<'a> = ();
2539        #[cfg(test)]
2540        #[allow(dead_code, unreachable_patterns)]
2541        fn _type_assertion(
2542            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2543        ) {
2544            match _t {
2545                alloy_sol_types::private::AssertTypeEq::<
2546                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2547                >(_) => {}
2548            }
2549        }
2550        #[automatically_derived]
2551        #[doc(hidden)]
2552        impl ::core::convert::From<BLSSigVerificationFailed>
2553        for UnderlyingRustTuple<'_> {
2554            fn from(value: BLSSigVerificationFailed) -> Self {
2555                ()
2556            }
2557        }
2558        #[automatically_derived]
2559        #[doc(hidden)]
2560        impl ::core::convert::From<UnderlyingRustTuple<'_>>
2561        for BLSSigVerificationFailed {
2562            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2563                Self
2564            }
2565        }
2566        #[automatically_derived]
2567        impl alloy_sol_types::SolError for BLSSigVerificationFailed {
2568            type Parameters<'a> = UnderlyingSolTuple<'a>;
2569            type Token<'a> = <Self::Parameters<
2570                'a,
2571            > as alloy_sol_types::SolType>::Token<'a>;
2572            const SIGNATURE: &'static str = "BLSSigVerificationFailed()";
2573            const SELECTOR: [u8; 4] = [12u8, 237u8, 62u8, 80u8];
2574            #[inline]
2575            fn new<'a>(
2576                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2577            ) -> Self {
2578                tuple.into()
2579            }
2580            #[inline]
2581            fn tokenize(&self) -> Self::Token<'_> {
2582                ()
2583            }
2584            #[inline]
2585            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2586                <Self::Parameters<
2587                    '_,
2588                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2589                    .map(Self::new)
2590            }
2591        }
2592    };
2593    #[derive(serde::Serialize, serde::Deserialize)]
2594    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2595    /**Custom error with signature `BLSVKIsInfinity()` and selector `0xbc86c59a`.
2596```solidity
2597error BLSVKIsInfinity();
2598```*/
2599    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2600    #[derive(Clone)]
2601    pub struct BLSVKIsInfinity;
2602    #[allow(
2603        non_camel_case_types,
2604        non_snake_case,
2605        clippy::pub_underscore_fields,
2606        clippy::style
2607    )]
2608    const _: () = {
2609        use alloy::sol_types as alloy_sol_types;
2610        #[doc(hidden)]
2611        #[allow(dead_code)]
2612        type UnderlyingSolTuple<'a> = ();
2613        #[doc(hidden)]
2614        type UnderlyingRustTuple<'a> = ();
2615        #[cfg(test)]
2616        #[allow(dead_code, unreachable_patterns)]
2617        fn _type_assertion(
2618            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2619        ) {
2620            match _t {
2621                alloy_sol_types::private::AssertTypeEq::<
2622                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2623                >(_) => {}
2624            }
2625        }
2626        #[automatically_derived]
2627        #[doc(hidden)]
2628        impl ::core::convert::From<BLSVKIsInfinity> for UnderlyingRustTuple<'_> {
2629            fn from(value: BLSVKIsInfinity) -> Self {
2630                ()
2631            }
2632        }
2633        #[automatically_derived]
2634        #[doc(hidden)]
2635        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BLSVKIsInfinity {
2636            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2637                Self
2638            }
2639        }
2640        #[automatically_derived]
2641        impl alloy_sol_types::SolError for BLSVKIsInfinity {
2642            type Parameters<'a> = UnderlyingSolTuple<'a>;
2643            type Token<'a> = <Self::Parameters<
2644                'a,
2645            > as alloy_sol_types::SolType>::Token<'a>;
2646            const SIGNATURE: &'static str = "BLSVKIsInfinity()";
2647            const SELECTOR: [u8; 4] = [188u8, 134u8, 197u8, 154u8];
2648            #[inline]
2649            fn new<'a>(
2650                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2651            ) -> Self {
2652                tuple.into()
2653            }
2654            #[inline]
2655            fn tokenize(&self) -> Self::Token<'_> {
2656                ()
2657            }
2658            #[inline]
2659            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2660                <Self::Parameters<
2661                    '_,
2662                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2663                    .map(Self::new)
2664            }
2665        }
2666    };
2667    #[derive(serde::Serialize, serde::Deserialize)]
2668    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2669    /**Custom error with signature `BN254PairingProdFailed()` and selector `0xc206334f`.
2670```solidity
2671error BN254PairingProdFailed();
2672```*/
2673    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2674    #[derive(Clone)]
2675    pub struct BN254PairingProdFailed;
2676    #[allow(
2677        non_camel_case_types,
2678        non_snake_case,
2679        clippy::pub_underscore_fields,
2680        clippy::style
2681    )]
2682    const _: () = {
2683        use alloy::sol_types as alloy_sol_types;
2684        #[doc(hidden)]
2685        #[allow(dead_code)]
2686        type UnderlyingSolTuple<'a> = ();
2687        #[doc(hidden)]
2688        type UnderlyingRustTuple<'a> = ();
2689        #[cfg(test)]
2690        #[allow(dead_code, unreachable_patterns)]
2691        fn _type_assertion(
2692            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2693        ) {
2694            match _t {
2695                alloy_sol_types::private::AssertTypeEq::<
2696                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2697                >(_) => {}
2698            }
2699        }
2700        #[automatically_derived]
2701        #[doc(hidden)]
2702        impl ::core::convert::From<BN254PairingProdFailed> for UnderlyingRustTuple<'_> {
2703            fn from(value: BN254PairingProdFailed) -> Self {
2704                ()
2705            }
2706        }
2707        #[automatically_derived]
2708        #[doc(hidden)]
2709        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BN254PairingProdFailed {
2710            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2711                Self
2712            }
2713        }
2714        #[automatically_derived]
2715        impl alloy_sol_types::SolError for BN254PairingProdFailed {
2716            type Parameters<'a> = UnderlyingSolTuple<'a>;
2717            type Token<'a> = <Self::Parameters<
2718                'a,
2719            > as alloy_sol_types::SolType>::Token<'a>;
2720            const SIGNATURE: &'static str = "BN254PairingProdFailed()";
2721            const SELECTOR: [u8; 4] = [194u8, 6u8, 51u8, 79u8];
2722            #[inline]
2723            fn new<'a>(
2724                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2725            ) -> Self {
2726                tuple.into()
2727            }
2728            #[inline]
2729            fn tokenize(&self) -> Self::Token<'_> {
2730                ()
2731            }
2732            #[inline]
2733            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2734                <Self::Parameters<
2735                    '_,
2736                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2737                    .map(Self::new)
2738            }
2739        }
2740    };
2741    #[derive(serde::Serialize, serde::Deserialize)]
2742    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2743    /**Custom error with signature `BlsKeyAlreadyUsed()` and selector `0x01b514ae`.
2744```solidity
2745error BlsKeyAlreadyUsed();
2746```*/
2747    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2748    #[derive(Clone)]
2749    pub struct BlsKeyAlreadyUsed;
2750    #[allow(
2751        non_camel_case_types,
2752        non_snake_case,
2753        clippy::pub_underscore_fields,
2754        clippy::style
2755    )]
2756    const _: () = {
2757        use alloy::sol_types as alloy_sol_types;
2758        #[doc(hidden)]
2759        #[allow(dead_code)]
2760        type UnderlyingSolTuple<'a> = ();
2761        #[doc(hidden)]
2762        type UnderlyingRustTuple<'a> = ();
2763        #[cfg(test)]
2764        #[allow(dead_code, unreachable_patterns)]
2765        fn _type_assertion(
2766            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2767        ) {
2768            match _t {
2769                alloy_sol_types::private::AssertTypeEq::<
2770                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2771                >(_) => {}
2772            }
2773        }
2774        #[automatically_derived]
2775        #[doc(hidden)]
2776        impl ::core::convert::From<BlsKeyAlreadyUsed> for UnderlyingRustTuple<'_> {
2777            fn from(value: BlsKeyAlreadyUsed) -> Self {
2778                ()
2779            }
2780        }
2781        #[automatically_derived]
2782        #[doc(hidden)]
2783        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BlsKeyAlreadyUsed {
2784            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2785                Self
2786            }
2787        }
2788        #[automatically_derived]
2789        impl alloy_sol_types::SolError for BlsKeyAlreadyUsed {
2790            type Parameters<'a> = UnderlyingSolTuple<'a>;
2791            type Token<'a> = <Self::Parameters<
2792                'a,
2793            > as alloy_sol_types::SolType>::Token<'a>;
2794            const SIGNATURE: &'static str = "BlsKeyAlreadyUsed()";
2795            const SELECTOR: [u8; 4] = [1u8, 181u8, 20u8, 174u8];
2796            #[inline]
2797            fn new<'a>(
2798                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2799            ) -> Self {
2800                tuple.into()
2801            }
2802            #[inline]
2803            fn tokenize(&self) -> Self::Token<'_> {
2804                ()
2805            }
2806            #[inline]
2807            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2808                <Self::Parameters<
2809                    '_,
2810                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2811                    .map(Self::new)
2812            }
2813        }
2814    };
2815    #[derive(serde::Serialize, serde::Deserialize)]
2816    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2817    /**Custom error with signature `ERC1967InvalidImplementation(address)` and selector `0x4c9c8ce3`.
2818```solidity
2819error ERC1967InvalidImplementation(address implementation);
2820```*/
2821    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2822    #[derive(Clone)]
2823    pub struct ERC1967InvalidImplementation {
2824        #[allow(missing_docs)]
2825        pub implementation: alloy::sol_types::private::Address,
2826    }
2827    #[allow(
2828        non_camel_case_types,
2829        non_snake_case,
2830        clippy::pub_underscore_fields,
2831        clippy::style
2832    )]
2833    const _: () = {
2834        use alloy::sol_types as alloy_sol_types;
2835        #[doc(hidden)]
2836        #[allow(dead_code)]
2837        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2838        #[doc(hidden)]
2839        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2840        #[cfg(test)]
2841        #[allow(dead_code, unreachable_patterns)]
2842        fn _type_assertion(
2843            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2844        ) {
2845            match _t {
2846                alloy_sol_types::private::AssertTypeEq::<
2847                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2848                >(_) => {}
2849            }
2850        }
2851        #[automatically_derived]
2852        #[doc(hidden)]
2853        impl ::core::convert::From<ERC1967InvalidImplementation>
2854        for UnderlyingRustTuple<'_> {
2855            fn from(value: ERC1967InvalidImplementation) -> Self {
2856                (value.implementation,)
2857            }
2858        }
2859        #[automatically_derived]
2860        #[doc(hidden)]
2861        impl ::core::convert::From<UnderlyingRustTuple<'_>>
2862        for ERC1967InvalidImplementation {
2863            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2864                Self { implementation: tuple.0 }
2865            }
2866        }
2867        #[automatically_derived]
2868        impl alloy_sol_types::SolError for ERC1967InvalidImplementation {
2869            type Parameters<'a> = UnderlyingSolTuple<'a>;
2870            type Token<'a> = <Self::Parameters<
2871                'a,
2872            > as alloy_sol_types::SolType>::Token<'a>;
2873            const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)";
2874            const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8];
2875            #[inline]
2876            fn new<'a>(
2877                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2878            ) -> Self {
2879                tuple.into()
2880            }
2881            #[inline]
2882            fn tokenize(&self) -> Self::Token<'_> {
2883                (
2884                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2885                        &self.implementation,
2886                    ),
2887                )
2888            }
2889            #[inline]
2890            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2891                <Self::Parameters<
2892                    '_,
2893                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2894                    .map(Self::new)
2895            }
2896        }
2897    };
2898    #[derive(serde::Serialize, serde::Deserialize)]
2899    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2900    /**Custom error with signature `ERC1967NonPayable()` and selector `0xb398979f`.
2901```solidity
2902error ERC1967NonPayable();
2903```*/
2904    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2905    #[derive(Clone)]
2906    pub struct ERC1967NonPayable;
2907    #[allow(
2908        non_camel_case_types,
2909        non_snake_case,
2910        clippy::pub_underscore_fields,
2911        clippy::style
2912    )]
2913    const _: () = {
2914        use alloy::sol_types as alloy_sol_types;
2915        #[doc(hidden)]
2916        #[allow(dead_code)]
2917        type UnderlyingSolTuple<'a> = ();
2918        #[doc(hidden)]
2919        type UnderlyingRustTuple<'a> = ();
2920        #[cfg(test)]
2921        #[allow(dead_code, unreachable_patterns)]
2922        fn _type_assertion(
2923            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2924        ) {
2925            match _t {
2926                alloy_sol_types::private::AssertTypeEq::<
2927                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2928                >(_) => {}
2929            }
2930        }
2931        #[automatically_derived]
2932        #[doc(hidden)]
2933        impl ::core::convert::From<ERC1967NonPayable> for UnderlyingRustTuple<'_> {
2934            fn from(value: ERC1967NonPayable) -> Self {
2935                ()
2936            }
2937        }
2938        #[automatically_derived]
2939        #[doc(hidden)]
2940        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1967NonPayable {
2941            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2942                Self
2943            }
2944        }
2945        #[automatically_derived]
2946        impl alloy_sol_types::SolError for ERC1967NonPayable {
2947            type Parameters<'a> = UnderlyingSolTuple<'a>;
2948            type Token<'a> = <Self::Parameters<
2949                'a,
2950            > as alloy_sol_types::SolType>::Token<'a>;
2951            const SIGNATURE: &'static str = "ERC1967NonPayable()";
2952            const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8];
2953            #[inline]
2954            fn new<'a>(
2955                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2956            ) -> Self {
2957                tuple.into()
2958            }
2959            #[inline]
2960            fn tokenize(&self) -> Self::Token<'_> {
2961                ()
2962            }
2963            #[inline]
2964            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2965                <Self::Parameters<
2966                    '_,
2967                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2968                    .map(Self::new)
2969            }
2970        }
2971    };
2972    #[derive(serde::Serialize, serde::Deserialize)]
2973    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2974    /**Custom error with signature `ExitEscrowPeriodInvalid()` and selector `0xb57e21df`.
2975```solidity
2976error ExitEscrowPeriodInvalid();
2977```*/
2978    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2979    #[derive(Clone)]
2980    pub struct ExitEscrowPeriodInvalid;
2981    #[allow(
2982        non_camel_case_types,
2983        non_snake_case,
2984        clippy::pub_underscore_fields,
2985        clippy::style
2986    )]
2987    const _: () = {
2988        use alloy::sol_types as alloy_sol_types;
2989        #[doc(hidden)]
2990        #[allow(dead_code)]
2991        type UnderlyingSolTuple<'a> = ();
2992        #[doc(hidden)]
2993        type UnderlyingRustTuple<'a> = ();
2994        #[cfg(test)]
2995        #[allow(dead_code, unreachable_patterns)]
2996        fn _type_assertion(
2997            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2998        ) {
2999            match _t {
3000                alloy_sol_types::private::AssertTypeEq::<
3001                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3002                >(_) => {}
3003            }
3004        }
3005        #[automatically_derived]
3006        #[doc(hidden)]
3007        impl ::core::convert::From<ExitEscrowPeriodInvalid> for UnderlyingRustTuple<'_> {
3008            fn from(value: ExitEscrowPeriodInvalid) -> Self {
3009                ()
3010            }
3011        }
3012        #[automatically_derived]
3013        #[doc(hidden)]
3014        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExitEscrowPeriodInvalid {
3015            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3016                Self
3017            }
3018        }
3019        #[automatically_derived]
3020        impl alloy_sol_types::SolError for ExitEscrowPeriodInvalid {
3021            type Parameters<'a> = UnderlyingSolTuple<'a>;
3022            type Token<'a> = <Self::Parameters<
3023                'a,
3024            > as alloy_sol_types::SolType>::Token<'a>;
3025            const SIGNATURE: &'static str = "ExitEscrowPeriodInvalid()";
3026            const SELECTOR: [u8; 4] = [181u8, 126u8, 33u8, 223u8];
3027            #[inline]
3028            fn new<'a>(
3029                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3030            ) -> Self {
3031                tuple.into()
3032            }
3033            #[inline]
3034            fn tokenize(&self) -> Self::Token<'_> {
3035                ()
3036            }
3037            #[inline]
3038            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3039                <Self::Parameters<
3040                    '_,
3041                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3042                    .map(Self::new)
3043            }
3044        }
3045    };
3046    #[derive(serde::Serialize, serde::Deserialize)]
3047    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3048    /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`.
3049```solidity
3050error FailedInnerCall();
3051```*/
3052    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3053    #[derive(Clone)]
3054    pub struct FailedInnerCall;
3055    #[allow(
3056        non_camel_case_types,
3057        non_snake_case,
3058        clippy::pub_underscore_fields,
3059        clippy::style
3060    )]
3061    const _: () = {
3062        use alloy::sol_types as alloy_sol_types;
3063        #[doc(hidden)]
3064        #[allow(dead_code)]
3065        type UnderlyingSolTuple<'a> = ();
3066        #[doc(hidden)]
3067        type UnderlyingRustTuple<'a> = ();
3068        #[cfg(test)]
3069        #[allow(dead_code, unreachable_patterns)]
3070        fn _type_assertion(
3071            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3072        ) {
3073            match _t {
3074                alloy_sol_types::private::AssertTypeEq::<
3075                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3076                >(_) => {}
3077            }
3078        }
3079        #[automatically_derived]
3080        #[doc(hidden)]
3081        impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
3082            fn from(value: FailedInnerCall) -> Self {
3083                ()
3084            }
3085        }
3086        #[automatically_derived]
3087        #[doc(hidden)]
3088        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
3089            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3090                Self
3091            }
3092        }
3093        #[automatically_derived]
3094        impl alloy_sol_types::SolError for FailedInnerCall {
3095            type Parameters<'a> = UnderlyingSolTuple<'a>;
3096            type Token<'a> = <Self::Parameters<
3097                'a,
3098            > as alloy_sol_types::SolType>::Token<'a>;
3099            const SIGNATURE: &'static str = "FailedInnerCall()";
3100            const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
3101            #[inline]
3102            fn new<'a>(
3103                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3104            ) -> Self {
3105                tuple.into()
3106            }
3107            #[inline]
3108            fn tokenize(&self) -> Self::Token<'_> {
3109                ()
3110            }
3111            #[inline]
3112            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3113                <Self::Parameters<
3114                    '_,
3115                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3116                    .map(Self::new)
3117            }
3118        }
3119    };
3120    #[derive(serde::Serialize, serde::Deserialize)]
3121    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3122    /**Custom error with signature `InsufficientAllowance(uint256,uint256)` and selector `0x2a1b2dd8`.
3123```solidity
3124error InsufficientAllowance(uint256, uint256);
3125```*/
3126    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3127    #[derive(Clone)]
3128    pub struct InsufficientAllowance {
3129        #[allow(missing_docs)]
3130        pub _0: alloy::sol_types::private::primitives::aliases::U256,
3131        #[allow(missing_docs)]
3132        pub _1: alloy::sol_types::private::primitives::aliases::U256,
3133    }
3134    #[allow(
3135        non_camel_case_types,
3136        non_snake_case,
3137        clippy::pub_underscore_fields,
3138        clippy::style
3139    )]
3140    const _: () = {
3141        use alloy::sol_types as alloy_sol_types;
3142        #[doc(hidden)]
3143        #[allow(dead_code)]
3144        type UnderlyingSolTuple<'a> = (
3145            alloy::sol_types::sol_data::Uint<256>,
3146            alloy::sol_types::sol_data::Uint<256>,
3147        );
3148        #[doc(hidden)]
3149        type UnderlyingRustTuple<'a> = (
3150            alloy::sol_types::private::primitives::aliases::U256,
3151            alloy::sol_types::private::primitives::aliases::U256,
3152        );
3153        #[cfg(test)]
3154        #[allow(dead_code, unreachable_patterns)]
3155        fn _type_assertion(
3156            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3157        ) {
3158            match _t {
3159                alloy_sol_types::private::AssertTypeEq::<
3160                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3161                >(_) => {}
3162            }
3163        }
3164        #[automatically_derived]
3165        #[doc(hidden)]
3166        impl ::core::convert::From<InsufficientAllowance> for UnderlyingRustTuple<'_> {
3167            fn from(value: InsufficientAllowance) -> Self {
3168                (value._0, value._1)
3169            }
3170        }
3171        #[automatically_derived]
3172        #[doc(hidden)]
3173        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientAllowance {
3174            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3175                Self { _0: tuple.0, _1: tuple.1 }
3176            }
3177        }
3178        #[automatically_derived]
3179        impl alloy_sol_types::SolError for InsufficientAllowance {
3180            type Parameters<'a> = UnderlyingSolTuple<'a>;
3181            type Token<'a> = <Self::Parameters<
3182                'a,
3183            > as alloy_sol_types::SolType>::Token<'a>;
3184            const SIGNATURE: &'static str = "InsufficientAllowance(uint256,uint256)";
3185            const SELECTOR: [u8; 4] = [42u8, 27u8, 45u8, 216u8];
3186            #[inline]
3187            fn new<'a>(
3188                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3189            ) -> Self {
3190                tuple.into()
3191            }
3192            #[inline]
3193            fn tokenize(&self) -> Self::Token<'_> {
3194                (
3195                    <alloy::sol_types::sol_data::Uint<
3196                        256,
3197                    > as alloy_sol_types::SolType>::tokenize(&self._0),
3198                    <alloy::sol_types::sol_data::Uint<
3199                        256,
3200                    > as alloy_sol_types::SolType>::tokenize(&self._1),
3201                )
3202            }
3203            #[inline]
3204            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3205                <Self::Parameters<
3206                    '_,
3207                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3208                    .map(Self::new)
3209            }
3210        }
3211    };
3212    #[derive(serde::Serialize, serde::Deserialize)]
3213    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3214    /**Custom error with signature `InsufficientBalance(uint256)` and selector `0x92665351`.
3215```solidity
3216error InsufficientBalance(uint256);
3217```*/
3218    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3219    #[derive(Clone)]
3220    pub struct InsufficientBalance(
3221        pub alloy::sol_types::private::primitives::aliases::U256,
3222    );
3223    #[allow(
3224        non_camel_case_types,
3225        non_snake_case,
3226        clippy::pub_underscore_fields,
3227        clippy::style
3228    )]
3229    const _: () = {
3230        use alloy::sol_types as alloy_sol_types;
3231        #[doc(hidden)]
3232        #[allow(dead_code)]
3233        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3234        #[doc(hidden)]
3235        type UnderlyingRustTuple<'a> = (
3236            alloy::sol_types::private::primitives::aliases::U256,
3237        );
3238        #[cfg(test)]
3239        #[allow(dead_code, unreachable_patterns)]
3240        fn _type_assertion(
3241            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3242        ) {
3243            match _t {
3244                alloy_sol_types::private::AssertTypeEq::<
3245                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3246                >(_) => {}
3247            }
3248        }
3249        #[automatically_derived]
3250        #[doc(hidden)]
3251        impl ::core::convert::From<InsufficientBalance> for UnderlyingRustTuple<'_> {
3252            fn from(value: InsufficientBalance) -> Self {
3253                (value.0,)
3254            }
3255        }
3256        #[automatically_derived]
3257        #[doc(hidden)]
3258        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientBalance {
3259            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3260                Self(tuple.0)
3261            }
3262        }
3263        #[automatically_derived]
3264        impl alloy_sol_types::SolError for InsufficientBalance {
3265            type Parameters<'a> = UnderlyingSolTuple<'a>;
3266            type Token<'a> = <Self::Parameters<
3267                'a,
3268            > as alloy_sol_types::SolType>::Token<'a>;
3269            const SIGNATURE: &'static str = "InsufficientBalance(uint256)";
3270            const SELECTOR: [u8; 4] = [146u8, 102u8, 83u8, 81u8];
3271            #[inline]
3272            fn new<'a>(
3273                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3274            ) -> Self {
3275                tuple.into()
3276            }
3277            #[inline]
3278            fn tokenize(&self) -> Self::Token<'_> {
3279                (
3280                    <alloy::sol_types::sol_data::Uint<
3281                        256,
3282                    > as alloy_sol_types::SolType>::tokenize(&self.0),
3283                )
3284            }
3285            #[inline]
3286            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3287                <Self::Parameters<
3288                    '_,
3289                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3290                    .map(Self::new)
3291            }
3292        }
3293    };
3294    #[derive(serde::Serialize, serde::Deserialize)]
3295    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3296    /**Custom error with signature `InvalidCommission()` and selector `0xdc81db85`.
3297```solidity
3298error InvalidCommission();
3299```*/
3300    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3301    #[derive(Clone)]
3302    pub struct InvalidCommission;
3303    #[allow(
3304        non_camel_case_types,
3305        non_snake_case,
3306        clippy::pub_underscore_fields,
3307        clippy::style
3308    )]
3309    const _: () = {
3310        use alloy::sol_types as alloy_sol_types;
3311        #[doc(hidden)]
3312        #[allow(dead_code)]
3313        type UnderlyingSolTuple<'a> = ();
3314        #[doc(hidden)]
3315        type UnderlyingRustTuple<'a> = ();
3316        #[cfg(test)]
3317        #[allow(dead_code, unreachable_patterns)]
3318        fn _type_assertion(
3319            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3320        ) {
3321            match _t {
3322                alloy_sol_types::private::AssertTypeEq::<
3323                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3324                >(_) => {}
3325            }
3326        }
3327        #[automatically_derived]
3328        #[doc(hidden)]
3329        impl ::core::convert::From<InvalidCommission> for UnderlyingRustTuple<'_> {
3330            fn from(value: InvalidCommission) -> Self {
3331                ()
3332            }
3333        }
3334        #[automatically_derived]
3335        #[doc(hidden)]
3336        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidCommission {
3337            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3338                Self
3339            }
3340        }
3341        #[automatically_derived]
3342        impl alloy_sol_types::SolError for InvalidCommission {
3343            type Parameters<'a> = UnderlyingSolTuple<'a>;
3344            type Token<'a> = <Self::Parameters<
3345                'a,
3346            > as alloy_sol_types::SolType>::Token<'a>;
3347            const SIGNATURE: &'static str = "InvalidCommission()";
3348            const SELECTOR: [u8; 4] = [220u8, 129u8, 219u8, 133u8];
3349            #[inline]
3350            fn new<'a>(
3351                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3352            ) -> Self {
3353                tuple.into()
3354            }
3355            #[inline]
3356            fn tokenize(&self) -> Self::Token<'_> {
3357                ()
3358            }
3359            #[inline]
3360            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3361                <Self::Parameters<
3362                    '_,
3363                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3364                    .map(Self::new)
3365            }
3366        }
3367    };
3368    #[derive(serde::Serialize, serde::Deserialize)]
3369    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3370    /**Custom error with signature `InvalidG1()` and selector `0x9e78d14c`.
3371```solidity
3372error InvalidG1();
3373```*/
3374    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3375    #[derive(Clone)]
3376    pub struct InvalidG1;
3377    #[allow(
3378        non_camel_case_types,
3379        non_snake_case,
3380        clippy::pub_underscore_fields,
3381        clippy::style
3382    )]
3383    const _: () = {
3384        use alloy::sol_types as alloy_sol_types;
3385        #[doc(hidden)]
3386        #[allow(dead_code)]
3387        type UnderlyingSolTuple<'a> = ();
3388        #[doc(hidden)]
3389        type UnderlyingRustTuple<'a> = ();
3390        #[cfg(test)]
3391        #[allow(dead_code, unreachable_patterns)]
3392        fn _type_assertion(
3393            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3394        ) {
3395            match _t {
3396                alloy_sol_types::private::AssertTypeEq::<
3397                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3398                >(_) => {}
3399            }
3400        }
3401        #[automatically_derived]
3402        #[doc(hidden)]
3403        impl ::core::convert::From<InvalidG1> for UnderlyingRustTuple<'_> {
3404            fn from(value: InvalidG1) -> Self {
3405                ()
3406            }
3407        }
3408        #[automatically_derived]
3409        #[doc(hidden)]
3410        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidG1 {
3411            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3412                Self
3413            }
3414        }
3415        #[automatically_derived]
3416        impl alloy_sol_types::SolError for InvalidG1 {
3417            type Parameters<'a> = UnderlyingSolTuple<'a>;
3418            type Token<'a> = <Self::Parameters<
3419                'a,
3420            > as alloy_sol_types::SolType>::Token<'a>;
3421            const SIGNATURE: &'static str = "InvalidG1()";
3422            const SELECTOR: [u8; 4] = [158u8, 120u8, 209u8, 76u8];
3423            #[inline]
3424            fn new<'a>(
3425                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3426            ) -> Self {
3427                tuple.into()
3428            }
3429            #[inline]
3430            fn tokenize(&self) -> Self::Token<'_> {
3431                ()
3432            }
3433            #[inline]
3434            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3435                <Self::Parameters<
3436                    '_,
3437                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3438                    .map(Self::new)
3439            }
3440        }
3441    };
3442    #[derive(serde::Serialize, serde::Deserialize)]
3443    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3444    /**Custom error with signature `InvalidInitialization()` and selector `0xf92ee8a9`.
3445```solidity
3446error InvalidInitialization();
3447```*/
3448    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3449    #[derive(Clone)]
3450    pub struct InvalidInitialization;
3451    #[allow(
3452        non_camel_case_types,
3453        non_snake_case,
3454        clippy::pub_underscore_fields,
3455        clippy::style
3456    )]
3457    const _: () = {
3458        use alloy::sol_types as alloy_sol_types;
3459        #[doc(hidden)]
3460        #[allow(dead_code)]
3461        type UnderlyingSolTuple<'a> = ();
3462        #[doc(hidden)]
3463        type UnderlyingRustTuple<'a> = ();
3464        #[cfg(test)]
3465        #[allow(dead_code, unreachable_patterns)]
3466        fn _type_assertion(
3467            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3468        ) {
3469            match _t {
3470                alloy_sol_types::private::AssertTypeEq::<
3471                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3472                >(_) => {}
3473            }
3474        }
3475        #[automatically_derived]
3476        #[doc(hidden)]
3477        impl ::core::convert::From<InvalidInitialization> for UnderlyingRustTuple<'_> {
3478            fn from(value: InvalidInitialization) -> Self {
3479                ()
3480            }
3481        }
3482        #[automatically_derived]
3483        #[doc(hidden)]
3484        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInitialization {
3485            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3486                Self
3487            }
3488        }
3489        #[automatically_derived]
3490        impl alloy_sol_types::SolError for InvalidInitialization {
3491            type Parameters<'a> = UnderlyingSolTuple<'a>;
3492            type Token<'a> = <Self::Parameters<
3493                'a,
3494            > as alloy_sol_types::SolType>::Token<'a>;
3495            const SIGNATURE: &'static str = "InvalidInitialization()";
3496            const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8];
3497            #[inline]
3498            fn new<'a>(
3499                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3500            ) -> Self {
3501                tuple.into()
3502            }
3503            #[inline]
3504            fn tokenize(&self) -> Self::Token<'_> {
3505                ()
3506            }
3507            #[inline]
3508            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3509                <Self::Parameters<
3510                    '_,
3511                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3512                    .map(Self::new)
3513            }
3514        }
3515    };
3516    #[derive(serde::Serialize, serde::Deserialize)]
3517    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3518    /**Custom error with signature `InvalidSchnorrVK()` and selector `0x06cf438f`.
3519```solidity
3520error InvalidSchnorrVK();
3521```*/
3522    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3523    #[derive(Clone)]
3524    pub struct InvalidSchnorrVK;
3525    #[allow(
3526        non_camel_case_types,
3527        non_snake_case,
3528        clippy::pub_underscore_fields,
3529        clippy::style
3530    )]
3531    const _: () = {
3532        use alloy::sol_types as alloy_sol_types;
3533        #[doc(hidden)]
3534        #[allow(dead_code)]
3535        type UnderlyingSolTuple<'a> = ();
3536        #[doc(hidden)]
3537        type UnderlyingRustTuple<'a> = ();
3538        #[cfg(test)]
3539        #[allow(dead_code, unreachable_patterns)]
3540        fn _type_assertion(
3541            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3542        ) {
3543            match _t {
3544                alloy_sol_types::private::AssertTypeEq::<
3545                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3546                >(_) => {}
3547            }
3548        }
3549        #[automatically_derived]
3550        #[doc(hidden)]
3551        impl ::core::convert::From<InvalidSchnorrVK> for UnderlyingRustTuple<'_> {
3552            fn from(value: InvalidSchnorrVK) -> Self {
3553                ()
3554            }
3555        }
3556        #[automatically_derived]
3557        #[doc(hidden)]
3558        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSchnorrVK {
3559            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3560                Self
3561            }
3562        }
3563        #[automatically_derived]
3564        impl alloy_sol_types::SolError for InvalidSchnorrVK {
3565            type Parameters<'a> = UnderlyingSolTuple<'a>;
3566            type Token<'a> = <Self::Parameters<
3567                'a,
3568            > as alloy_sol_types::SolType>::Token<'a>;
3569            const SIGNATURE: &'static str = "InvalidSchnorrVK()";
3570            const SELECTOR: [u8; 4] = [6u8, 207u8, 67u8, 143u8];
3571            #[inline]
3572            fn new<'a>(
3573                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3574            ) -> Self {
3575                tuple.into()
3576            }
3577            #[inline]
3578            fn tokenize(&self) -> Self::Token<'_> {
3579                ()
3580            }
3581            #[inline]
3582            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3583                <Self::Parameters<
3584                    '_,
3585                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3586                    .map(Self::new)
3587            }
3588        }
3589    };
3590    #[derive(serde::Serialize, serde::Deserialize)]
3591    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3592    /**Custom error with signature `NotInitializing()` and selector `0xd7e6bcf8`.
3593```solidity
3594error NotInitializing();
3595```*/
3596    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3597    #[derive(Clone)]
3598    pub struct NotInitializing;
3599    #[allow(
3600        non_camel_case_types,
3601        non_snake_case,
3602        clippy::pub_underscore_fields,
3603        clippy::style
3604    )]
3605    const _: () = {
3606        use alloy::sol_types as alloy_sol_types;
3607        #[doc(hidden)]
3608        #[allow(dead_code)]
3609        type UnderlyingSolTuple<'a> = ();
3610        #[doc(hidden)]
3611        type UnderlyingRustTuple<'a> = ();
3612        #[cfg(test)]
3613        #[allow(dead_code, unreachable_patterns)]
3614        fn _type_assertion(
3615            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3616        ) {
3617            match _t {
3618                alloy_sol_types::private::AssertTypeEq::<
3619                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3620                >(_) => {}
3621            }
3622        }
3623        #[automatically_derived]
3624        #[doc(hidden)]
3625        impl ::core::convert::From<NotInitializing> for UnderlyingRustTuple<'_> {
3626            fn from(value: NotInitializing) -> Self {
3627                ()
3628            }
3629        }
3630        #[automatically_derived]
3631        #[doc(hidden)]
3632        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotInitializing {
3633            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3634                Self
3635            }
3636        }
3637        #[automatically_derived]
3638        impl alloy_sol_types::SolError for NotInitializing {
3639            type Parameters<'a> = UnderlyingSolTuple<'a>;
3640            type Token<'a> = <Self::Parameters<
3641                'a,
3642            > as alloy_sol_types::SolType>::Token<'a>;
3643            const SIGNATURE: &'static str = "NotInitializing()";
3644            const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8];
3645            #[inline]
3646            fn new<'a>(
3647                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3648            ) -> Self {
3649                tuple.into()
3650            }
3651            #[inline]
3652            fn tokenize(&self) -> Self::Token<'_> {
3653                ()
3654            }
3655            #[inline]
3656            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3657                <Self::Parameters<
3658                    '_,
3659                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3660                    .map(Self::new)
3661            }
3662        }
3663    };
3664    #[derive(serde::Serialize, serde::Deserialize)]
3665    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3666    /**Custom error with signature `NothingToWithdraw()` and selector `0xd0d04f60`.
3667```solidity
3668error NothingToWithdraw();
3669```*/
3670    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3671    #[derive(Clone)]
3672    pub struct NothingToWithdraw;
3673    #[allow(
3674        non_camel_case_types,
3675        non_snake_case,
3676        clippy::pub_underscore_fields,
3677        clippy::style
3678    )]
3679    const _: () = {
3680        use alloy::sol_types as alloy_sol_types;
3681        #[doc(hidden)]
3682        #[allow(dead_code)]
3683        type UnderlyingSolTuple<'a> = ();
3684        #[doc(hidden)]
3685        type UnderlyingRustTuple<'a> = ();
3686        #[cfg(test)]
3687        #[allow(dead_code, unreachable_patterns)]
3688        fn _type_assertion(
3689            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3690        ) {
3691            match _t {
3692                alloy_sol_types::private::AssertTypeEq::<
3693                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3694                >(_) => {}
3695            }
3696        }
3697        #[automatically_derived]
3698        #[doc(hidden)]
3699        impl ::core::convert::From<NothingToWithdraw> for UnderlyingRustTuple<'_> {
3700            fn from(value: NothingToWithdraw) -> Self {
3701                ()
3702            }
3703        }
3704        #[automatically_derived]
3705        #[doc(hidden)]
3706        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NothingToWithdraw {
3707            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3708                Self
3709            }
3710        }
3711        #[automatically_derived]
3712        impl alloy_sol_types::SolError for NothingToWithdraw {
3713            type Parameters<'a> = UnderlyingSolTuple<'a>;
3714            type Token<'a> = <Self::Parameters<
3715                'a,
3716            > as alloy_sol_types::SolType>::Token<'a>;
3717            const SIGNATURE: &'static str = "NothingToWithdraw()";
3718            const SELECTOR: [u8; 4] = [208u8, 208u8, 79u8, 96u8];
3719            #[inline]
3720            fn new<'a>(
3721                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3722            ) -> Self {
3723                tuple.into()
3724            }
3725            #[inline]
3726            fn tokenize(&self) -> Self::Token<'_> {
3727                ()
3728            }
3729            #[inline]
3730            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3731                <Self::Parameters<
3732                    '_,
3733                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3734                    .map(Self::new)
3735            }
3736        }
3737    };
3738    #[derive(serde::Serialize, serde::Deserialize)]
3739    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3740    /**Custom error with signature `OwnableInvalidOwner(address)` and selector `0x1e4fbdf7`.
3741```solidity
3742error OwnableInvalidOwner(address owner);
3743```*/
3744    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3745    #[derive(Clone)]
3746    pub struct OwnableInvalidOwner {
3747        #[allow(missing_docs)]
3748        pub owner: alloy::sol_types::private::Address,
3749    }
3750    #[allow(
3751        non_camel_case_types,
3752        non_snake_case,
3753        clippy::pub_underscore_fields,
3754        clippy::style
3755    )]
3756    const _: () = {
3757        use alloy::sol_types as alloy_sol_types;
3758        #[doc(hidden)]
3759        #[allow(dead_code)]
3760        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3761        #[doc(hidden)]
3762        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3763        #[cfg(test)]
3764        #[allow(dead_code, unreachable_patterns)]
3765        fn _type_assertion(
3766            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3767        ) {
3768            match _t {
3769                alloy_sol_types::private::AssertTypeEq::<
3770                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3771                >(_) => {}
3772            }
3773        }
3774        #[automatically_derived]
3775        #[doc(hidden)]
3776        impl ::core::convert::From<OwnableInvalidOwner> for UnderlyingRustTuple<'_> {
3777            fn from(value: OwnableInvalidOwner) -> Self {
3778                (value.owner,)
3779            }
3780        }
3781        #[automatically_derived]
3782        #[doc(hidden)]
3783        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableInvalidOwner {
3784            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3785                Self { owner: tuple.0 }
3786            }
3787        }
3788        #[automatically_derived]
3789        impl alloy_sol_types::SolError for OwnableInvalidOwner {
3790            type Parameters<'a> = UnderlyingSolTuple<'a>;
3791            type Token<'a> = <Self::Parameters<
3792                'a,
3793            > as alloy_sol_types::SolType>::Token<'a>;
3794            const SIGNATURE: &'static str = "OwnableInvalidOwner(address)";
3795            const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8];
3796            #[inline]
3797            fn new<'a>(
3798                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3799            ) -> Self {
3800                tuple.into()
3801            }
3802            #[inline]
3803            fn tokenize(&self) -> Self::Token<'_> {
3804                (
3805                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3806                        &self.owner,
3807                    ),
3808                )
3809            }
3810            #[inline]
3811            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3812                <Self::Parameters<
3813                    '_,
3814                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3815                    .map(Self::new)
3816            }
3817        }
3818    };
3819    #[derive(serde::Serialize, serde::Deserialize)]
3820    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3821    /**Custom error with signature `OwnableUnauthorizedAccount(address)` and selector `0x118cdaa7`.
3822```solidity
3823error OwnableUnauthorizedAccount(address account);
3824```*/
3825    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3826    #[derive(Clone)]
3827    pub struct OwnableUnauthorizedAccount {
3828        #[allow(missing_docs)]
3829        pub account: alloy::sol_types::private::Address,
3830    }
3831    #[allow(
3832        non_camel_case_types,
3833        non_snake_case,
3834        clippy::pub_underscore_fields,
3835        clippy::style
3836    )]
3837    const _: () = {
3838        use alloy::sol_types as alloy_sol_types;
3839        #[doc(hidden)]
3840        #[allow(dead_code)]
3841        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3842        #[doc(hidden)]
3843        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3844        #[cfg(test)]
3845        #[allow(dead_code, unreachable_patterns)]
3846        fn _type_assertion(
3847            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3848        ) {
3849            match _t {
3850                alloy_sol_types::private::AssertTypeEq::<
3851                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3852                >(_) => {}
3853            }
3854        }
3855        #[automatically_derived]
3856        #[doc(hidden)]
3857        impl ::core::convert::From<OwnableUnauthorizedAccount>
3858        for UnderlyingRustTuple<'_> {
3859            fn from(value: OwnableUnauthorizedAccount) -> Self {
3860                (value.account,)
3861            }
3862        }
3863        #[automatically_derived]
3864        #[doc(hidden)]
3865        impl ::core::convert::From<UnderlyingRustTuple<'_>>
3866        for OwnableUnauthorizedAccount {
3867            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3868                Self { account: tuple.0 }
3869            }
3870        }
3871        #[automatically_derived]
3872        impl alloy_sol_types::SolError for OwnableUnauthorizedAccount {
3873            type Parameters<'a> = UnderlyingSolTuple<'a>;
3874            type Token<'a> = <Self::Parameters<
3875                'a,
3876            > as alloy_sol_types::SolType>::Token<'a>;
3877            const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)";
3878            const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8];
3879            #[inline]
3880            fn new<'a>(
3881                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3882            ) -> Self {
3883                tuple.into()
3884            }
3885            #[inline]
3886            fn tokenize(&self) -> Self::Token<'_> {
3887                (
3888                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3889                        &self.account,
3890                    ),
3891                )
3892            }
3893            #[inline]
3894            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3895                <Self::Parameters<
3896                    '_,
3897                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3898                    .map(Self::new)
3899            }
3900        }
3901    };
3902    #[derive(serde::Serialize, serde::Deserialize)]
3903    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3904    /**Custom error with signature `OwnershipCannotBeRenounced()` and selector `0x2fab92ca`.
3905```solidity
3906error OwnershipCannotBeRenounced();
3907```*/
3908    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3909    #[derive(Clone)]
3910    pub struct OwnershipCannotBeRenounced;
3911    #[allow(
3912        non_camel_case_types,
3913        non_snake_case,
3914        clippy::pub_underscore_fields,
3915        clippy::style
3916    )]
3917    const _: () = {
3918        use alloy::sol_types as alloy_sol_types;
3919        #[doc(hidden)]
3920        #[allow(dead_code)]
3921        type UnderlyingSolTuple<'a> = ();
3922        #[doc(hidden)]
3923        type UnderlyingRustTuple<'a> = ();
3924        #[cfg(test)]
3925        #[allow(dead_code, unreachable_patterns)]
3926        fn _type_assertion(
3927            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3928        ) {
3929            match _t {
3930                alloy_sol_types::private::AssertTypeEq::<
3931                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3932                >(_) => {}
3933            }
3934        }
3935        #[automatically_derived]
3936        #[doc(hidden)]
3937        impl ::core::convert::From<OwnershipCannotBeRenounced>
3938        for UnderlyingRustTuple<'_> {
3939            fn from(value: OwnershipCannotBeRenounced) -> Self {
3940                ()
3941            }
3942        }
3943        #[automatically_derived]
3944        #[doc(hidden)]
3945        impl ::core::convert::From<UnderlyingRustTuple<'_>>
3946        for OwnershipCannotBeRenounced {
3947            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3948                Self
3949            }
3950        }
3951        #[automatically_derived]
3952        impl alloy_sol_types::SolError for OwnershipCannotBeRenounced {
3953            type Parameters<'a> = UnderlyingSolTuple<'a>;
3954            type Token<'a> = <Self::Parameters<
3955                'a,
3956            > as alloy_sol_types::SolType>::Token<'a>;
3957            const SIGNATURE: &'static str = "OwnershipCannotBeRenounced()";
3958            const SELECTOR: [u8; 4] = [47u8, 171u8, 146u8, 202u8];
3959            #[inline]
3960            fn new<'a>(
3961                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3962            ) -> Self {
3963                tuple.into()
3964            }
3965            #[inline]
3966            fn tokenize(&self) -> Self::Token<'_> {
3967                ()
3968            }
3969            #[inline]
3970            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3971                <Self::Parameters<
3972                    '_,
3973                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3974                    .map(Self::new)
3975            }
3976        }
3977    };
3978    #[derive(serde::Serialize, serde::Deserialize)]
3979    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3980    /**Custom error with signature `PowPrecompileFailed()` and selector `0x3274fa64`.
3981```solidity
3982error PowPrecompileFailed();
3983```*/
3984    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3985    #[derive(Clone)]
3986    pub struct PowPrecompileFailed;
3987    #[allow(
3988        non_camel_case_types,
3989        non_snake_case,
3990        clippy::pub_underscore_fields,
3991        clippy::style
3992    )]
3993    const _: () = {
3994        use alloy::sol_types as alloy_sol_types;
3995        #[doc(hidden)]
3996        #[allow(dead_code)]
3997        type UnderlyingSolTuple<'a> = ();
3998        #[doc(hidden)]
3999        type UnderlyingRustTuple<'a> = ();
4000        #[cfg(test)]
4001        #[allow(dead_code, unreachable_patterns)]
4002        fn _type_assertion(
4003            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4004        ) {
4005            match _t {
4006                alloy_sol_types::private::AssertTypeEq::<
4007                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4008                >(_) => {}
4009            }
4010        }
4011        #[automatically_derived]
4012        #[doc(hidden)]
4013        impl ::core::convert::From<PowPrecompileFailed> for UnderlyingRustTuple<'_> {
4014            fn from(value: PowPrecompileFailed) -> Self {
4015                ()
4016            }
4017        }
4018        #[automatically_derived]
4019        #[doc(hidden)]
4020        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PowPrecompileFailed {
4021            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4022                Self
4023            }
4024        }
4025        #[automatically_derived]
4026        impl alloy_sol_types::SolError for PowPrecompileFailed {
4027            type Parameters<'a> = UnderlyingSolTuple<'a>;
4028            type Token<'a> = <Self::Parameters<
4029                'a,
4030            > as alloy_sol_types::SolType>::Token<'a>;
4031            const SIGNATURE: &'static str = "PowPrecompileFailed()";
4032            const SELECTOR: [u8; 4] = [50u8, 116u8, 250u8, 100u8];
4033            #[inline]
4034            fn new<'a>(
4035                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4036            ) -> Self {
4037                tuple.into()
4038            }
4039            #[inline]
4040            fn tokenize(&self) -> Self::Token<'_> {
4041                ()
4042            }
4043            #[inline]
4044            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4045                <Self::Parameters<
4046                    '_,
4047                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4048                    .map(Self::new)
4049            }
4050        }
4051    };
4052    #[derive(serde::Serialize, serde::Deserialize)]
4053    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4054    /**Custom error with signature `PrematureWithdrawal()` and selector `0x5a774357`.
4055```solidity
4056error PrematureWithdrawal();
4057```*/
4058    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4059    #[derive(Clone)]
4060    pub struct PrematureWithdrawal;
4061    #[allow(
4062        non_camel_case_types,
4063        non_snake_case,
4064        clippy::pub_underscore_fields,
4065        clippy::style
4066    )]
4067    const _: () = {
4068        use alloy::sol_types as alloy_sol_types;
4069        #[doc(hidden)]
4070        #[allow(dead_code)]
4071        type UnderlyingSolTuple<'a> = ();
4072        #[doc(hidden)]
4073        type UnderlyingRustTuple<'a> = ();
4074        #[cfg(test)]
4075        #[allow(dead_code, unreachable_patterns)]
4076        fn _type_assertion(
4077            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4078        ) {
4079            match _t {
4080                alloy_sol_types::private::AssertTypeEq::<
4081                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4082                >(_) => {}
4083            }
4084        }
4085        #[automatically_derived]
4086        #[doc(hidden)]
4087        impl ::core::convert::From<PrematureWithdrawal> for UnderlyingRustTuple<'_> {
4088            fn from(value: PrematureWithdrawal) -> Self {
4089                ()
4090            }
4091        }
4092        #[automatically_derived]
4093        #[doc(hidden)]
4094        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PrematureWithdrawal {
4095            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4096                Self
4097            }
4098        }
4099        #[automatically_derived]
4100        impl alloy_sol_types::SolError for PrematureWithdrawal {
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 = "PrematureWithdrawal()";
4106            const SELECTOR: [u8; 4] = [90u8, 119u8, 67u8, 87u8];
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            #[inline]
4118            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4119                <Self::Parameters<
4120                    '_,
4121                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4122                    .map(Self::new)
4123            }
4124        }
4125    };
4126    #[derive(serde::Serialize, serde::Deserialize)]
4127    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4128    /**Custom error with signature `UUPSUnauthorizedCallContext()` and selector `0xe07c8dba`.
4129```solidity
4130error UUPSUnauthorizedCallContext();
4131```*/
4132    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4133    #[derive(Clone)]
4134    pub struct UUPSUnauthorizedCallContext;
4135    #[allow(
4136        non_camel_case_types,
4137        non_snake_case,
4138        clippy::pub_underscore_fields,
4139        clippy::style
4140    )]
4141    const _: () = {
4142        use alloy::sol_types as alloy_sol_types;
4143        #[doc(hidden)]
4144        #[allow(dead_code)]
4145        type UnderlyingSolTuple<'a> = ();
4146        #[doc(hidden)]
4147        type UnderlyingRustTuple<'a> = ();
4148        #[cfg(test)]
4149        #[allow(dead_code, unreachable_patterns)]
4150        fn _type_assertion(
4151            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4152        ) {
4153            match _t {
4154                alloy_sol_types::private::AssertTypeEq::<
4155                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4156                >(_) => {}
4157            }
4158        }
4159        #[automatically_derived]
4160        #[doc(hidden)]
4161        impl ::core::convert::From<UUPSUnauthorizedCallContext>
4162        for UnderlyingRustTuple<'_> {
4163            fn from(value: UUPSUnauthorizedCallContext) -> Self {
4164                ()
4165            }
4166        }
4167        #[automatically_derived]
4168        #[doc(hidden)]
4169        impl ::core::convert::From<UnderlyingRustTuple<'_>>
4170        for UUPSUnauthorizedCallContext {
4171            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4172                Self
4173            }
4174        }
4175        #[automatically_derived]
4176        impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext {
4177            type Parameters<'a> = UnderlyingSolTuple<'a>;
4178            type Token<'a> = <Self::Parameters<
4179                'a,
4180            > as alloy_sol_types::SolType>::Token<'a>;
4181            const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()";
4182            const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8];
4183            #[inline]
4184            fn new<'a>(
4185                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4186            ) -> Self {
4187                tuple.into()
4188            }
4189            #[inline]
4190            fn tokenize(&self) -> Self::Token<'_> {
4191                ()
4192            }
4193            #[inline]
4194            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4195                <Self::Parameters<
4196                    '_,
4197                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4198                    .map(Self::new)
4199            }
4200        }
4201    };
4202    #[derive(serde::Serialize, serde::Deserialize)]
4203    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4204    /**Custom error with signature `UUPSUnsupportedProxiableUUID(bytes32)` and selector `0xaa1d49a4`.
4205```solidity
4206error UUPSUnsupportedProxiableUUID(bytes32 slot);
4207```*/
4208    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4209    #[derive(Clone)]
4210    pub struct UUPSUnsupportedProxiableUUID {
4211        #[allow(missing_docs)]
4212        pub slot: alloy::sol_types::private::FixedBytes<32>,
4213    }
4214    #[allow(
4215        non_camel_case_types,
4216        non_snake_case,
4217        clippy::pub_underscore_fields,
4218        clippy::style
4219    )]
4220    const _: () = {
4221        use alloy::sol_types as alloy_sol_types;
4222        #[doc(hidden)]
4223        #[allow(dead_code)]
4224        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4225        #[doc(hidden)]
4226        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4227        #[cfg(test)]
4228        #[allow(dead_code, unreachable_patterns)]
4229        fn _type_assertion(
4230            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4231        ) {
4232            match _t {
4233                alloy_sol_types::private::AssertTypeEq::<
4234                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4235                >(_) => {}
4236            }
4237        }
4238        #[automatically_derived]
4239        #[doc(hidden)]
4240        impl ::core::convert::From<UUPSUnsupportedProxiableUUID>
4241        for UnderlyingRustTuple<'_> {
4242            fn from(value: UUPSUnsupportedProxiableUUID) -> Self {
4243                (value.slot,)
4244            }
4245        }
4246        #[automatically_derived]
4247        #[doc(hidden)]
4248        impl ::core::convert::From<UnderlyingRustTuple<'_>>
4249        for UUPSUnsupportedProxiableUUID {
4250            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4251                Self { slot: tuple.0 }
4252            }
4253        }
4254        #[automatically_derived]
4255        impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID {
4256            type Parameters<'a> = UnderlyingSolTuple<'a>;
4257            type Token<'a> = <Self::Parameters<
4258                'a,
4259            > as alloy_sol_types::SolType>::Token<'a>;
4260            const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)";
4261            const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8];
4262            #[inline]
4263            fn new<'a>(
4264                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4265            ) -> Self {
4266                tuple.into()
4267            }
4268            #[inline]
4269            fn tokenize(&self) -> Self::Token<'_> {
4270                (
4271                    <alloy::sol_types::sol_data::FixedBytes<
4272                        32,
4273                    > as alloy_sol_types::SolType>::tokenize(&self.slot),
4274                )
4275            }
4276            #[inline]
4277            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4278                <Self::Parameters<
4279                    '_,
4280                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4281                    .map(Self::new)
4282            }
4283        }
4284    };
4285    #[derive(serde::Serialize, serde::Deserialize)]
4286    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4287    /**Custom error with signature `UndelegationAlreadyExists()` and selector `0xd423a4f1`.
4288```solidity
4289error UndelegationAlreadyExists();
4290```*/
4291    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4292    #[derive(Clone)]
4293    pub struct UndelegationAlreadyExists;
4294    #[allow(
4295        non_camel_case_types,
4296        non_snake_case,
4297        clippy::pub_underscore_fields,
4298        clippy::style
4299    )]
4300    const _: () = {
4301        use alloy::sol_types as alloy_sol_types;
4302        #[doc(hidden)]
4303        #[allow(dead_code)]
4304        type UnderlyingSolTuple<'a> = ();
4305        #[doc(hidden)]
4306        type UnderlyingRustTuple<'a> = ();
4307        #[cfg(test)]
4308        #[allow(dead_code, unreachable_patterns)]
4309        fn _type_assertion(
4310            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4311        ) {
4312            match _t {
4313                alloy_sol_types::private::AssertTypeEq::<
4314                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4315                >(_) => {}
4316            }
4317        }
4318        #[automatically_derived]
4319        #[doc(hidden)]
4320        impl ::core::convert::From<UndelegationAlreadyExists>
4321        for UnderlyingRustTuple<'_> {
4322            fn from(value: UndelegationAlreadyExists) -> Self {
4323                ()
4324            }
4325        }
4326        #[automatically_derived]
4327        #[doc(hidden)]
4328        impl ::core::convert::From<UnderlyingRustTuple<'_>>
4329        for UndelegationAlreadyExists {
4330            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4331                Self
4332            }
4333        }
4334        #[automatically_derived]
4335        impl alloy_sol_types::SolError for UndelegationAlreadyExists {
4336            type Parameters<'a> = UnderlyingSolTuple<'a>;
4337            type Token<'a> = <Self::Parameters<
4338                'a,
4339            > as alloy_sol_types::SolType>::Token<'a>;
4340            const SIGNATURE: &'static str = "UndelegationAlreadyExists()";
4341            const SELECTOR: [u8; 4] = [212u8, 35u8, 164u8, 241u8];
4342            #[inline]
4343            fn new<'a>(
4344                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4345            ) -> Self {
4346                tuple.into()
4347            }
4348            #[inline]
4349            fn tokenize(&self) -> Self::Token<'_> {
4350                ()
4351            }
4352            #[inline]
4353            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4354                <Self::Parameters<
4355                    '_,
4356                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4357                    .map(Self::new)
4358            }
4359        }
4360    };
4361    #[derive(serde::Serialize, serde::Deserialize)]
4362    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4363    /**Custom error with signature `ValidatorAlreadyExited()` and selector `0xeab4a963`.
4364```solidity
4365error ValidatorAlreadyExited();
4366```*/
4367    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4368    #[derive(Clone)]
4369    pub struct ValidatorAlreadyExited;
4370    #[allow(
4371        non_camel_case_types,
4372        non_snake_case,
4373        clippy::pub_underscore_fields,
4374        clippy::style
4375    )]
4376    const _: () = {
4377        use alloy::sol_types as alloy_sol_types;
4378        #[doc(hidden)]
4379        #[allow(dead_code)]
4380        type UnderlyingSolTuple<'a> = ();
4381        #[doc(hidden)]
4382        type UnderlyingRustTuple<'a> = ();
4383        #[cfg(test)]
4384        #[allow(dead_code, unreachable_patterns)]
4385        fn _type_assertion(
4386            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4387        ) {
4388            match _t {
4389                alloy_sol_types::private::AssertTypeEq::<
4390                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4391                >(_) => {}
4392            }
4393        }
4394        #[automatically_derived]
4395        #[doc(hidden)]
4396        impl ::core::convert::From<ValidatorAlreadyExited> for UnderlyingRustTuple<'_> {
4397            fn from(value: ValidatorAlreadyExited) -> Self {
4398                ()
4399            }
4400        }
4401        #[automatically_derived]
4402        #[doc(hidden)]
4403        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ValidatorAlreadyExited {
4404            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4405                Self
4406            }
4407        }
4408        #[automatically_derived]
4409        impl alloy_sol_types::SolError for ValidatorAlreadyExited {
4410            type Parameters<'a> = UnderlyingSolTuple<'a>;
4411            type Token<'a> = <Self::Parameters<
4412                'a,
4413            > as alloy_sol_types::SolType>::Token<'a>;
4414            const SIGNATURE: &'static str = "ValidatorAlreadyExited()";
4415            const SELECTOR: [u8; 4] = [234u8, 180u8, 169u8, 99u8];
4416            #[inline]
4417            fn new<'a>(
4418                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4419            ) -> Self {
4420                tuple.into()
4421            }
4422            #[inline]
4423            fn tokenize(&self) -> Self::Token<'_> {
4424                ()
4425            }
4426            #[inline]
4427            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4428                <Self::Parameters<
4429                    '_,
4430                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4431                    .map(Self::new)
4432            }
4433        }
4434    };
4435    #[derive(serde::Serialize, serde::Deserialize)]
4436    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4437    /**Custom error with signature `ValidatorAlreadyRegistered()` and selector `0x9973f7d8`.
4438```solidity
4439error ValidatorAlreadyRegistered();
4440```*/
4441    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4442    #[derive(Clone)]
4443    pub struct ValidatorAlreadyRegistered;
4444    #[allow(
4445        non_camel_case_types,
4446        non_snake_case,
4447        clippy::pub_underscore_fields,
4448        clippy::style
4449    )]
4450    const _: () = {
4451        use alloy::sol_types as alloy_sol_types;
4452        #[doc(hidden)]
4453        #[allow(dead_code)]
4454        type UnderlyingSolTuple<'a> = ();
4455        #[doc(hidden)]
4456        type UnderlyingRustTuple<'a> = ();
4457        #[cfg(test)]
4458        #[allow(dead_code, unreachable_patterns)]
4459        fn _type_assertion(
4460            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4461        ) {
4462            match _t {
4463                alloy_sol_types::private::AssertTypeEq::<
4464                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4465                >(_) => {}
4466            }
4467        }
4468        #[automatically_derived]
4469        #[doc(hidden)]
4470        impl ::core::convert::From<ValidatorAlreadyRegistered>
4471        for UnderlyingRustTuple<'_> {
4472            fn from(value: ValidatorAlreadyRegistered) -> Self {
4473                ()
4474            }
4475        }
4476        #[automatically_derived]
4477        #[doc(hidden)]
4478        impl ::core::convert::From<UnderlyingRustTuple<'_>>
4479        for ValidatorAlreadyRegistered {
4480            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4481                Self
4482            }
4483        }
4484        #[automatically_derived]
4485        impl alloy_sol_types::SolError for ValidatorAlreadyRegistered {
4486            type Parameters<'a> = UnderlyingSolTuple<'a>;
4487            type Token<'a> = <Self::Parameters<
4488                'a,
4489            > as alloy_sol_types::SolType>::Token<'a>;
4490            const SIGNATURE: &'static str = "ValidatorAlreadyRegistered()";
4491            const SELECTOR: [u8; 4] = [153u8, 115u8, 247u8, 216u8];
4492            #[inline]
4493            fn new<'a>(
4494                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4495            ) -> Self {
4496                tuple.into()
4497            }
4498            #[inline]
4499            fn tokenize(&self) -> Self::Token<'_> {
4500                ()
4501            }
4502            #[inline]
4503            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4504                <Self::Parameters<
4505                    '_,
4506                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4507                    .map(Self::new)
4508            }
4509        }
4510    };
4511    #[derive(serde::Serialize, serde::Deserialize)]
4512    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4513    /**Custom error with signature `ValidatorInactive()` and selector `0x508a793f`.
4514```solidity
4515error ValidatorInactive();
4516```*/
4517    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4518    #[derive(Clone)]
4519    pub struct ValidatorInactive;
4520    #[allow(
4521        non_camel_case_types,
4522        non_snake_case,
4523        clippy::pub_underscore_fields,
4524        clippy::style
4525    )]
4526    const _: () = {
4527        use alloy::sol_types as alloy_sol_types;
4528        #[doc(hidden)]
4529        #[allow(dead_code)]
4530        type UnderlyingSolTuple<'a> = ();
4531        #[doc(hidden)]
4532        type UnderlyingRustTuple<'a> = ();
4533        #[cfg(test)]
4534        #[allow(dead_code, unreachable_patterns)]
4535        fn _type_assertion(
4536            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4537        ) {
4538            match _t {
4539                alloy_sol_types::private::AssertTypeEq::<
4540                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4541                >(_) => {}
4542            }
4543        }
4544        #[automatically_derived]
4545        #[doc(hidden)]
4546        impl ::core::convert::From<ValidatorInactive> for UnderlyingRustTuple<'_> {
4547            fn from(value: ValidatorInactive) -> Self {
4548                ()
4549            }
4550        }
4551        #[automatically_derived]
4552        #[doc(hidden)]
4553        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ValidatorInactive {
4554            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4555                Self
4556            }
4557        }
4558        #[automatically_derived]
4559        impl alloy_sol_types::SolError for ValidatorInactive {
4560            type Parameters<'a> = UnderlyingSolTuple<'a>;
4561            type Token<'a> = <Self::Parameters<
4562                'a,
4563            > as alloy_sol_types::SolType>::Token<'a>;
4564            const SIGNATURE: &'static str = "ValidatorInactive()";
4565            const SELECTOR: [u8; 4] = [80u8, 138u8, 121u8, 63u8];
4566            #[inline]
4567            fn new<'a>(
4568                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4569            ) -> Self {
4570                tuple.into()
4571            }
4572            #[inline]
4573            fn tokenize(&self) -> Self::Token<'_> {
4574                ()
4575            }
4576            #[inline]
4577            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4578                <Self::Parameters<
4579                    '_,
4580                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4581                    .map(Self::new)
4582            }
4583        }
4584    };
4585    #[derive(serde::Serialize, serde::Deserialize)]
4586    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4587    /**Custom error with signature `ValidatorNotExited()` and selector `0xf25314a6`.
4588```solidity
4589error ValidatorNotExited();
4590```*/
4591    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4592    #[derive(Clone)]
4593    pub struct ValidatorNotExited;
4594    #[allow(
4595        non_camel_case_types,
4596        non_snake_case,
4597        clippy::pub_underscore_fields,
4598        clippy::style
4599    )]
4600    const _: () = {
4601        use alloy::sol_types as alloy_sol_types;
4602        #[doc(hidden)]
4603        #[allow(dead_code)]
4604        type UnderlyingSolTuple<'a> = ();
4605        #[doc(hidden)]
4606        type UnderlyingRustTuple<'a> = ();
4607        #[cfg(test)]
4608        #[allow(dead_code, unreachable_patterns)]
4609        fn _type_assertion(
4610            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4611        ) {
4612            match _t {
4613                alloy_sol_types::private::AssertTypeEq::<
4614                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4615                >(_) => {}
4616            }
4617        }
4618        #[automatically_derived]
4619        #[doc(hidden)]
4620        impl ::core::convert::From<ValidatorNotExited> for UnderlyingRustTuple<'_> {
4621            fn from(value: ValidatorNotExited) -> Self {
4622                ()
4623            }
4624        }
4625        #[automatically_derived]
4626        #[doc(hidden)]
4627        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ValidatorNotExited {
4628            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4629                Self
4630            }
4631        }
4632        #[automatically_derived]
4633        impl alloy_sol_types::SolError for ValidatorNotExited {
4634            type Parameters<'a> = UnderlyingSolTuple<'a>;
4635            type Token<'a> = <Self::Parameters<
4636                'a,
4637            > as alloy_sol_types::SolType>::Token<'a>;
4638            const SIGNATURE: &'static str = "ValidatorNotExited()";
4639            const SELECTOR: [u8; 4] = [242u8, 83u8, 20u8, 166u8];
4640            #[inline]
4641            fn new<'a>(
4642                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4643            ) -> Self {
4644                tuple.into()
4645            }
4646            #[inline]
4647            fn tokenize(&self) -> Self::Token<'_> {
4648                ()
4649            }
4650            #[inline]
4651            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4652                <Self::Parameters<
4653                    '_,
4654                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4655                    .map(Self::new)
4656            }
4657        }
4658    };
4659    #[derive(serde::Serialize, serde::Deserialize)]
4660    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4661    /**Custom error with signature `ZeroAddress()` and selector `0xd92e233d`.
4662```solidity
4663error ZeroAddress();
4664```*/
4665    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4666    #[derive(Clone)]
4667    pub struct ZeroAddress;
4668    #[allow(
4669        non_camel_case_types,
4670        non_snake_case,
4671        clippy::pub_underscore_fields,
4672        clippy::style
4673    )]
4674    const _: () = {
4675        use alloy::sol_types as alloy_sol_types;
4676        #[doc(hidden)]
4677        #[allow(dead_code)]
4678        type UnderlyingSolTuple<'a> = ();
4679        #[doc(hidden)]
4680        type UnderlyingRustTuple<'a> = ();
4681        #[cfg(test)]
4682        #[allow(dead_code, unreachable_patterns)]
4683        fn _type_assertion(
4684            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4685        ) {
4686            match _t {
4687                alloy_sol_types::private::AssertTypeEq::<
4688                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4689                >(_) => {}
4690            }
4691        }
4692        #[automatically_derived]
4693        #[doc(hidden)]
4694        impl ::core::convert::From<ZeroAddress> for UnderlyingRustTuple<'_> {
4695            fn from(value: ZeroAddress) -> Self {
4696                ()
4697            }
4698        }
4699        #[automatically_derived]
4700        #[doc(hidden)]
4701        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ZeroAddress {
4702            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4703                Self
4704            }
4705        }
4706        #[automatically_derived]
4707        impl alloy_sol_types::SolError for ZeroAddress {
4708            type Parameters<'a> = UnderlyingSolTuple<'a>;
4709            type Token<'a> = <Self::Parameters<
4710                'a,
4711            > as alloy_sol_types::SolType>::Token<'a>;
4712            const SIGNATURE: &'static str = "ZeroAddress()";
4713            const SELECTOR: [u8; 4] = [217u8, 46u8, 35u8, 61u8];
4714            #[inline]
4715            fn new<'a>(
4716                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4717            ) -> Self {
4718                tuple.into()
4719            }
4720            #[inline]
4721            fn tokenize(&self) -> Self::Token<'_> {
4722                ()
4723            }
4724            #[inline]
4725            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4726                <Self::Parameters<
4727                    '_,
4728                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4729                    .map(Self::new)
4730            }
4731        }
4732    };
4733    #[derive(serde::Serialize, serde::Deserialize)]
4734    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4735    /**Custom error with signature `ZeroAmount()` and selector `0x1f2a2005`.
4736```solidity
4737error ZeroAmount();
4738```*/
4739    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4740    #[derive(Clone)]
4741    pub struct ZeroAmount;
4742    #[allow(
4743        non_camel_case_types,
4744        non_snake_case,
4745        clippy::pub_underscore_fields,
4746        clippy::style
4747    )]
4748    const _: () = {
4749        use alloy::sol_types as alloy_sol_types;
4750        #[doc(hidden)]
4751        #[allow(dead_code)]
4752        type UnderlyingSolTuple<'a> = ();
4753        #[doc(hidden)]
4754        type UnderlyingRustTuple<'a> = ();
4755        #[cfg(test)]
4756        #[allow(dead_code, unreachable_patterns)]
4757        fn _type_assertion(
4758            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4759        ) {
4760            match _t {
4761                alloy_sol_types::private::AssertTypeEq::<
4762                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4763                >(_) => {}
4764            }
4765        }
4766        #[automatically_derived]
4767        #[doc(hidden)]
4768        impl ::core::convert::From<ZeroAmount> for UnderlyingRustTuple<'_> {
4769            fn from(value: ZeroAmount) -> Self {
4770                ()
4771            }
4772        }
4773        #[automatically_derived]
4774        #[doc(hidden)]
4775        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ZeroAmount {
4776            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4777                Self
4778            }
4779        }
4780        #[automatically_derived]
4781        impl alloy_sol_types::SolError for ZeroAmount {
4782            type Parameters<'a> = UnderlyingSolTuple<'a>;
4783            type Token<'a> = <Self::Parameters<
4784                'a,
4785            > as alloy_sol_types::SolType>::Token<'a>;
4786            const SIGNATURE: &'static str = "ZeroAmount()";
4787            const SELECTOR: [u8; 4] = [31u8, 42u8, 32u8, 5u8];
4788            #[inline]
4789            fn new<'a>(
4790                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4791            ) -> Self {
4792                tuple.into()
4793            }
4794            #[inline]
4795            fn tokenize(&self) -> Self::Token<'_> {
4796                ()
4797            }
4798            #[inline]
4799            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4800                <Self::Parameters<
4801                    '_,
4802                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4803                    .map(Self::new)
4804            }
4805        }
4806    };
4807    #[derive(serde::Serialize, serde::Deserialize)]
4808    #[derive()]
4809    /**Event with signature `ConsensusKeysUpdated(address,(uint256,uint256,uint256,uint256),(uint256,uint256))` and selector `0x80d8a4a1663328a998d4555ba21d8bba6ef1576a8c5e9d27f9c545f1a3d52b1d`.
4810```solidity
4811event ConsensusKeysUpdated(address indexed account, BN254.G2Point blsVK, EdOnBN254.EdOnBN254Point schnorrVK);
4812```*/
4813    #[allow(
4814        non_camel_case_types,
4815        non_snake_case,
4816        clippy::pub_underscore_fields,
4817        clippy::style
4818    )]
4819    #[derive(Clone)]
4820    pub struct ConsensusKeysUpdated {
4821        #[allow(missing_docs)]
4822        pub account: alloy::sol_types::private::Address,
4823        #[allow(missing_docs)]
4824        pub blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
4825        #[allow(missing_docs)]
4826        pub schnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
4827    }
4828    #[allow(
4829        non_camel_case_types,
4830        non_snake_case,
4831        clippy::pub_underscore_fields,
4832        clippy::style
4833    )]
4834    const _: () = {
4835        use alloy::sol_types as alloy_sol_types;
4836        #[automatically_derived]
4837        impl alloy_sol_types::SolEvent for ConsensusKeysUpdated {
4838            type DataTuple<'a> = (BN254::G2Point, EdOnBN254::EdOnBN254Point);
4839            type DataToken<'a> = <Self::DataTuple<
4840                'a,
4841            > as alloy_sol_types::SolType>::Token<'a>;
4842            type TopicList = (
4843                alloy_sol_types::sol_data::FixedBytes<32>,
4844                alloy::sol_types::sol_data::Address,
4845            );
4846            const SIGNATURE: &'static str = "ConsensusKeysUpdated(address,(uint256,uint256,uint256,uint256),(uint256,uint256))";
4847            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
4848                128u8, 216u8, 164u8, 161u8, 102u8, 51u8, 40u8, 169u8, 152u8, 212u8, 85u8,
4849                91u8, 162u8, 29u8, 139u8, 186u8, 110u8, 241u8, 87u8, 106u8, 140u8, 94u8,
4850                157u8, 39u8, 249u8, 197u8, 69u8, 241u8, 163u8, 213u8, 43u8, 29u8,
4851            ]);
4852            const ANONYMOUS: bool = false;
4853            #[allow(unused_variables)]
4854            #[inline]
4855            fn new(
4856                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4857                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4858            ) -> Self {
4859                Self {
4860                    account: topics.1,
4861                    blsVK: data.0,
4862                    schnorrVK: data.1,
4863                }
4864            }
4865            #[inline]
4866            fn check_signature(
4867                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4868            ) -> alloy_sol_types::Result<()> {
4869                if topics.0 != Self::SIGNATURE_HASH {
4870                    return Err(
4871                        alloy_sol_types::Error::invalid_event_signature_hash(
4872                            Self::SIGNATURE,
4873                            topics.0,
4874                            Self::SIGNATURE_HASH,
4875                        ),
4876                    );
4877                }
4878                Ok(())
4879            }
4880            #[inline]
4881            fn tokenize_body(&self) -> Self::DataToken<'_> {
4882                (
4883                    <BN254::G2Point as alloy_sol_types::SolType>::tokenize(&self.blsVK),
4884                    <EdOnBN254::EdOnBN254Point as alloy_sol_types::SolType>::tokenize(
4885                        &self.schnorrVK,
4886                    ),
4887                )
4888            }
4889            #[inline]
4890            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4891                (Self::SIGNATURE_HASH.into(), self.account.clone())
4892            }
4893            #[inline]
4894            fn encode_topics_raw(
4895                &self,
4896                out: &mut [alloy_sol_types::abi::token::WordToken],
4897            ) -> alloy_sol_types::Result<()> {
4898                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4899                    return Err(alloy_sol_types::Error::Overrun);
4900                }
4901                out[0usize] = alloy_sol_types::abi::token::WordToken(
4902                    Self::SIGNATURE_HASH,
4903                );
4904                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4905                    &self.account,
4906                );
4907                Ok(())
4908            }
4909        }
4910        #[automatically_derived]
4911        impl alloy_sol_types::private::IntoLogData for ConsensusKeysUpdated {
4912            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4913                From::from(self)
4914            }
4915            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4916                From::from(&self)
4917            }
4918        }
4919        #[automatically_derived]
4920        impl From<&ConsensusKeysUpdated> for alloy_sol_types::private::LogData {
4921            #[inline]
4922            fn from(this: &ConsensusKeysUpdated) -> alloy_sol_types::private::LogData {
4923                alloy_sol_types::SolEvent::encode_log_data(this)
4924            }
4925        }
4926    };
4927    #[derive(serde::Serialize, serde::Deserialize)]
4928    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4929    /**Event with signature `Delegated(address,address,uint256)` and selector `0xe5541a6b6103d4fa7e021ed54fad39c66f27a76bd13d374cf6240ae6bd0bb72b`.
4930```solidity
4931event Delegated(address indexed delegator, address indexed validator, uint256 amount);
4932```*/
4933    #[allow(
4934        non_camel_case_types,
4935        non_snake_case,
4936        clippy::pub_underscore_fields,
4937        clippy::style
4938    )]
4939    #[derive(Clone)]
4940    pub struct Delegated {
4941        #[allow(missing_docs)]
4942        pub delegator: alloy::sol_types::private::Address,
4943        #[allow(missing_docs)]
4944        pub validator: alloy::sol_types::private::Address,
4945        #[allow(missing_docs)]
4946        pub amount: alloy::sol_types::private::primitives::aliases::U256,
4947    }
4948    #[allow(
4949        non_camel_case_types,
4950        non_snake_case,
4951        clippy::pub_underscore_fields,
4952        clippy::style
4953    )]
4954    const _: () = {
4955        use alloy::sol_types as alloy_sol_types;
4956        #[automatically_derived]
4957        impl alloy_sol_types::SolEvent for Delegated {
4958            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4959            type DataToken<'a> = <Self::DataTuple<
4960                'a,
4961            > as alloy_sol_types::SolType>::Token<'a>;
4962            type TopicList = (
4963                alloy_sol_types::sol_data::FixedBytes<32>,
4964                alloy::sol_types::sol_data::Address,
4965                alloy::sol_types::sol_data::Address,
4966            );
4967            const SIGNATURE: &'static str = "Delegated(address,address,uint256)";
4968            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
4969                229u8, 84u8, 26u8, 107u8, 97u8, 3u8, 212u8, 250u8, 126u8, 2u8, 30u8,
4970                213u8, 79u8, 173u8, 57u8, 198u8, 111u8, 39u8, 167u8, 107u8, 209u8, 61u8,
4971                55u8, 76u8, 246u8, 36u8, 10u8, 230u8, 189u8, 11u8, 183u8, 43u8,
4972            ]);
4973            const ANONYMOUS: bool = false;
4974            #[allow(unused_variables)]
4975            #[inline]
4976            fn new(
4977                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4978                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4979            ) -> Self {
4980                Self {
4981                    delegator: topics.1,
4982                    validator: topics.2,
4983                    amount: data.0,
4984                }
4985            }
4986            #[inline]
4987            fn check_signature(
4988                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4989            ) -> alloy_sol_types::Result<()> {
4990                if topics.0 != Self::SIGNATURE_HASH {
4991                    return Err(
4992                        alloy_sol_types::Error::invalid_event_signature_hash(
4993                            Self::SIGNATURE,
4994                            topics.0,
4995                            Self::SIGNATURE_HASH,
4996                        ),
4997                    );
4998                }
4999                Ok(())
5000            }
5001            #[inline]
5002            fn tokenize_body(&self) -> Self::DataToken<'_> {
5003                (
5004                    <alloy::sol_types::sol_data::Uint<
5005                        256,
5006                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
5007                )
5008            }
5009            #[inline]
5010            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5011                (
5012                    Self::SIGNATURE_HASH.into(),
5013                    self.delegator.clone(),
5014                    self.validator.clone(),
5015                )
5016            }
5017            #[inline]
5018            fn encode_topics_raw(
5019                &self,
5020                out: &mut [alloy_sol_types::abi::token::WordToken],
5021            ) -> alloy_sol_types::Result<()> {
5022                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5023                    return Err(alloy_sol_types::Error::Overrun);
5024                }
5025                out[0usize] = alloy_sol_types::abi::token::WordToken(
5026                    Self::SIGNATURE_HASH,
5027                );
5028                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5029                    &self.delegator,
5030                );
5031                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5032                    &self.validator,
5033                );
5034                Ok(())
5035            }
5036        }
5037        #[automatically_derived]
5038        impl alloy_sol_types::private::IntoLogData for Delegated {
5039            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5040                From::from(self)
5041            }
5042            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5043                From::from(&self)
5044            }
5045        }
5046        #[automatically_derived]
5047        impl From<&Delegated> for alloy_sol_types::private::LogData {
5048            #[inline]
5049            fn from(this: &Delegated) -> alloy_sol_types::private::LogData {
5050                alloy_sol_types::SolEvent::encode_log_data(this)
5051            }
5052        }
5053    };
5054    #[derive(serde::Serialize, serde::Deserialize)]
5055    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5056    /**Event with signature `Initialized(uint64)` and selector `0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2`.
5057```solidity
5058event Initialized(uint64 version);
5059```*/
5060    #[allow(
5061        non_camel_case_types,
5062        non_snake_case,
5063        clippy::pub_underscore_fields,
5064        clippy::style
5065    )]
5066    #[derive(Clone)]
5067    pub struct Initialized {
5068        #[allow(missing_docs)]
5069        pub version: u64,
5070    }
5071    #[allow(
5072        non_camel_case_types,
5073        non_snake_case,
5074        clippy::pub_underscore_fields,
5075        clippy::style
5076    )]
5077    const _: () = {
5078        use alloy::sol_types as alloy_sol_types;
5079        #[automatically_derived]
5080        impl alloy_sol_types::SolEvent for Initialized {
5081            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
5082            type DataToken<'a> = <Self::DataTuple<
5083                'a,
5084            > as alloy_sol_types::SolType>::Token<'a>;
5085            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5086            const SIGNATURE: &'static str = "Initialized(uint64)";
5087            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5088                199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
5089                19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
5090                33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
5091            ]);
5092            const ANONYMOUS: bool = false;
5093            #[allow(unused_variables)]
5094            #[inline]
5095            fn new(
5096                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5097                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5098            ) -> Self {
5099                Self { version: data.0 }
5100            }
5101            #[inline]
5102            fn check_signature(
5103                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5104            ) -> alloy_sol_types::Result<()> {
5105                if topics.0 != Self::SIGNATURE_HASH {
5106                    return Err(
5107                        alloy_sol_types::Error::invalid_event_signature_hash(
5108                            Self::SIGNATURE,
5109                            topics.0,
5110                            Self::SIGNATURE_HASH,
5111                        ),
5112                    );
5113                }
5114                Ok(())
5115            }
5116            #[inline]
5117            fn tokenize_body(&self) -> Self::DataToken<'_> {
5118                (
5119                    <alloy::sol_types::sol_data::Uint<
5120                        64,
5121                    > as alloy_sol_types::SolType>::tokenize(&self.version),
5122                )
5123            }
5124            #[inline]
5125            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5126                (Self::SIGNATURE_HASH.into(),)
5127            }
5128            #[inline]
5129            fn encode_topics_raw(
5130                &self,
5131                out: &mut [alloy_sol_types::abi::token::WordToken],
5132            ) -> alloy_sol_types::Result<()> {
5133                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5134                    return Err(alloy_sol_types::Error::Overrun);
5135                }
5136                out[0usize] = alloy_sol_types::abi::token::WordToken(
5137                    Self::SIGNATURE_HASH,
5138                );
5139                Ok(())
5140            }
5141        }
5142        #[automatically_derived]
5143        impl alloy_sol_types::private::IntoLogData for Initialized {
5144            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5145                From::from(self)
5146            }
5147            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5148                From::from(&self)
5149            }
5150        }
5151        #[automatically_derived]
5152        impl From<&Initialized> for alloy_sol_types::private::LogData {
5153            #[inline]
5154            fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
5155                alloy_sol_types::SolEvent::encode_log_data(this)
5156            }
5157        }
5158    };
5159    #[derive(serde::Serialize, serde::Deserialize)]
5160    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5161    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
5162```solidity
5163event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
5164```*/
5165    #[allow(
5166        non_camel_case_types,
5167        non_snake_case,
5168        clippy::pub_underscore_fields,
5169        clippy::style
5170    )]
5171    #[derive(Clone)]
5172    pub struct OwnershipTransferred {
5173        #[allow(missing_docs)]
5174        pub previousOwner: alloy::sol_types::private::Address,
5175        #[allow(missing_docs)]
5176        pub newOwner: alloy::sol_types::private::Address,
5177    }
5178    #[allow(
5179        non_camel_case_types,
5180        non_snake_case,
5181        clippy::pub_underscore_fields,
5182        clippy::style
5183    )]
5184    const _: () = {
5185        use alloy::sol_types as alloy_sol_types;
5186        #[automatically_derived]
5187        impl alloy_sol_types::SolEvent for OwnershipTransferred {
5188            type DataTuple<'a> = ();
5189            type DataToken<'a> = <Self::DataTuple<
5190                'a,
5191            > as alloy_sol_types::SolType>::Token<'a>;
5192            type TopicList = (
5193                alloy_sol_types::sol_data::FixedBytes<32>,
5194                alloy::sol_types::sol_data::Address,
5195                alloy::sol_types::sol_data::Address,
5196            );
5197            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
5198            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5199                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
5200                31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
5201                218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
5202            ]);
5203            const ANONYMOUS: bool = false;
5204            #[allow(unused_variables)]
5205            #[inline]
5206            fn new(
5207                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5208                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5209            ) -> Self {
5210                Self {
5211                    previousOwner: topics.1,
5212                    newOwner: topics.2,
5213                }
5214            }
5215            #[inline]
5216            fn check_signature(
5217                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5218            ) -> alloy_sol_types::Result<()> {
5219                if topics.0 != Self::SIGNATURE_HASH {
5220                    return Err(
5221                        alloy_sol_types::Error::invalid_event_signature_hash(
5222                            Self::SIGNATURE,
5223                            topics.0,
5224                            Self::SIGNATURE_HASH,
5225                        ),
5226                    );
5227                }
5228                Ok(())
5229            }
5230            #[inline]
5231            fn tokenize_body(&self) -> Self::DataToken<'_> {
5232                ()
5233            }
5234            #[inline]
5235            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5236                (
5237                    Self::SIGNATURE_HASH.into(),
5238                    self.previousOwner.clone(),
5239                    self.newOwner.clone(),
5240                )
5241            }
5242            #[inline]
5243            fn encode_topics_raw(
5244                &self,
5245                out: &mut [alloy_sol_types::abi::token::WordToken],
5246            ) -> alloy_sol_types::Result<()> {
5247                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5248                    return Err(alloy_sol_types::Error::Overrun);
5249                }
5250                out[0usize] = alloy_sol_types::abi::token::WordToken(
5251                    Self::SIGNATURE_HASH,
5252                );
5253                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5254                    &self.previousOwner,
5255                );
5256                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5257                    &self.newOwner,
5258                );
5259                Ok(())
5260            }
5261        }
5262        #[automatically_derived]
5263        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
5264            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5265                From::from(self)
5266            }
5267            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5268                From::from(&self)
5269            }
5270        }
5271        #[automatically_derived]
5272        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
5273            #[inline]
5274            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
5275                alloy_sol_types::SolEvent::encode_log_data(this)
5276            }
5277        }
5278    };
5279    #[derive(serde::Serialize, serde::Deserialize)]
5280    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5281    /**Event with signature `Undelegated(address,address,uint256)` and selector `0x4d10bd049775c77bd7f255195afba5088028ecb3c7c277d393ccff7934f2f92c`.
5282```solidity
5283event Undelegated(address indexed delegator, address indexed validator, uint256 amount);
5284```*/
5285    #[allow(
5286        non_camel_case_types,
5287        non_snake_case,
5288        clippy::pub_underscore_fields,
5289        clippy::style
5290    )]
5291    #[derive(Clone)]
5292    pub struct Undelegated {
5293        #[allow(missing_docs)]
5294        pub delegator: alloy::sol_types::private::Address,
5295        #[allow(missing_docs)]
5296        pub validator: alloy::sol_types::private::Address,
5297        #[allow(missing_docs)]
5298        pub amount: alloy::sol_types::private::primitives::aliases::U256,
5299    }
5300    #[allow(
5301        non_camel_case_types,
5302        non_snake_case,
5303        clippy::pub_underscore_fields,
5304        clippy::style
5305    )]
5306    const _: () = {
5307        use alloy::sol_types as alloy_sol_types;
5308        #[automatically_derived]
5309        impl alloy_sol_types::SolEvent for Undelegated {
5310            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5311            type DataToken<'a> = <Self::DataTuple<
5312                'a,
5313            > as alloy_sol_types::SolType>::Token<'a>;
5314            type TopicList = (
5315                alloy_sol_types::sol_data::FixedBytes<32>,
5316                alloy::sol_types::sol_data::Address,
5317                alloy::sol_types::sol_data::Address,
5318            );
5319            const SIGNATURE: &'static str = "Undelegated(address,address,uint256)";
5320            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5321                77u8, 16u8, 189u8, 4u8, 151u8, 117u8, 199u8, 123u8, 215u8, 242u8, 85u8,
5322                25u8, 90u8, 251u8, 165u8, 8u8, 128u8, 40u8, 236u8, 179u8, 199u8, 194u8,
5323                119u8, 211u8, 147u8, 204u8, 255u8, 121u8, 52u8, 242u8, 249u8, 44u8,
5324            ]);
5325            const ANONYMOUS: bool = false;
5326            #[allow(unused_variables)]
5327            #[inline]
5328            fn new(
5329                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5330                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5331            ) -> Self {
5332                Self {
5333                    delegator: topics.1,
5334                    validator: topics.2,
5335                    amount: data.0,
5336                }
5337            }
5338            #[inline]
5339            fn check_signature(
5340                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5341            ) -> alloy_sol_types::Result<()> {
5342                if topics.0 != Self::SIGNATURE_HASH {
5343                    return Err(
5344                        alloy_sol_types::Error::invalid_event_signature_hash(
5345                            Self::SIGNATURE,
5346                            topics.0,
5347                            Self::SIGNATURE_HASH,
5348                        ),
5349                    );
5350                }
5351                Ok(())
5352            }
5353            #[inline]
5354            fn tokenize_body(&self) -> Self::DataToken<'_> {
5355                (
5356                    <alloy::sol_types::sol_data::Uint<
5357                        256,
5358                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
5359                )
5360            }
5361            #[inline]
5362            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5363                (
5364                    Self::SIGNATURE_HASH.into(),
5365                    self.delegator.clone(),
5366                    self.validator.clone(),
5367                )
5368            }
5369            #[inline]
5370            fn encode_topics_raw(
5371                &self,
5372                out: &mut [alloy_sol_types::abi::token::WordToken],
5373            ) -> alloy_sol_types::Result<()> {
5374                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5375                    return Err(alloy_sol_types::Error::Overrun);
5376                }
5377                out[0usize] = alloy_sol_types::abi::token::WordToken(
5378                    Self::SIGNATURE_HASH,
5379                );
5380                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5381                    &self.delegator,
5382                );
5383                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5384                    &self.validator,
5385                );
5386                Ok(())
5387            }
5388        }
5389        #[automatically_derived]
5390        impl alloy_sol_types::private::IntoLogData for Undelegated {
5391            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5392                From::from(self)
5393            }
5394            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5395                From::from(&self)
5396            }
5397        }
5398        #[automatically_derived]
5399        impl From<&Undelegated> for alloy_sol_types::private::LogData {
5400            #[inline]
5401            fn from(this: &Undelegated) -> alloy_sol_types::private::LogData {
5402                alloy_sol_types::SolEvent::encode_log_data(this)
5403            }
5404        }
5405    };
5406    #[derive(serde::Serialize, serde::Deserialize)]
5407    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5408    /**Event with signature `Upgraded(address)` and selector `0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b`.
5409```solidity
5410event Upgraded(address indexed implementation);
5411```*/
5412    #[allow(
5413        non_camel_case_types,
5414        non_snake_case,
5415        clippy::pub_underscore_fields,
5416        clippy::style
5417    )]
5418    #[derive(Clone)]
5419    pub struct Upgraded {
5420        #[allow(missing_docs)]
5421        pub implementation: alloy::sol_types::private::Address,
5422    }
5423    #[allow(
5424        non_camel_case_types,
5425        non_snake_case,
5426        clippy::pub_underscore_fields,
5427        clippy::style
5428    )]
5429    const _: () = {
5430        use alloy::sol_types as alloy_sol_types;
5431        #[automatically_derived]
5432        impl alloy_sol_types::SolEvent for Upgraded {
5433            type DataTuple<'a> = ();
5434            type DataToken<'a> = <Self::DataTuple<
5435                'a,
5436            > as alloy_sol_types::SolType>::Token<'a>;
5437            type TopicList = (
5438                alloy_sol_types::sol_data::FixedBytes<32>,
5439                alloy::sol_types::sol_data::Address,
5440            );
5441            const SIGNATURE: &'static str = "Upgraded(address)";
5442            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5443                188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
5444                179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8,
5445                12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
5446            ]);
5447            const ANONYMOUS: bool = false;
5448            #[allow(unused_variables)]
5449            #[inline]
5450            fn new(
5451                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5452                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5453            ) -> Self {
5454                Self { implementation: topics.1 }
5455            }
5456            #[inline]
5457            fn check_signature(
5458                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5459            ) -> alloy_sol_types::Result<()> {
5460                if topics.0 != Self::SIGNATURE_HASH {
5461                    return Err(
5462                        alloy_sol_types::Error::invalid_event_signature_hash(
5463                            Self::SIGNATURE,
5464                            topics.0,
5465                            Self::SIGNATURE_HASH,
5466                        ),
5467                    );
5468                }
5469                Ok(())
5470            }
5471            #[inline]
5472            fn tokenize_body(&self) -> Self::DataToken<'_> {
5473                ()
5474            }
5475            #[inline]
5476            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5477                (Self::SIGNATURE_HASH.into(), self.implementation.clone())
5478            }
5479            #[inline]
5480            fn encode_topics_raw(
5481                &self,
5482                out: &mut [alloy_sol_types::abi::token::WordToken],
5483            ) -> alloy_sol_types::Result<()> {
5484                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5485                    return Err(alloy_sol_types::Error::Overrun);
5486                }
5487                out[0usize] = alloy_sol_types::abi::token::WordToken(
5488                    Self::SIGNATURE_HASH,
5489                );
5490                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5491                    &self.implementation,
5492                );
5493                Ok(())
5494            }
5495        }
5496        #[automatically_derived]
5497        impl alloy_sol_types::private::IntoLogData for Upgraded {
5498            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5499                From::from(self)
5500            }
5501            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5502                From::from(&self)
5503            }
5504        }
5505        #[automatically_derived]
5506        impl From<&Upgraded> for alloy_sol_types::private::LogData {
5507            #[inline]
5508            fn from(this: &Upgraded) -> alloy_sol_types::private::LogData {
5509                alloy_sol_types::SolEvent::encode_log_data(this)
5510            }
5511        }
5512    };
5513    #[derive(serde::Serialize, serde::Deserialize)]
5514    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5515    /**Event with signature `ValidatorExit(address)` and selector `0xfb24305354c87762d557487ae4a564e8d03ecbb9a97dd8afff8e1f6fcaf0dd16`.
5516```solidity
5517event ValidatorExit(address indexed validator);
5518```*/
5519    #[allow(
5520        non_camel_case_types,
5521        non_snake_case,
5522        clippy::pub_underscore_fields,
5523        clippy::style
5524    )]
5525    #[derive(Clone)]
5526    pub struct ValidatorExit {
5527        #[allow(missing_docs)]
5528        pub validator: alloy::sol_types::private::Address,
5529    }
5530    #[allow(
5531        non_camel_case_types,
5532        non_snake_case,
5533        clippy::pub_underscore_fields,
5534        clippy::style
5535    )]
5536    const _: () = {
5537        use alloy::sol_types as alloy_sol_types;
5538        #[automatically_derived]
5539        impl alloy_sol_types::SolEvent for ValidatorExit {
5540            type DataTuple<'a> = ();
5541            type DataToken<'a> = <Self::DataTuple<
5542                'a,
5543            > as alloy_sol_types::SolType>::Token<'a>;
5544            type TopicList = (
5545                alloy_sol_types::sol_data::FixedBytes<32>,
5546                alloy::sol_types::sol_data::Address,
5547            );
5548            const SIGNATURE: &'static str = "ValidatorExit(address)";
5549            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5550                251u8, 36u8, 48u8, 83u8, 84u8, 200u8, 119u8, 98u8, 213u8, 87u8, 72u8,
5551                122u8, 228u8, 165u8, 100u8, 232u8, 208u8, 62u8, 203u8, 185u8, 169u8,
5552                125u8, 216u8, 175u8, 255u8, 142u8, 31u8, 111u8, 202u8, 240u8, 221u8, 22u8,
5553            ]);
5554            const ANONYMOUS: bool = false;
5555            #[allow(unused_variables)]
5556            #[inline]
5557            fn new(
5558                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5559                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5560            ) -> Self {
5561                Self { validator: topics.1 }
5562            }
5563            #[inline]
5564            fn check_signature(
5565                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5566            ) -> alloy_sol_types::Result<()> {
5567                if topics.0 != Self::SIGNATURE_HASH {
5568                    return Err(
5569                        alloy_sol_types::Error::invalid_event_signature_hash(
5570                            Self::SIGNATURE,
5571                            topics.0,
5572                            Self::SIGNATURE_HASH,
5573                        ),
5574                    );
5575                }
5576                Ok(())
5577            }
5578            #[inline]
5579            fn tokenize_body(&self) -> Self::DataToken<'_> {
5580                ()
5581            }
5582            #[inline]
5583            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5584                (Self::SIGNATURE_HASH.into(), self.validator.clone())
5585            }
5586            #[inline]
5587            fn encode_topics_raw(
5588                &self,
5589                out: &mut [alloy_sol_types::abi::token::WordToken],
5590            ) -> alloy_sol_types::Result<()> {
5591                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5592                    return Err(alloy_sol_types::Error::Overrun);
5593                }
5594                out[0usize] = alloy_sol_types::abi::token::WordToken(
5595                    Self::SIGNATURE_HASH,
5596                );
5597                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5598                    &self.validator,
5599                );
5600                Ok(())
5601            }
5602        }
5603        #[automatically_derived]
5604        impl alloy_sol_types::private::IntoLogData for ValidatorExit {
5605            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5606                From::from(self)
5607            }
5608            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5609                From::from(&self)
5610            }
5611        }
5612        #[automatically_derived]
5613        impl From<&ValidatorExit> for alloy_sol_types::private::LogData {
5614            #[inline]
5615            fn from(this: &ValidatorExit) -> alloy_sol_types::private::LogData {
5616                alloy_sol_types::SolEvent::encode_log_data(this)
5617            }
5618        }
5619    };
5620    #[derive(serde::Serialize, serde::Deserialize)]
5621    #[derive()]
5622    /**Event with signature `ValidatorRegistered(address,(uint256,uint256,uint256,uint256),(uint256,uint256),uint16)` and selector `0xf6e8359c57520b469634736bfc3bb7ec5cbd1a0bd28b10a8275793bb730b797f`.
5623```solidity
5624event ValidatorRegistered(address indexed account, BN254.G2Point blsVk, EdOnBN254.EdOnBN254Point schnorrVk, uint16 commission);
5625```*/
5626    #[allow(
5627        non_camel_case_types,
5628        non_snake_case,
5629        clippy::pub_underscore_fields,
5630        clippy::style
5631    )]
5632    #[derive(Clone)]
5633    pub struct ValidatorRegistered {
5634        #[allow(missing_docs)]
5635        pub account: alloy::sol_types::private::Address,
5636        #[allow(missing_docs)]
5637        pub blsVk: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
5638        #[allow(missing_docs)]
5639        pub schnorrVk: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
5640        #[allow(missing_docs)]
5641        pub commission: u16,
5642    }
5643    #[allow(
5644        non_camel_case_types,
5645        non_snake_case,
5646        clippy::pub_underscore_fields,
5647        clippy::style
5648    )]
5649    const _: () = {
5650        use alloy::sol_types as alloy_sol_types;
5651        #[automatically_derived]
5652        impl alloy_sol_types::SolEvent for ValidatorRegistered {
5653            type DataTuple<'a> = (
5654                BN254::G2Point,
5655                EdOnBN254::EdOnBN254Point,
5656                alloy::sol_types::sol_data::Uint<16>,
5657            );
5658            type DataToken<'a> = <Self::DataTuple<
5659                'a,
5660            > as alloy_sol_types::SolType>::Token<'a>;
5661            type TopicList = (
5662                alloy_sol_types::sol_data::FixedBytes<32>,
5663                alloy::sol_types::sol_data::Address,
5664            );
5665            const SIGNATURE: &'static str = "ValidatorRegistered(address,(uint256,uint256,uint256,uint256),(uint256,uint256),uint16)";
5666            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5667                246u8, 232u8, 53u8, 156u8, 87u8, 82u8, 11u8, 70u8, 150u8, 52u8, 115u8,
5668                107u8, 252u8, 59u8, 183u8, 236u8, 92u8, 189u8, 26u8, 11u8, 210u8, 139u8,
5669                16u8, 168u8, 39u8, 87u8, 147u8, 187u8, 115u8, 11u8, 121u8, 127u8,
5670            ]);
5671            const ANONYMOUS: bool = false;
5672            #[allow(unused_variables)]
5673            #[inline]
5674            fn new(
5675                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5676                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5677            ) -> Self {
5678                Self {
5679                    account: topics.1,
5680                    blsVk: data.0,
5681                    schnorrVk: data.1,
5682                    commission: data.2,
5683                }
5684            }
5685            #[inline]
5686            fn check_signature(
5687                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5688            ) -> alloy_sol_types::Result<()> {
5689                if topics.0 != Self::SIGNATURE_HASH {
5690                    return Err(
5691                        alloy_sol_types::Error::invalid_event_signature_hash(
5692                            Self::SIGNATURE,
5693                            topics.0,
5694                            Self::SIGNATURE_HASH,
5695                        ),
5696                    );
5697                }
5698                Ok(())
5699            }
5700            #[inline]
5701            fn tokenize_body(&self) -> Self::DataToken<'_> {
5702                (
5703                    <BN254::G2Point as alloy_sol_types::SolType>::tokenize(&self.blsVk),
5704                    <EdOnBN254::EdOnBN254Point as alloy_sol_types::SolType>::tokenize(
5705                        &self.schnorrVk,
5706                    ),
5707                    <alloy::sol_types::sol_data::Uint<
5708                        16,
5709                    > as alloy_sol_types::SolType>::tokenize(&self.commission),
5710                )
5711            }
5712            #[inline]
5713            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5714                (Self::SIGNATURE_HASH.into(), self.account.clone())
5715            }
5716            #[inline]
5717            fn encode_topics_raw(
5718                &self,
5719                out: &mut [alloy_sol_types::abi::token::WordToken],
5720            ) -> alloy_sol_types::Result<()> {
5721                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5722                    return Err(alloy_sol_types::Error::Overrun);
5723                }
5724                out[0usize] = alloy_sol_types::abi::token::WordToken(
5725                    Self::SIGNATURE_HASH,
5726                );
5727                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5728                    &self.account,
5729                );
5730                Ok(())
5731            }
5732        }
5733        #[automatically_derived]
5734        impl alloy_sol_types::private::IntoLogData for ValidatorRegistered {
5735            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5736                From::from(self)
5737            }
5738            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5739                From::from(&self)
5740            }
5741        }
5742        #[automatically_derived]
5743        impl From<&ValidatorRegistered> for alloy_sol_types::private::LogData {
5744            #[inline]
5745            fn from(this: &ValidatorRegistered) -> alloy_sol_types::private::LogData {
5746                alloy_sol_types::SolEvent::encode_log_data(this)
5747            }
5748        }
5749    };
5750    #[derive(serde::Serialize, serde::Deserialize)]
5751    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5752    /**Event with signature `Withdrawal(address,uint256)` and selector `0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65`.
5753```solidity
5754event Withdrawal(address indexed account, uint256 amount);
5755```*/
5756    #[allow(
5757        non_camel_case_types,
5758        non_snake_case,
5759        clippy::pub_underscore_fields,
5760        clippy::style
5761    )]
5762    #[derive(Clone)]
5763    pub struct Withdrawal {
5764        #[allow(missing_docs)]
5765        pub account: alloy::sol_types::private::Address,
5766        #[allow(missing_docs)]
5767        pub amount: alloy::sol_types::private::primitives::aliases::U256,
5768    }
5769    #[allow(
5770        non_camel_case_types,
5771        non_snake_case,
5772        clippy::pub_underscore_fields,
5773        clippy::style
5774    )]
5775    const _: () = {
5776        use alloy::sol_types as alloy_sol_types;
5777        #[automatically_derived]
5778        impl alloy_sol_types::SolEvent for Withdrawal {
5779            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5780            type DataToken<'a> = <Self::DataTuple<
5781                'a,
5782            > as alloy_sol_types::SolType>::Token<'a>;
5783            type TopicList = (
5784                alloy_sol_types::sol_data::FixedBytes<32>,
5785                alloy::sol_types::sol_data::Address,
5786            );
5787            const SIGNATURE: &'static str = "Withdrawal(address,uint256)";
5788            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5789                127u8, 207u8, 83u8, 44u8, 21u8, 240u8, 166u8, 219u8, 11u8, 214u8, 208u8,
5790                224u8, 56u8, 190u8, 167u8, 29u8, 48u8, 216u8, 8u8, 199u8, 217u8, 140u8,
5791                179u8, 191u8, 114u8, 104u8, 169u8, 91u8, 245u8, 8u8, 27u8, 101u8,
5792            ]);
5793            const ANONYMOUS: bool = false;
5794            #[allow(unused_variables)]
5795            #[inline]
5796            fn new(
5797                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5798                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5799            ) -> Self {
5800                Self {
5801                    account: topics.1,
5802                    amount: data.0,
5803                }
5804            }
5805            #[inline]
5806            fn check_signature(
5807                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5808            ) -> alloy_sol_types::Result<()> {
5809                if topics.0 != Self::SIGNATURE_HASH {
5810                    return Err(
5811                        alloy_sol_types::Error::invalid_event_signature_hash(
5812                            Self::SIGNATURE,
5813                            topics.0,
5814                            Self::SIGNATURE_HASH,
5815                        ),
5816                    );
5817                }
5818                Ok(())
5819            }
5820            #[inline]
5821            fn tokenize_body(&self) -> Self::DataToken<'_> {
5822                (
5823                    <alloy::sol_types::sol_data::Uint<
5824                        256,
5825                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
5826                )
5827            }
5828            #[inline]
5829            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5830                (Self::SIGNATURE_HASH.into(), self.account.clone())
5831            }
5832            #[inline]
5833            fn encode_topics_raw(
5834                &self,
5835                out: &mut [alloy_sol_types::abi::token::WordToken],
5836            ) -> alloy_sol_types::Result<()> {
5837                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5838                    return Err(alloy_sol_types::Error::Overrun);
5839                }
5840                out[0usize] = alloy_sol_types::abi::token::WordToken(
5841                    Self::SIGNATURE_HASH,
5842                );
5843                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5844                    &self.account,
5845                );
5846                Ok(())
5847            }
5848        }
5849        #[automatically_derived]
5850        impl alloy_sol_types::private::IntoLogData for Withdrawal {
5851            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5852                From::from(self)
5853            }
5854            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5855                From::from(&self)
5856            }
5857        }
5858        #[automatically_derived]
5859        impl From<&Withdrawal> for alloy_sol_types::private::LogData {
5860            #[inline]
5861            fn from(this: &Withdrawal) -> alloy_sol_types::private::LogData {
5862                alloy_sol_types::SolEvent::encode_log_data(this)
5863            }
5864        }
5865    };
5866    /**Constructor`.
5867```solidity
5868constructor();
5869```*/
5870    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5871    #[derive(Clone)]
5872    pub struct constructorCall {}
5873    const _: () = {
5874        use alloy::sol_types as alloy_sol_types;
5875        {
5876            #[doc(hidden)]
5877            #[allow(dead_code)]
5878            type UnderlyingSolTuple<'a> = ();
5879            #[doc(hidden)]
5880            type UnderlyingRustTuple<'a> = ();
5881            #[cfg(test)]
5882            #[allow(dead_code, unreachable_patterns)]
5883            fn _type_assertion(
5884                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5885            ) {
5886                match _t {
5887                    alloy_sol_types::private::AssertTypeEq::<
5888                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5889                    >(_) => {}
5890                }
5891            }
5892            #[automatically_derived]
5893            #[doc(hidden)]
5894            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
5895                fn from(value: constructorCall) -> Self {
5896                    ()
5897                }
5898            }
5899            #[automatically_derived]
5900            #[doc(hidden)]
5901            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
5902                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5903                    Self {}
5904                }
5905            }
5906        }
5907        #[automatically_derived]
5908        impl alloy_sol_types::SolConstructor for constructorCall {
5909            type Parameters<'a> = ();
5910            type Token<'a> = <Self::Parameters<
5911                'a,
5912            > as alloy_sol_types::SolType>::Token<'a>;
5913            #[inline]
5914            fn new<'a>(
5915                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5916            ) -> Self {
5917                tuple.into()
5918            }
5919            #[inline]
5920            fn tokenize(&self) -> Self::Token<'_> {
5921                ()
5922            }
5923        }
5924    };
5925    #[derive(serde::Serialize, serde::Deserialize)]
5926    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5927    /**Function with signature `UPGRADE_INTERFACE_VERSION()` and selector `0xad3cb1cc`.
5928```solidity
5929function UPGRADE_INTERFACE_VERSION() external view returns (string memory);
5930```*/
5931    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5932    #[derive(Clone)]
5933    pub struct UPGRADE_INTERFACE_VERSIONCall;
5934    #[derive(serde::Serialize, serde::Deserialize)]
5935    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5936    ///Container type for the return parameters of the [`UPGRADE_INTERFACE_VERSION()`](UPGRADE_INTERFACE_VERSIONCall) function.
5937    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5938    #[derive(Clone)]
5939    pub struct UPGRADE_INTERFACE_VERSIONReturn {
5940        #[allow(missing_docs)]
5941        pub _0: alloy::sol_types::private::String,
5942    }
5943    #[allow(
5944        non_camel_case_types,
5945        non_snake_case,
5946        clippy::pub_underscore_fields,
5947        clippy::style
5948    )]
5949    const _: () = {
5950        use alloy::sol_types as alloy_sol_types;
5951        {
5952            #[doc(hidden)]
5953            #[allow(dead_code)]
5954            type UnderlyingSolTuple<'a> = ();
5955            #[doc(hidden)]
5956            type UnderlyingRustTuple<'a> = ();
5957            #[cfg(test)]
5958            #[allow(dead_code, unreachable_patterns)]
5959            fn _type_assertion(
5960                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5961            ) {
5962                match _t {
5963                    alloy_sol_types::private::AssertTypeEq::<
5964                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5965                    >(_) => {}
5966                }
5967            }
5968            #[automatically_derived]
5969            #[doc(hidden)]
5970            impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONCall>
5971            for UnderlyingRustTuple<'_> {
5972                fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self {
5973                    ()
5974                }
5975            }
5976            #[automatically_derived]
5977            #[doc(hidden)]
5978            impl ::core::convert::From<UnderlyingRustTuple<'_>>
5979            for UPGRADE_INTERFACE_VERSIONCall {
5980                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5981                    Self
5982                }
5983            }
5984        }
5985        {
5986            #[doc(hidden)]
5987            #[allow(dead_code)]
5988            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
5989            #[doc(hidden)]
5990            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
5991            #[cfg(test)]
5992            #[allow(dead_code, unreachable_patterns)]
5993            fn _type_assertion(
5994                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5995            ) {
5996                match _t {
5997                    alloy_sol_types::private::AssertTypeEq::<
5998                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5999                    >(_) => {}
6000                }
6001            }
6002            #[automatically_derived]
6003            #[doc(hidden)]
6004            impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONReturn>
6005            for UnderlyingRustTuple<'_> {
6006                fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self {
6007                    (value._0,)
6008                }
6009            }
6010            #[automatically_derived]
6011            #[doc(hidden)]
6012            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6013            for UPGRADE_INTERFACE_VERSIONReturn {
6014                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6015                    Self { _0: tuple.0 }
6016                }
6017            }
6018        }
6019        #[automatically_derived]
6020        impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall {
6021            type Parameters<'a> = ();
6022            type Token<'a> = <Self::Parameters<
6023                'a,
6024            > as alloy_sol_types::SolType>::Token<'a>;
6025            type Return = alloy::sol_types::private::String;
6026            type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
6027            type ReturnToken<'a> = <Self::ReturnTuple<
6028                'a,
6029            > as alloy_sol_types::SolType>::Token<'a>;
6030            const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()";
6031            const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8];
6032            #[inline]
6033            fn new<'a>(
6034                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6035            ) -> Self {
6036                tuple.into()
6037            }
6038            #[inline]
6039            fn tokenize(&self) -> Self::Token<'_> {
6040                ()
6041            }
6042            #[inline]
6043            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6044                (
6045                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
6046                        ret,
6047                    ),
6048                )
6049            }
6050            #[inline]
6051            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6052                <Self::ReturnTuple<
6053                    '_,
6054                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6055                    .map(|r| {
6056                        let r: UPGRADE_INTERFACE_VERSIONReturn = r.into();
6057                        r._0
6058                    })
6059            }
6060            #[inline]
6061            fn abi_decode_returns_validate(
6062                data: &[u8],
6063            ) -> alloy_sol_types::Result<Self::Return> {
6064                <Self::ReturnTuple<
6065                    '_,
6066                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6067                    .map(|r| {
6068                        let r: UPGRADE_INTERFACE_VERSIONReturn = r.into();
6069                        r._0
6070                    })
6071            }
6072        }
6073    };
6074    #[derive(serde::Serialize, serde::Deserialize)]
6075    #[derive()]
6076    /**Function with signature `_hashBlsKey((uint256,uint256,uint256,uint256))` and selector `0x9b30a5e6`.
6077```solidity
6078function _hashBlsKey(BN254.G2Point memory blsVK) external pure returns (bytes32);
6079```*/
6080    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6081    #[derive(Clone)]
6082    pub struct _hashBlsKeyCall {
6083        #[allow(missing_docs)]
6084        pub blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
6085    }
6086    #[derive(serde::Serialize, serde::Deserialize)]
6087    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6088    ///Container type for the return parameters of the [`_hashBlsKey((uint256,uint256,uint256,uint256))`](_hashBlsKeyCall) function.
6089    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6090    #[derive(Clone)]
6091    pub struct _hashBlsKeyReturn {
6092        #[allow(missing_docs)]
6093        pub _0: alloy::sol_types::private::FixedBytes<32>,
6094    }
6095    #[allow(
6096        non_camel_case_types,
6097        non_snake_case,
6098        clippy::pub_underscore_fields,
6099        clippy::style
6100    )]
6101    const _: () = {
6102        use alloy::sol_types as alloy_sol_types;
6103        {
6104            #[doc(hidden)]
6105            #[allow(dead_code)]
6106            type UnderlyingSolTuple<'a> = (BN254::G2Point,);
6107            #[doc(hidden)]
6108            type UnderlyingRustTuple<'a> = (
6109                <BN254::G2Point as alloy::sol_types::SolType>::RustType,
6110            );
6111            #[cfg(test)]
6112            #[allow(dead_code, unreachable_patterns)]
6113            fn _type_assertion(
6114                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6115            ) {
6116                match _t {
6117                    alloy_sol_types::private::AssertTypeEq::<
6118                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6119                    >(_) => {}
6120                }
6121            }
6122            #[automatically_derived]
6123            #[doc(hidden)]
6124            impl ::core::convert::From<_hashBlsKeyCall> for UnderlyingRustTuple<'_> {
6125                fn from(value: _hashBlsKeyCall) -> Self {
6126                    (value.blsVK,)
6127                }
6128            }
6129            #[automatically_derived]
6130            #[doc(hidden)]
6131            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _hashBlsKeyCall {
6132                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6133                    Self { blsVK: tuple.0 }
6134                }
6135            }
6136        }
6137        {
6138            #[doc(hidden)]
6139            #[allow(dead_code)]
6140            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6141            #[doc(hidden)]
6142            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
6143            #[cfg(test)]
6144            #[allow(dead_code, unreachable_patterns)]
6145            fn _type_assertion(
6146                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6147            ) {
6148                match _t {
6149                    alloy_sol_types::private::AssertTypeEq::<
6150                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6151                    >(_) => {}
6152                }
6153            }
6154            #[automatically_derived]
6155            #[doc(hidden)]
6156            impl ::core::convert::From<_hashBlsKeyReturn> for UnderlyingRustTuple<'_> {
6157                fn from(value: _hashBlsKeyReturn) -> Self {
6158                    (value._0,)
6159                }
6160            }
6161            #[automatically_derived]
6162            #[doc(hidden)]
6163            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _hashBlsKeyReturn {
6164                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6165                    Self { _0: tuple.0 }
6166                }
6167            }
6168        }
6169        #[automatically_derived]
6170        impl alloy_sol_types::SolCall for _hashBlsKeyCall {
6171            type Parameters<'a> = (BN254::G2Point,);
6172            type Token<'a> = <Self::Parameters<
6173                'a,
6174            > as alloy_sol_types::SolType>::Token<'a>;
6175            type Return = alloy::sol_types::private::FixedBytes<32>;
6176            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6177            type ReturnToken<'a> = <Self::ReturnTuple<
6178                'a,
6179            > as alloy_sol_types::SolType>::Token<'a>;
6180            const SIGNATURE: &'static str = "_hashBlsKey((uint256,uint256,uint256,uint256))";
6181            const SELECTOR: [u8; 4] = [155u8, 48u8, 165u8, 230u8];
6182            #[inline]
6183            fn new<'a>(
6184                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6185            ) -> Self {
6186                tuple.into()
6187            }
6188            #[inline]
6189            fn tokenize(&self) -> Self::Token<'_> {
6190                (<BN254::G2Point as alloy_sol_types::SolType>::tokenize(&self.blsVK),)
6191            }
6192            #[inline]
6193            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6194                (
6195                    <alloy::sol_types::sol_data::FixedBytes<
6196                        32,
6197                    > as alloy_sol_types::SolType>::tokenize(ret),
6198                )
6199            }
6200            #[inline]
6201            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6202                <Self::ReturnTuple<
6203                    '_,
6204                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6205                    .map(|r| {
6206                        let r: _hashBlsKeyReturn = r.into();
6207                        r._0
6208                    })
6209            }
6210            #[inline]
6211            fn abi_decode_returns_validate(
6212                data: &[u8],
6213            ) -> alloy_sol_types::Result<Self::Return> {
6214                <Self::ReturnTuple<
6215                    '_,
6216                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6217                    .map(|r| {
6218                        let r: _hashBlsKeyReturn = r.into();
6219                        r._0
6220                    })
6221            }
6222        }
6223    };
6224    #[derive(serde::Serialize, serde::Deserialize)]
6225    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6226    /**Function with signature `blsKeys(bytes32)` and selector `0xb3e6ebd5`.
6227```solidity
6228function blsKeys(bytes32 blsKeyHash) external view returns (bool used);
6229```*/
6230    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6231    #[derive(Clone)]
6232    pub struct blsKeysCall {
6233        #[allow(missing_docs)]
6234        pub blsKeyHash: alloy::sol_types::private::FixedBytes<32>,
6235    }
6236    #[derive(serde::Serialize, serde::Deserialize)]
6237    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6238    ///Container type for the return parameters of the [`blsKeys(bytes32)`](blsKeysCall) function.
6239    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6240    #[derive(Clone)]
6241    pub struct blsKeysReturn {
6242        #[allow(missing_docs)]
6243        pub used: bool,
6244    }
6245    #[allow(
6246        non_camel_case_types,
6247        non_snake_case,
6248        clippy::pub_underscore_fields,
6249        clippy::style
6250    )]
6251    const _: () = {
6252        use alloy::sol_types as alloy_sol_types;
6253        {
6254            #[doc(hidden)]
6255            #[allow(dead_code)]
6256            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6257            #[doc(hidden)]
6258            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
6259            #[cfg(test)]
6260            #[allow(dead_code, unreachable_patterns)]
6261            fn _type_assertion(
6262                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6263            ) {
6264                match _t {
6265                    alloy_sol_types::private::AssertTypeEq::<
6266                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6267                    >(_) => {}
6268                }
6269            }
6270            #[automatically_derived]
6271            #[doc(hidden)]
6272            impl ::core::convert::From<blsKeysCall> for UnderlyingRustTuple<'_> {
6273                fn from(value: blsKeysCall) -> Self {
6274                    (value.blsKeyHash,)
6275                }
6276            }
6277            #[automatically_derived]
6278            #[doc(hidden)]
6279            impl ::core::convert::From<UnderlyingRustTuple<'_>> for blsKeysCall {
6280                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6281                    Self { blsKeyHash: tuple.0 }
6282                }
6283            }
6284        }
6285        {
6286            #[doc(hidden)]
6287            #[allow(dead_code)]
6288            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
6289            #[doc(hidden)]
6290            type UnderlyingRustTuple<'a> = (bool,);
6291            #[cfg(test)]
6292            #[allow(dead_code, unreachable_patterns)]
6293            fn _type_assertion(
6294                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6295            ) {
6296                match _t {
6297                    alloy_sol_types::private::AssertTypeEq::<
6298                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6299                    >(_) => {}
6300                }
6301            }
6302            #[automatically_derived]
6303            #[doc(hidden)]
6304            impl ::core::convert::From<blsKeysReturn> for UnderlyingRustTuple<'_> {
6305                fn from(value: blsKeysReturn) -> Self {
6306                    (value.used,)
6307                }
6308            }
6309            #[automatically_derived]
6310            #[doc(hidden)]
6311            impl ::core::convert::From<UnderlyingRustTuple<'_>> for blsKeysReturn {
6312                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6313                    Self { used: tuple.0 }
6314                }
6315            }
6316        }
6317        #[automatically_derived]
6318        impl alloy_sol_types::SolCall for blsKeysCall {
6319            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6320            type Token<'a> = <Self::Parameters<
6321                'a,
6322            > as alloy_sol_types::SolType>::Token<'a>;
6323            type Return = bool;
6324            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
6325            type ReturnToken<'a> = <Self::ReturnTuple<
6326                'a,
6327            > as alloy_sol_types::SolType>::Token<'a>;
6328            const SIGNATURE: &'static str = "blsKeys(bytes32)";
6329            const SELECTOR: [u8; 4] = [179u8, 230u8, 235u8, 213u8];
6330            #[inline]
6331            fn new<'a>(
6332                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6333            ) -> Self {
6334                tuple.into()
6335            }
6336            #[inline]
6337            fn tokenize(&self) -> Self::Token<'_> {
6338                (
6339                    <alloy::sol_types::sol_data::FixedBytes<
6340                        32,
6341                    > as alloy_sol_types::SolType>::tokenize(&self.blsKeyHash),
6342                )
6343            }
6344            #[inline]
6345            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6346                (
6347                    <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
6348                        ret,
6349                    ),
6350                )
6351            }
6352            #[inline]
6353            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6354                <Self::ReturnTuple<
6355                    '_,
6356                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6357                    .map(|r| {
6358                        let r: blsKeysReturn = r.into();
6359                        r.used
6360                    })
6361            }
6362            #[inline]
6363            fn abi_decode_returns_validate(
6364                data: &[u8],
6365            ) -> alloy_sol_types::Result<Self::Return> {
6366                <Self::ReturnTuple<
6367                    '_,
6368                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6369                    .map(|r| {
6370                        let r: blsKeysReturn = r.into();
6371                        r.used
6372                    })
6373            }
6374        }
6375    };
6376    #[derive(serde::Serialize, serde::Deserialize)]
6377    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6378    /**Function with signature `claimValidatorExit(address)` and selector `0x2140fecd`.
6379```solidity
6380function claimValidatorExit(address validator) external;
6381```*/
6382    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6383    #[derive(Clone)]
6384    pub struct claimValidatorExitCall {
6385        #[allow(missing_docs)]
6386        pub validator: alloy::sol_types::private::Address,
6387    }
6388    ///Container type for the return parameters of the [`claimValidatorExit(address)`](claimValidatorExitCall) function.
6389    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6390    #[derive(Clone)]
6391    pub struct claimValidatorExitReturn {}
6392    #[allow(
6393        non_camel_case_types,
6394        non_snake_case,
6395        clippy::pub_underscore_fields,
6396        clippy::style
6397    )]
6398    const _: () = {
6399        use alloy::sol_types as alloy_sol_types;
6400        {
6401            #[doc(hidden)]
6402            #[allow(dead_code)]
6403            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6404            #[doc(hidden)]
6405            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6406            #[cfg(test)]
6407            #[allow(dead_code, unreachable_patterns)]
6408            fn _type_assertion(
6409                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6410            ) {
6411                match _t {
6412                    alloy_sol_types::private::AssertTypeEq::<
6413                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6414                    >(_) => {}
6415                }
6416            }
6417            #[automatically_derived]
6418            #[doc(hidden)]
6419            impl ::core::convert::From<claimValidatorExitCall>
6420            for UnderlyingRustTuple<'_> {
6421                fn from(value: claimValidatorExitCall) -> Self {
6422                    (value.validator,)
6423                }
6424            }
6425            #[automatically_derived]
6426            #[doc(hidden)]
6427            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6428            for claimValidatorExitCall {
6429                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6430                    Self { validator: tuple.0 }
6431                }
6432            }
6433        }
6434        {
6435            #[doc(hidden)]
6436            #[allow(dead_code)]
6437            type UnderlyingSolTuple<'a> = ();
6438            #[doc(hidden)]
6439            type UnderlyingRustTuple<'a> = ();
6440            #[cfg(test)]
6441            #[allow(dead_code, unreachable_patterns)]
6442            fn _type_assertion(
6443                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6444            ) {
6445                match _t {
6446                    alloy_sol_types::private::AssertTypeEq::<
6447                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6448                    >(_) => {}
6449                }
6450            }
6451            #[automatically_derived]
6452            #[doc(hidden)]
6453            impl ::core::convert::From<claimValidatorExitReturn>
6454            for UnderlyingRustTuple<'_> {
6455                fn from(value: claimValidatorExitReturn) -> Self {
6456                    ()
6457                }
6458            }
6459            #[automatically_derived]
6460            #[doc(hidden)]
6461            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6462            for claimValidatorExitReturn {
6463                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6464                    Self {}
6465                }
6466            }
6467        }
6468        impl claimValidatorExitReturn {
6469            fn _tokenize(
6470                &self,
6471            ) -> <claimValidatorExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6472                ()
6473            }
6474        }
6475        #[automatically_derived]
6476        impl alloy_sol_types::SolCall for claimValidatorExitCall {
6477            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
6478            type Token<'a> = <Self::Parameters<
6479                'a,
6480            > as alloy_sol_types::SolType>::Token<'a>;
6481            type Return = claimValidatorExitReturn;
6482            type ReturnTuple<'a> = ();
6483            type ReturnToken<'a> = <Self::ReturnTuple<
6484                'a,
6485            > as alloy_sol_types::SolType>::Token<'a>;
6486            const SIGNATURE: &'static str = "claimValidatorExit(address)";
6487            const SELECTOR: [u8; 4] = [33u8, 64u8, 254u8, 205u8];
6488            #[inline]
6489            fn new<'a>(
6490                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6491            ) -> Self {
6492                tuple.into()
6493            }
6494            #[inline]
6495            fn tokenize(&self) -> Self::Token<'_> {
6496                (
6497                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6498                        &self.validator,
6499                    ),
6500                )
6501            }
6502            #[inline]
6503            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6504                claimValidatorExitReturn::_tokenize(ret)
6505            }
6506            #[inline]
6507            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6508                <Self::ReturnTuple<
6509                    '_,
6510                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6511                    .map(Into::into)
6512            }
6513            #[inline]
6514            fn abi_decode_returns_validate(
6515                data: &[u8],
6516            ) -> alloy_sol_types::Result<Self::Return> {
6517                <Self::ReturnTuple<
6518                    '_,
6519                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6520                    .map(Into::into)
6521            }
6522        }
6523    };
6524    #[derive(serde::Serialize, serde::Deserialize)]
6525    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6526    /**Function with signature `claimWithdrawal(address)` and selector `0xa3066aab`.
6527```solidity
6528function claimWithdrawal(address validator) external;
6529```*/
6530    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6531    #[derive(Clone)]
6532    pub struct claimWithdrawalCall {
6533        #[allow(missing_docs)]
6534        pub validator: alloy::sol_types::private::Address,
6535    }
6536    ///Container type for the return parameters of the [`claimWithdrawal(address)`](claimWithdrawalCall) function.
6537    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6538    #[derive(Clone)]
6539    pub struct claimWithdrawalReturn {}
6540    #[allow(
6541        non_camel_case_types,
6542        non_snake_case,
6543        clippy::pub_underscore_fields,
6544        clippy::style
6545    )]
6546    const _: () = {
6547        use alloy::sol_types as alloy_sol_types;
6548        {
6549            #[doc(hidden)]
6550            #[allow(dead_code)]
6551            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6552            #[doc(hidden)]
6553            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6554            #[cfg(test)]
6555            #[allow(dead_code, unreachable_patterns)]
6556            fn _type_assertion(
6557                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6558            ) {
6559                match _t {
6560                    alloy_sol_types::private::AssertTypeEq::<
6561                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6562                    >(_) => {}
6563                }
6564            }
6565            #[automatically_derived]
6566            #[doc(hidden)]
6567            impl ::core::convert::From<claimWithdrawalCall> for UnderlyingRustTuple<'_> {
6568                fn from(value: claimWithdrawalCall) -> Self {
6569                    (value.validator,)
6570                }
6571            }
6572            #[automatically_derived]
6573            #[doc(hidden)]
6574            impl ::core::convert::From<UnderlyingRustTuple<'_>> for claimWithdrawalCall {
6575                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6576                    Self { validator: tuple.0 }
6577                }
6578            }
6579        }
6580        {
6581            #[doc(hidden)]
6582            #[allow(dead_code)]
6583            type UnderlyingSolTuple<'a> = ();
6584            #[doc(hidden)]
6585            type UnderlyingRustTuple<'a> = ();
6586            #[cfg(test)]
6587            #[allow(dead_code, unreachable_patterns)]
6588            fn _type_assertion(
6589                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6590            ) {
6591                match _t {
6592                    alloy_sol_types::private::AssertTypeEq::<
6593                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6594                    >(_) => {}
6595                }
6596            }
6597            #[automatically_derived]
6598            #[doc(hidden)]
6599            impl ::core::convert::From<claimWithdrawalReturn>
6600            for UnderlyingRustTuple<'_> {
6601                fn from(value: claimWithdrawalReturn) -> Self {
6602                    ()
6603                }
6604            }
6605            #[automatically_derived]
6606            #[doc(hidden)]
6607            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6608            for claimWithdrawalReturn {
6609                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6610                    Self {}
6611                }
6612            }
6613        }
6614        impl claimWithdrawalReturn {
6615            fn _tokenize(
6616                &self,
6617            ) -> <claimWithdrawalCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6618                ()
6619            }
6620        }
6621        #[automatically_derived]
6622        impl alloy_sol_types::SolCall for claimWithdrawalCall {
6623            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
6624            type Token<'a> = <Self::Parameters<
6625                'a,
6626            > as alloy_sol_types::SolType>::Token<'a>;
6627            type Return = claimWithdrawalReturn;
6628            type ReturnTuple<'a> = ();
6629            type ReturnToken<'a> = <Self::ReturnTuple<
6630                'a,
6631            > as alloy_sol_types::SolType>::Token<'a>;
6632            const SIGNATURE: &'static str = "claimWithdrawal(address)";
6633            const SELECTOR: [u8; 4] = [163u8, 6u8, 106u8, 171u8];
6634            #[inline]
6635            fn new<'a>(
6636                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6637            ) -> Self {
6638                tuple.into()
6639            }
6640            #[inline]
6641            fn tokenize(&self) -> Self::Token<'_> {
6642                (
6643                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6644                        &self.validator,
6645                    ),
6646                )
6647            }
6648            #[inline]
6649            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6650                claimWithdrawalReturn::_tokenize(ret)
6651            }
6652            #[inline]
6653            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6654                <Self::ReturnTuple<
6655                    '_,
6656                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6657                    .map(Into::into)
6658            }
6659            #[inline]
6660            fn abi_decode_returns_validate(
6661                data: &[u8],
6662            ) -> alloy_sol_types::Result<Self::Return> {
6663                <Self::ReturnTuple<
6664                    '_,
6665                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6666                    .map(Into::into)
6667            }
6668        }
6669    };
6670    #[derive(serde::Serialize, serde::Deserialize)]
6671    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6672    /**Function with signature `delegate(address,uint256)` and selector `0x026e402b`.
6673```solidity
6674function delegate(address validator, uint256 amount) external;
6675```*/
6676    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6677    #[derive(Clone)]
6678    pub struct delegateCall {
6679        #[allow(missing_docs)]
6680        pub validator: alloy::sol_types::private::Address,
6681        #[allow(missing_docs)]
6682        pub amount: alloy::sol_types::private::primitives::aliases::U256,
6683    }
6684    ///Container type for the return parameters of the [`delegate(address,uint256)`](delegateCall) function.
6685    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6686    #[derive(Clone)]
6687    pub struct delegateReturn {}
6688    #[allow(
6689        non_camel_case_types,
6690        non_snake_case,
6691        clippy::pub_underscore_fields,
6692        clippy::style
6693    )]
6694    const _: () = {
6695        use alloy::sol_types as alloy_sol_types;
6696        {
6697            #[doc(hidden)]
6698            #[allow(dead_code)]
6699            type UnderlyingSolTuple<'a> = (
6700                alloy::sol_types::sol_data::Address,
6701                alloy::sol_types::sol_data::Uint<256>,
6702            );
6703            #[doc(hidden)]
6704            type UnderlyingRustTuple<'a> = (
6705                alloy::sol_types::private::Address,
6706                alloy::sol_types::private::primitives::aliases::U256,
6707            );
6708            #[cfg(test)]
6709            #[allow(dead_code, unreachable_patterns)]
6710            fn _type_assertion(
6711                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6712            ) {
6713                match _t {
6714                    alloy_sol_types::private::AssertTypeEq::<
6715                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6716                    >(_) => {}
6717                }
6718            }
6719            #[automatically_derived]
6720            #[doc(hidden)]
6721            impl ::core::convert::From<delegateCall> for UnderlyingRustTuple<'_> {
6722                fn from(value: delegateCall) -> Self {
6723                    (value.validator, value.amount)
6724                }
6725            }
6726            #[automatically_derived]
6727            #[doc(hidden)]
6728            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegateCall {
6729                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6730                    Self {
6731                        validator: tuple.0,
6732                        amount: tuple.1,
6733                    }
6734                }
6735            }
6736        }
6737        {
6738            #[doc(hidden)]
6739            #[allow(dead_code)]
6740            type UnderlyingSolTuple<'a> = ();
6741            #[doc(hidden)]
6742            type UnderlyingRustTuple<'a> = ();
6743            #[cfg(test)]
6744            #[allow(dead_code, unreachable_patterns)]
6745            fn _type_assertion(
6746                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6747            ) {
6748                match _t {
6749                    alloy_sol_types::private::AssertTypeEq::<
6750                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6751                    >(_) => {}
6752                }
6753            }
6754            #[automatically_derived]
6755            #[doc(hidden)]
6756            impl ::core::convert::From<delegateReturn> for UnderlyingRustTuple<'_> {
6757                fn from(value: delegateReturn) -> Self {
6758                    ()
6759                }
6760            }
6761            #[automatically_derived]
6762            #[doc(hidden)]
6763            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegateReturn {
6764                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6765                    Self {}
6766                }
6767            }
6768        }
6769        impl delegateReturn {
6770            fn _tokenize(
6771                &self,
6772            ) -> <delegateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6773                ()
6774            }
6775        }
6776        #[automatically_derived]
6777        impl alloy_sol_types::SolCall for delegateCall {
6778            type Parameters<'a> = (
6779                alloy::sol_types::sol_data::Address,
6780                alloy::sol_types::sol_data::Uint<256>,
6781            );
6782            type Token<'a> = <Self::Parameters<
6783                'a,
6784            > as alloy_sol_types::SolType>::Token<'a>;
6785            type Return = delegateReturn;
6786            type ReturnTuple<'a> = ();
6787            type ReturnToken<'a> = <Self::ReturnTuple<
6788                'a,
6789            > as alloy_sol_types::SolType>::Token<'a>;
6790            const SIGNATURE: &'static str = "delegate(address,uint256)";
6791            const SELECTOR: [u8; 4] = [2u8, 110u8, 64u8, 43u8];
6792            #[inline]
6793            fn new<'a>(
6794                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6795            ) -> Self {
6796                tuple.into()
6797            }
6798            #[inline]
6799            fn tokenize(&self) -> Self::Token<'_> {
6800                (
6801                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6802                        &self.validator,
6803                    ),
6804                    <alloy::sol_types::sol_data::Uint<
6805                        256,
6806                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
6807                )
6808            }
6809            #[inline]
6810            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6811                delegateReturn::_tokenize(ret)
6812            }
6813            #[inline]
6814            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6815                <Self::ReturnTuple<
6816                    '_,
6817                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6818                    .map(Into::into)
6819            }
6820            #[inline]
6821            fn abi_decode_returns_validate(
6822                data: &[u8],
6823            ) -> alloy_sol_types::Result<Self::Return> {
6824                <Self::ReturnTuple<
6825                    '_,
6826                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6827                    .map(Into::into)
6828            }
6829        }
6830    };
6831    #[derive(serde::Serialize, serde::Deserialize)]
6832    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6833    /**Function with signature `delegations(address,address)` and selector `0xc64814dd`.
6834```solidity
6835function delegations(address validator, address delegator) external view returns (uint256 amount);
6836```*/
6837    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6838    #[derive(Clone)]
6839    pub struct delegationsCall {
6840        #[allow(missing_docs)]
6841        pub validator: alloy::sol_types::private::Address,
6842        #[allow(missing_docs)]
6843        pub delegator: alloy::sol_types::private::Address,
6844    }
6845    #[derive(serde::Serialize, serde::Deserialize)]
6846    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6847    ///Container type for the return parameters of the [`delegations(address,address)`](delegationsCall) function.
6848    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6849    #[derive(Clone)]
6850    pub struct delegationsReturn {
6851        #[allow(missing_docs)]
6852        pub amount: alloy::sol_types::private::primitives::aliases::U256,
6853    }
6854    #[allow(
6855        non_camel_case_types,
6856        non_snake_case,
6857        clippy::pub_underscore_fields,
6858        clippy::style
6859    )]
6860    const _: () = {
6861        use alloy::sol_types as alloy_sol_types;
6862        {
6863            #[doc(hidden)]
6864            #[allow(dead_code)]
6865            type UnderlyingSolTuple<'a> = (
6866                alloy::sol_types::sol_data::Address,
6867                alloy::sol_types::sol_data::Address,
6868            );
6869            #[doc(hidden)]
6870            type UnderlyingRustTuple<'a> = (
6871                alloy::sol_types::private::Address,
6872                alloy::sol_types::private::Address,
6873            );
6874            #[cfg(test)]
6875            #[allow(dead_code, unreachable_patterns)]
6876            fn _type_assertion(
6877                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6878            ) {
6879                match _t {
6880                    alloy_sol_types::private::AssertTypeEq::<
6881                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6882                    >(_) => {}
6883                }
6884            }
6885            #[automatically_derived]
6886            #[doc(hidden)]
6887            impl ::core::convert::From<delegationsCall> for UnderlyingRustTuple<'_> {
6888                fn from(value: delegationsCall) -> Self {
6889                    (value.validator, value.delegator)
6890                }
6891            }
6892            #[automatically_derived]
6893            #[doc(hidden)]
6894            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegationsCall {
6895                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6896                    Self {
6897                        validator: tuple.0,
6898                        delegator: tuple.1,
6899                    }
6900                }
6901            }
6902        }
6903        {
6904            #[doc(hidden)]
6905            #[allow(dead_code)]
6906            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6907            #[doc(hidden)]
6908            type UnderlyingRustTuple<'a> = (
6909                alloy::sol_types::private::primitives::aliases::U256,
6910            );
6911            #[cfg(test)]
6912            #[allow(dead_code, unreachable_patterns)]
6913            fn _type_assertion(
6914                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6915            ) {
6916                match _t {
6917                    alloy_sol_types::private::AssertTypeEq::<
6918                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6919                    >(_) => {}
6920                }
6921            }
6922            #[automatically_derived]
6923            #[doc(hidden)]
6924            impl ::core::convert::From<delegationsReturn> for UnderlyingRustTuple<'_> {
6925                fn from(value: delegationsReturn) -> Self {
6926                    (value.amount,)
6927                }
6928            }
6929            #[automatically_derived]
6930            #[doc(hidden)]
6931            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegationsReturn {
6932                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6933                    Self { amount: tuple.0 }
6934                }
6935            }
6936        }
6937        #[automatically_derived]
6938        impl alloy_sol_types::SolCall for delegationsCall {
6939            type Parameters<'a> = (
6940                alloy::sol_types::sol_data::Address,
6941                alloy::sol_types::sol_data::Address,
6942            );
6943            type Token<'a> = <Self::Parameters<
6944                'a,
6945            > as alloy_sol_types::SolType>::Token<'a>;
6946            type Return = alloy::sol_types::private::primitives::aliases::U256;
6947            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6948            type ReturnToken<'a> = <Self::ReturnTuple<
6949                'a,
6950            > as alloy_sol_types::SolType>::Token<'a>;
6951            const SIGNATURE: &'static str = "delegations(address,address)";
6952            const SELECTOR: [u8; 4] = [198u8, 72u8, 20u8, 221u8];
6953            #[inline]
6954            fn new<'a>(
6955                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6956            ) -> Self {
6957                tuple.into()
6958            }
6959            #[inline]
6960            fn tokenize(&self) -> Self::Token<'_> {
6961                (
6962                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6963                        &self.validator,
6964                    ),
6965                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6966                        &self.delegator,
6967                    ),
6968                )
6969            }
6970            #[inline]
6971            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6972                (
6973                    <alloy::sol_types::sol_data::Uint<
6974                        256,
6975                    > as alloy_sol_types::SolType>::tokenize(ret),
6976                )
6977            }
6978            #[inline]
6979            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6980                <Self::ReturnTuple<
6981                    '_,
6982                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6983                    .map(|r| {
6984                        let r: delegationsReturn = r.into();
6985                        r.amount
6986                    })
6987            }
6988            #[inline]
6989            fn abi_decode_returns_validate(
6990                data: &[u8],
6991            ) -> alloy_sol_types::Result<Self::Return> {
6992                <Self::ReturnTuple<
6993                    '_,
6994                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6995                    .map(|r| {
6996                        let r: delegationsReturn = r.into();
6997                        r.amount
6998                    })
6999            }
7000        }
7001    };
7002    #[derive(serde::Serialize, serde::Deserialize)]
7003    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7004    /**Function with signature `deregisterValidator()` and selector `0x6a911ccf`.
7005```solidity
7006function deregisterValidator() external;
7007```*/
7008    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7009    #[derive(Clone)]
7010    pub struct deregisterValidatorCall;
7011    ///Container type for the return parameters of the [`deregisterValidator()`](deregisterValidatorCall) function.
7012    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7013    #[derive(Clone)]
7014    pub struct deregisterValidatorReturn {}
7015    #[allow(
7016        non_camel_case_types,
7017        non_snake_case,
7018        clippy::pub_underscore_fields,
7019        clippy::style
7020    )]
7021    const _: () = {
7022        use alloy::sol_types as alloy_sol_types;
7023        {
7024            #[doc(hidden)]
7025            #[allow(dead_code)]
7026            type UnderlyingSolTuple<'a> = ();
7027            #[doc(hidden)]
7028            type UnderlyingRustTuple<'a> = ();
7029            #[cfg(test)]
7030            #[allow(dead_code, unreachable_patterns)]
7031            fn _type_assertion(
7032                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7033            ) {
7034                match _t {
7035                    alloy_sol_types::private::AssertTypeEq::<
7036                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7037                    >(_) => {}
7038                }
7039            }
7040            #[automatically_derived]
7041            #[doc(hidden)]
7042            impl ::core::convert::From<deregisterValidatorCall>
7043            for UnderlyingRustTuple<'_> {
7044                fn from(value: deregisterValidatorCall) -> Self {
7045                    ()
7046                }
7047            }
7048            #[automatically_derived]
7049            #[doc(hidden)]
7050            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7051            for deregisterValidatorCall {
7052                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7053                    Self
7054                }
7055            }
7056        }
7057        {
7058            #[doc(hidden)]
7059            #[allow(dead_code)]
7060            type UnderlyingSolTuple<'a> = ();
7061            #[doc(hidden)]
7062            type UnderlyingRustTuple<'a> = ();
7063            #[cfg(test)]
7064            #[allow(dead_code, unreachable_patterns)]
7065            fn _type_assertion(
7066                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7067            ) {
7068                match _t {
7069                    alloy_sol_types::private::AssertTypeEq::<
7070                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7071                    >(_) => {}
7072                }
7073            }
7074            #[automatically_derived]
7075            #[doc(hidden)]
7076            impl ::core::convert::From<deregisterValidatorReturn>
7077            for UnderlyingRustTuple<'_> {
7078                fn from(value: deregisterValidatorReturn) -> Self {
7079                    ()
7080                }
7081            }
7082            #[automatically_derived]
7083            #[doc(hidden)]
7084            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7085            for deregisterValidatorReturn {
7086                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7087                    Self {}
7088                }
7089            }
7090        }
7091        impl deregisterValidatorReturn {
7092            fn _tokenize(
7093                &self,
7094            ) -> <deregisterValidatorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
7095                ()
7096            }
7097        }
7098        #[automatically_derived]
7099        impl alloy_sol_types::SolCall for deregisterValidatorCall {
7100            type Parameters<'a> = ();
7101            type Token<'a> = <Self::Parameters<
7102                'a,
7103            > as alloy_sol_types::SolType>::Token<'a>;
7104            type Return = deregisterValidatorReturn;
7105            type ReturnTuple<'a> = ();
7106            type ReturnToken<'a> = <Self::ReturnTuple<
7107                'a,
7108            > as alloy_sol_types::SolType>::Token<'a>;
7109            const SIGNATURE: &'static str = "deregisterValidator()";
7110            const SELECTOR: [u8; 4] = [106u8, 145u8, 28u8, 207u8];
7111            #[inline]
7112            fn new<'a>(
7113                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7114            ) -> Self {
7115                tuple.into()
7116            }
7117            #[inline]
7118            fn tokenize(&self) -> Self::Token<'_> {
7119                ()
7120            }
7121            #[inline]
7122            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7123                deregisterValidatorReturn::_tokenize(ret)
7124            }
7125            #[inline]
7126            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7127                <Self::ReturnTuple<
7128                    '_,
7129                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7130                    .map(Into::into)
7131            }
7132            #[inline]
7133            fn abi_decode_returns_validate(
7134                data: &[u8],
7135            ) -> alloy_sol_types::Result<Self::Return> {
7136                <Self::ReturnTuple<
7137                    '_,
7138                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7139                    .map(Into::into)
7140            }
7141        }
7142    };
7143    #[derive(serde::Serialize, serde::Deserialize)]
7144    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7145    /**Function with signature `exitEscrowPeriod()` and selector `0x9e9a8f31`.
7146```solidity
7147function exitEscrowPeriod() external view returns (uint256);
7148```*/
7149    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7150    #[derive(Clone)]
7151    pub struct exitEscrowPeriodCall;
7152    #[derive(serde::Serialize, serde::Deserialize)]
7153    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7154    ///Container type for the return parameters of the [`exitEscrowPeriod()`](exitEscrowPeriodCall) function.
7155    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7156    #[derive(Clone)]
7157    pub struct exitEscrowPeriodReturn {
7158        #[allow(missing_docs)]
7159        pub _0: alloy::sol_types::private::primitives::aliases::U256,
7160    }
7161    #[allow(
7162        non_camel_case_types,
7163        non_snake_case,
7164        clippy::pub_underscore_fields,
7165        clippy::style
7166    )]
7167    const _: () = {
7168        use alloy::sol_types as alloy_sol_types;
7169        {
7170            #[doc(hidden)]
7171            #[allow(dead_code)]
7172            type UnderlyingSolTuple<'a> = ();
7173            #[doc(hidden)]
7174            type UnderlyingRustTuple<'a> = ();
7175            #[cfg(test)]
7176            #[allow(dead_code, unreachable_patterns)]
7177            fn _type_assertion(
7178                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7179            ) {
7180                match _t {
7181                    alloy_sol_types::private::AssertTypeEq::<
7182                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7183                    >(_) => {}
7184                }
7185            }
7186            #[automatically_derived]
7187            #[doc(hidden)]
7188            impl ::core::convert::From<exitEscrowPeriodCall>
7189            for UnderlyingRustTuple<'_> {
7190                fn from(value: exitEscrowPeriodCall) -> Self {
7191                    ()
7192                }
7193            }
7194            #[automatically_derived]
7195            #[doc(hidden)]
7196            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7197            for exitEscrowPeriodCall {
7198                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7199                    Self
7200                }
7201            }
7202        }
7203        {
7204            #[doc(hidden)]
7205            #[allow(dead_code)]
7206            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7207            #[doc(hidden)]
7208            type UnderlyingRustTuple<'a> = (
7209                alloy::sol_types::private::primitives::aliases::U256,
7210            );
7211            #[cfg(test)]
7212            #[allow(dead_code, unreachable_patterns)]
7213            fn _type_assertion(
7214                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7215            ) {
7216                match _t {
7217                    alloy_sol_types::private::AssertTypeEq::<
7218                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7219                    >(_) => {}
7220                }
7221            }
7222            #[automatically_derived]
7223            #[doc(hidden)]
7224            impl ::core::convert::From<exitEscrowPeriodReturn>
7225            for UnderlyingRustTuple<'_> {
7226                fn from(value: exitEscrowPeriodReturn) -> Self {
7227                    (value._0,)
7228                }
7229            }
7230            #[automatically_derived]
7231            #[doc(hidden)]
7232            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7233            for exitEscrowPeriodReturn {
7234                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7235                    Self { _0: tuple.0 }
7236                }
7237            }
7238        }
7239        #[automatically_derived]
7240        impl alloy_sol_types::SolCall for exitEscrowPeriodCall {
7241            type Parameters<'a> = ();
7242            type Token<'a> = <Self::Parameters<
7243                'a,
7244            > as alloy_sol_types::SolType>::Token<'a>;
7245            type Return = alloy::sol_types::private::primitives::aliases::U256;
7246            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7247            type ReturnToken<'a> = <Self::ReturnTuple<
7248                'a,
7249            > as alloy_sol_types::SolType>::Token<'a>;
7250            const SIGNATURE: &'static str = "exitEscrowPeriod()";
7251            const SELECTOR: [u8; 4] = [158u8, 154u8, 143u8, 49u8];
7252            #[inline]
7253            fn new<'a>(
7254                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7255            ) -> Self {
7256                tuple.into()
7257            }
7258            #[inline]
7259            fn tokenize(&self) -> Self::Token<'_> {
7260                ()
7261            }
7262            #[inline]
7263            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7264                (
7265                    <alloy::sol_types::sol_data::Uint<
7266                        256,
7267                    > as alloy_sol_types::SolType>::tokenize(ret),
7268                )
7269            }
7270            #[inline]
7271            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7272                <Self::ReturnTuple<
7273                    '_,
7274                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7275                    .map(|r| {
7276                        let r: exitEscrowPeriodReturn = r.into();
7277                        r._0
7278                    })
7279            }
7280            #[inline]
7281            fn abi_decode_returns_validate(
7282                data: &[u8],
7283            ) -> alloy_sol_types::Result<Self::Return> {
7284                <Self::ReturnTuple<
7285                    '_,
7286                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7287                    .map(|r| {
7288                        let r: exitEscrowPeriodReturn = r.into();
7289                        r._0
7290                    })
7291            }
7292        }
7293    };
7294    #[derive(serde::Serialize, serde::Deserialize)]
7295    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7296    /**Function with signature `getVersion()` and selector `0x0d8e6e2c`.
7297```solidity
7298function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion);
7299```*/
7300    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7301    #[derive(Clone)]
7302    pub struct getVersionCall;
7303    #[derive(serde::Serialize, serde::Deserialize)]
7304    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7305    ///Container type for the return parameters of the [`getVersion()`](getVersionCall) function.
7306    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7307    #[derive(Clone)]
7308    pub struct getVersionReturn {
7309        #[allow(missing_docs)]
7310        pub majorVersion: u8,
7311        #[allow(missing_docs)]
7312        pub minorVersion: u8,
7313        #[allow(missing_docs)]
7314        pub patchVersion: u8,
7315    }
7316    #[allow(
7317        non_camel_case_types,
7318        non_snake_case,
7319        clippy::pub_underscore_fields,
7320        clippy::style
7321    )]
7322    const _: () = {
7323        use alloy::sol_types as alloy_sol_types;
7324        {
7325            #[doc(hidden)]
7326            #[allow(dead_code)]
7327            type UnderlyingSolTuple<'a> = ();
7328            #[doc(hidden)]
7329            type UnderlyingRustTuple<'a> = ();
7330            #[cfg(test)]
7331            #[allow(dead_code, unreachable_patterns)]
7332            fn _type_assertion(
7333                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7334            ) {
7335                match _t {
7336                    alloy_sol_types::private::AssertTypeEq::<
7337                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7338                    >(_) => {}
7339                }
7340            }
7341            #[automatically_derived]
7342            #[doc(hidden)]
7343            impl ::core::convert::From<getVersionCall> for UnderlyingRustTuple<'_> {
7344                fn from(value: getVersionCall) -> Self {
7345                    ()
7346                }
7347            }
7348            #[automatically_derived]
7349            #[doc(hidden)]
7350            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionCall {
7351                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7352                    Self
7353                }
7354            }
7355        }
7356        {
7357            #[doc(hidden)]
7358            #[allow(dead_code)]
7359            type UnderlyingSolTuple<'a> = (
7360                alloy::sol_types::sol_data::Uint<8>,
7361                alloy::sol_types::sol_data::Uint<8>,
7362                alloy::sol_types::sol_data::Uint<8>,
7363            );
7364            #[doc(hidden)]
7365            type UnderlyingRustTuple<'a> = (u8, u8, u8);
7366            #[cfg(test)]
7367            #[allow(dead_code, unreachable_patterns)]
7368            fn _type_assertion(
7369                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7370            ) {
7371                match _t {
7372                    alloy_sol_types::private::AssertTypeEq::<
7373                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7374                    >(_) => {}
7375                }
7376            }
7377            #[automatically_derived]
7378            #[doc(hidden)]
7379            impl ::core::convert::From<getVersionReturn> for UnderlyingRustTuple<'_> {
7380                fn from(value: getVersionReturn) -> Self {
7381                    (value.majorVersion, value.minorVersion, value.patchVersion)
7382                }
7383            }
7384            #[automatically_derived]
7385            #[doc(hidden)]
7386            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionReturn {
7387                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7388                    Self {
7389                        majorVersion: tuple.0,
7390                        minorVersion: tuple.1,
7391                        patchVersion: tuple.2,
7392                    }
7393                }
7394            }
7395        }
7396        impl getVersionReturn {
7397            fn _tokenize(
7398                &self,
7399            ) -> <getVersionCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
7400                (
7401                    <alloy::sol_types::sol_data::Uint<
7402                        8,
7403                    > as alloy_sol_types::SolType>::tokenize(&self.majorVersion),
7404                    <alloy::sol_types::sol_data::Uint<
7405                        8,
7406                    > as alloy_sol_types::SolType>::tokenize(&self.minorVersion),
7407                    <alloy::sol_types::sol_data::Uint<
7408                        8,
7409                    > as alloy_sol_types::SolType>::tokenize(&self.patchVersion),
7410                )
7411            }
7412        }
7413        #[automatically_derived]
7414        impl alloy_sol_types::SolCall for getVersionCall {
7415            type Parameters<'a> = ();
7416            type Token<'a> = <Self::Parameters<
7417                'a,
7418            > as alloy_sol_types::SolType>::Token<'a>;
7419            type Return = getVersionReturn;
7420            type ReturnTuple<'a> = (
7421                alloy::sol_types::sol_data::Uint<8>,
7422                alloy::sol_types::sol_data::Uint<8>,
7423                alloy::sol_types::sol_data::Uint<8>,
7424            );
7425            type ReturnToken<'a> = <Self::ReturnTuple<
7426                'a,
7427            > as alloy_sol_types::SolType>::Token<'a>;
7428            const SIGNATURE: &'static str = "getVersion()";
7429            const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8];
7430            #[inline]
7431            fn new<'a>(
7432                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7433            ) -> Self {
7434                tuple.into()
7435            }
7436            #[inline]
7437            fn tokenize(&self) -> Self::Token<'_> {
7438                ()
7439            }
7440            #[inline]
7441            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7442                getVersionReturn::_tokenize(ret)
7443            }
7444            #[inline]
7445            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7446                <Self::ReturnTuple<
7447                    '_,
7448                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7449                    .map(Into::into)
7450            }
7451            #[inline]
7452            fn abi_decode_returns_validate(
7453                data: &[u8],
7454            ) -> alloy_sol_types::Result<Self::Return> {
7455                <Self::ReturnTuple<
7456                    '_,
7457                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7458                    .map(Into::into)
7459            }
7460        }
7461    };
7462    #[derive(serde::Serialize, serde::Deserialize)]
7463    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7464    /**Function with signature `initialize(address,address,uint256,address)` and selector `0xbe203094`.
7465```solidity
7466function initialize(address _tokenAddress, address _lightClientAddress, uint256 _exitEscrowPeriod, address _timelock) external;
7467```*/
7468    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7469    #[derive(Clone)]
7470    pub struct initializeCall {
7471        #[allow(missing_docs)]
7472        pub _tokenAddress: alloy::sol_types::private::Address,
7473        #[allow(missing_docs)]
7474        pub _lightClientAddress: alloy::sol_types::private::Address,
7475        #[allow(missing_docs)]
7476        pub _exitEscrowPeriod: alloy::sol_types::private::primitives::aliases::U256,
7477        #[allow(missing_docs)]
7478        pub _timelock: alloy::sol_types::private::Address,
7479    }
7480    ///Container type for the return parameters of the [`initialize(address,address,uint256,address)`](initializeCall) function.
7481    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7482    #[derive(Clone)]
7483    pub struct initializeReturn {}
7484    #[allow(
7485        non_camel_case_types,
7486        non_snake_case,
7487        clippy::pub_underscore_fields,
7488        clippy::style
7489    )]
7490    const _: () = {
7491        use alloy::sol_types as alloy_sol_types;
7492        {
7493            #[doc(hidden)]
7494            #[allow(dead_code)]
7495            type UnderlyingSolTuple<'a> = (
7496                alloy::sol_types::sol_data::Address,
7497                alloy::sol_types::sol_data::Address,
7498                alloy::sol_types::sol_data::Uint<256>,
7499                alloy::sol_types::sol_data::Address,
7500            );
7501            #[doc(hidden)]
7502            type UnderlyingRustTuple<'a> = (
7503                alloy::sol_types::private::Address,
7504                alloy::sol_types::private::Address,
7505                alloy::sol_types::private::primitives::aliases::U256,
7506                alloy::sol_types::private::Address,
7507            );
7508            #[cfg(test)]
7509            #[allow(dead_code, unreachable_patterns)]
7510            fn _type_assertion(
7511                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7512            ) {
7513                match _t {
7514                    alloy_sol_types::private::AssertTypeEq::<
7515                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7516                    >(_) => {}
7517                }
7518            }
7519            #[automatically_derived]
7520            #[doc(hidden)]
7521            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
7522                fn from(value: initializeCall) -> Self {
7523                    (
7524                        value._tokenAddress,
7525                        value._lightClientAddress,
7526                        value._exitEscrowPeriod,
7527                        value._timelock,
7528                    )
7529                }
7530            }
7531            #[automatically_derived]
7532            #[doc(hidden)]
7533            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
7534                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7535                    Self {
7536                        _tokenAddress: tuple.0,
7537                        _lightClientAddress: tuple.1,
7538                        _exitEscrowPeriod: tuple.2,
7539                        _timelock: tuple.3,
7540                    }
7541                }
7542            }
7543        }
7544        {
7545            #[doc(hidden)]
7546            #[allow(dead_code)]
7547            type UnderlyingSolTuple<'a> = ();
7548            #[doc(hidden)]
7549            type UnderlyingRustTuple<'a> = ();
7550            #[cfg(test)]
7551            #[allow(dead_code, unreachable_patterns)]
7552            fn _type_assertion(
7553                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7554            ) {
7555                match _t {
7556                    alloy_sol_types::private::AssertTypeEq::<
7557                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7558                    >(_) => {}
7559                }
7560            }
7561            #[automatically_derived]
7562            #[doc(hidden)]
7563            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
7564                fn from(value: initializeReturn) -> Self {
7565                    ()
7566                }
7567            }
7568            #[automatically_derived]
7569            #[doc(hidden)]
7570            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
7571                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7572                    Self {}
7573                }
7574            }
7575        }
7576        impl initializeReturn {
7577            fn _tokenize(
7578                &self,
7579            ) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
7580                ()
7581            }
7582        }
7583        #[automatically_derived]
7584        impl alloy_sol_types::SolCall for initializeCall {
7585            type Parameters<'a> = (
7586                alloy::sol_types::sol_data::Address,
7587                alloy::sol_types::sol_data::Address,
7588                alloy::sol_types::sol_data::Uint<256>,
7589                alloy::sol_types::sol_data::Address,
7590            );
7591            type Token<'a> = <Self::Parameters<
7592                'a,
7593            > as alloy_sol_types::SolType>::Token<'a>;
7594            type Return = initializeReturn;
7595            type ReturnTuple<'a> = ();
7596            type ReturnToken<'a> = <Self::ReturnTuple<
7597                'a,
7598            > as alloy_sol_types::SolType>::Token<'a>;
7599            const SIGNATURE: &'static str = "initialize(address,address,uint256,address)";
7600            const SELECTOR: [u8; 4] = [190u8, 32u8, 48u8, 148u8];
7601            #[inline]
7602            fn new<'a>(
7603                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7604            ) -> Self {
7605                tuple.into()
7606            }
7607            #[inline]
7608            fn tokenize(&self) -> Self::Token<'_> {
7609                (
7610                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7611                        &self._tokenAddress,
7612                    ),
7613                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7614                        &self._lightClientAddress,
7615                    ),
7616                    <alloy::sol_types::sol_data::Uint<
7617                        256,
7618                    > as alloy_sol_types::SolType>::tokenize(&self._exitEscrowPeriod),
7619                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7620                        &self._timelock,
7621                    ),
7622                )
7623            }
7624            #[inline]
7625            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7626                initializeReturn::_tokenize(ret)
7627            }
7628            #[inline]
7629            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7630                <Self::ReturnTuple<
7631                    '_,
7632                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7633                    .map(Into::into)
7634            }
7635            #[inline]
7636            fn abi_decode_returns_validate(
7637                data: &[u8],
7638            ) -> alloy_sol_types::Result<Self::Return> {
7639                <Self::ReturnTuple<
7640                    '_,
7641                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7642                    .map(Into::into)
7643            }
7644        }
7645    };
7646    #[derive(serde::Serialize, serde::Deserialize)]
7647    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7648    /**Function with signature `initializedAtBlock()` and selector `0x3e9df9b5`.
7649```solidity
7650function initializedAtBlock() external view returns (uint256);
7651```*/
7652    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7653    #[derive(Clone)]
7654    pub struct initializedAtBlockCall;
7655    #[derive(serde::Serialize, serde::Deserialize)]
7656    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7657    ///Container type for the return parameters of the [`initializedAtBlock()`](initializedAtBlockCall) function.
7658    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7659    #[derive(Clone)]
7660    pub struct initializedAtBlockReturn {
7661        #[allow(missing_docs)]
7662        pub _0: alloy::sol_types::private::primitives::aliases::U256,
7663    }
7664    #[allow(
7665        non_camel_case_types,
7666        non_snake_case,
7667        clippy::pub_underscore_fields,
7668        clippy::style
7669    )]
7670    const _: () = {
7671        use alloy::sol_types as alloy_sol_types;
7672        {
7673            #[doc(hidden)]
7674            #[allow(dead_code)]
7675            type UnderlyingSolTuple<'a> = ();
7676            #[doc(hidden)]
7677            type UnderlyingRustTuple<'a> = ();
7678            #[cfg(test)]
7679            #[allow(dead_code, unreachable_patterns)]
7680            fn _type_assertion(
7681                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7682            ) {
7683                match _t {
7684                    alloy_sol_types::private::AssertTypeEq::<
7685                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7686                    >(_) => {}
7687                }
7688            }
7689            #[automatically_derived]
7690            #[doc(hidden)]
7691            impl ::core::convert::From<initializedAtBlockCall>
7692            for UnderlyingRustTuple<'_> {
7693                fn from(value: initializedAtBlockCall) -> Self {
7694                    ()
7695                }
7696            }
7697            #[automatically_derived]
7698            #[doc(hidden)]
7699            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7700            for initializedAtBlockCall {
7701                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7702                    Self
7703                }
7704            }
7705        }
7706        {
7707            #[doc(hidden)]
7708            #[allow(dead_code)]
7709            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7710            #[doc(hidden)]
7711            type UnderlyingRustTuple<'a> = (
7712                alloy::sol_types::private::primitives::aliases::U256,
7713            );
7714            #[cfg(test)]
7715            #[allow(dead_code, unreachable_patterns)]
7716            fn _type_assertion(
7717                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7718            ) {
7719                match _t {
7720                    alloy_sol_types::private::AssertTypeEq::<
7721                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7722                    >(_) => {}
7723                }
7724            }
7725            #[automatically_derived]
7726            #[doc(hidden)]
7727            impl ::core::convert::From<initializedAtBlockReturn>
7728            for UnderlyingRustTuple<'_> {
7729                fn from(value: initializedAtBlockReturn) -> Self {
7730                    (value._0,)
7731                }
7732            }
7733            #[automatically_derived]
7734            #[doc(hidden)]
7735            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7736            for initializedAtBlockReturn {
7737                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7738                    Self { _0: tuple.0 }
7739                }
7740            }
7741        }
7742        #[automatically_derived]
7743        impl alloy_sol_types::SolCall for initializedAtBlockCall {
7744            type Parameters<'a> = ();
7745            type Token<'a> = <Self::Parameters<
7746                'a,
7747            > as alloy_sol_types::SolType>::Token<'a>;
7748            type Return = alloy::sol_types::private::primitives::aliases::U256;
7749            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7750            type ReturnToken<'a> = <Self::ReturnTuple<
7751                'a,
7752            > as alloy_sol_types::SolType>::Token<'a>;
7753            const SIGNATURE: &'static str = "initializedAtBlock()";
7754            const SELECTOR: [u8; 4] = [62u8, 157u8, 249u8, 181u8];
7755            #[inline]
7756            fn new<'a>(
7757                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7758            ) -> Self {
7759                tuple.into()
7760            }
7761            #[inline]
7762            fn tokenize(&self) -> Self::Token<'_> {
7763                ()
7764            }
7765            #[inline]
7766            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7767                (
7768                    <alloy::sol_types::sol_data::Uint<
7769                        256,
7770                    > as alloy_sol_types::SolType>::tokenize(ret),
7771                )
7772            }
7773            #[inline]
7774            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7775                <Self::ReturnTuple<
7776                    '_,
7777                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7778                    .map(|r| {
7779                        let r: initializedAtBlockReturn = r.into();
7780                        r._0
7781                    })
7782            }
7783            #[inline]
7784            fn abi_decode_returns_validate(
7785                data: &[u8],
7786            ) -> alloy_sol_types::Result<Self::Return> {
7787                <Self::ReturnTuple<
7788                    '_,
7789                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7790                    .map(|r| {
7791                        let r: initializedAtBlockReturn = r.into();
7792                        r._0
7793                    })
7794            }
7795        }
7796    };
7797    #[derive(serde::Serialize, serde::Deserialize)]
7798    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7799    /**Function with signature `lightClient()` and selector `0xb5700e68`.
7800```solidity
7801function lightClient() external view returns (address);
7802```*/
7803    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7804    #[derive(Clone)]
7805    pub struct lightClientCall;
7806    #[derive(serde::Serialize, serde::Deserialize)]
7807    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7808    ///Container type for the return parameters of the [`lightClient()`](lightClientCall) function.
7809    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7810    #[derive(Clone)]
7811    pub struct lightClientReturn {
7812        #[allow(missing_docs)]
7813        pub _0: alloy::sol_types::private::Address,
7814    }
7815    #[allow(
7816        non_camel_case_types,
7817        non_snake_case,
7818        clippy::pub_underscore_fields,
7819        clippy::style
7820    )]
7821    const _: () = {
7822        use alloy::sol_types as alloy_sol_types;
7823        {
7824            #[doc(hidden)]
7825            #[allow(dead_code)]
7826            type UnderlyingSolTuple<'a> = ();
7827            #[doc(hidden)]
7828            type UnderlyingRustTuple<'a> = ();
7829            #[cfg(test)]
7830            #[allow(dead_code, unreachable_patterns)]
7831            fn _type_assertion(
7832                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7833            ) {
7834                match _t {
7835                    alloy_sol_types::private::AssertTypeEq::<
7836                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7837                    >(_) => {}
7838                }
7839            }
7840            #[automatically_derived]
7841            #[doc(hidden)]
7842            impl ::core::convert::From<lightClientCall> for UnderlyingRustTuple<'_> {
7843                fn from(value: lightClientCall) -> Self {
7844                    ()
7845                }
7846            }
7847            #[automatically_derived]
7848            #[doc(hidden)]
7849            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lightClientCall {
7850                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7851                    Self
7852                }
7853            }
7854        }
7855        {
7856            #[doc(hidden)]
7857            #[allow(dead_code)]
7858            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7859            #[doc(hidden)]
7860            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7861            #[cfg(test)]
7862            #[allow(dead_code, unreachable_patterns)]
7863            fn _type_assertion(
7864                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7865            ) {
7866                match _t {
7867                    alloy_sol_types::private::AssertTypeEq::<
7868                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7869                    >(_) => {}
7870                }
7871            }
7872            #[automatically_derived]
7873            #[doc(hidden)]
7874            impl ::core::convert::From<lightClientReturn> for UnderlyingRustTuple<'_> {
7875                fn from(value: lightClientReturn) -> Self {
7876                    (value._0,)
7877                }
7878            }
7879            #[automatically_derived]
7880            #[doc(hidden)]
7881            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lightClientReturn {
7882                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7883                    Self { _0: tuple.0 }
7884                }
7885            }
7886        }
7887        #[automatically_derived]
7888        impl alloy_sol_types::SolCall for lightClientCall {
7889            type Parameters<'a> = ();
7890            type Token<'a> = <Self::Parameters<
7891                'a,
7892            > as alloy_sol_types::SolType>::Token<'a>;
7893            type Return = alloy::sol_types::private::Address;
7894            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
7895            type ReturnToken<'a> = <Self::ReturnTuple<
7896                'a,
7897            > as alloy_sol_types::SolType>::Token<'a>;
7898            const SIGNATURE: &'static str = "lightClient()";
7899            const SELECTOR: [u8; 4] = [181u8, 112u8, 14u8, 104u8];
7900            #[inline]
7901            fn new<'a>(
7902                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7903            ) -> Self {
7904                tuple.into()
7905            }
7906            #[inline]
7907            fn tokenize(&self) -> Self::Token<'_> {
7908                ()
7909            }
7910            #[inline]
7911            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7912                (
7913                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7914                        ret,
7915                    ),
7916                )
7917            }
7918            #[inline]
7919            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7920                <Self::ReturnTuple<
7921                    '_,
7922                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7923                    .map(|r| {
7924                        let r: lightClientReturn = r.into();
7925                        r._0
7926                    })
7927            }
7928            #[inline]
7929            fn abi_decode_returns_validate(
7930                data: &[u8],
7931            ) -> alloy_sol_types::Result<Self::Return> {
7932                <Self::ReturnTuple<
7933                    '_,
7934                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7935                    .map(|r| {
7936                        let r: lightClientReturn = r.into();
7937                        r._0
7938                    })
7939            }
7940        }
7941    };
7942    #[derive(serde::Serialize, serde::Deserialize)]
7943    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7944    /**Function with signature `owner()` and selector `0x8da5cb5b`.
7945```solidity
7946function owner() external view returns (address);
7947```*/
7948    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7949    #[derive(Clone)]
7950    pub struct ownerCall;
7951    #[derive(serde::Serialize, serde::Deserialize)]
7952    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7953    ///Container type for the return parameters of the [`owner()`](ownerCall) function.
7954    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7955    #[derive(Clone)]
7956    pub struct ownerReturn {
7957        #[allow(missing_docs)]
7958        pub _0: alloy::sol_types::private::Address,
7959    }
7960    #[allow(
7961        non_camel_case_types,
7962        non_snake_case,
7963        clippy::pub_underscore_fields,
7964        clippy::style
7965    )]
7966    const _: () = {
7967        use alloy::sol_types as alloy_sol_types;
7968        {
7969            #[doc(hidden)]
7970            #[allow(dead_code)]
7971            type UnderlyingSolTuple<'a> = ();
7972            #[doc(hidden)]
7973            type UnderlyingRustTuple<'a> = ();
7974            #[cfg(test)]
7975            #[allow(dead_code, unreachable_patterns)]
7976            fn _type_assertion(
7977                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7978            ) {
7979                match _t {
7980                    alloy_sol_types::private::AssertTypeEq::<
7981                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7982                    >(_) => {}
7983                }
7984            }
7985            #[automatically_derived]
7986            #[doc(hidden)]
7987            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
7988                fn from(value: ownerCall) -> Self {
7989                    ()
7990                }
7991            }
7992            #[automatically_derived]
7993            #[doc(hidden)]
7994            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
7995                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7996                    Self
7997                }
7998            }
7999        }
8000        {
8001            #[doc(hidden)]
8002            #[allow(dead_code)]
8003            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8004            #[doc(hidden)]
8005            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8006            #[cfg(test)]
8007            #[allow(dead_code, unreachable_patterns)]
8008            fn _type_assertion(
8009                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8010            ) {
8011                match _t {
8012                    alloy_sol_types::private::AssertTypeEq::<
8013                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8014                    >(_) => {}
8015                }
8016            }
8017            #[automatically_derived]
8018            #[doc(hidden)]
8019            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
8020                fn from(value: ownerReturn) -> Self {
8021                    (value._0,)
8022                }
8023            }
8024            #[automatically_derived]
8025            #[doc(hidden)]
8026            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
8027                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8028                    Self { _0: tuple.0 }
8029                }
8030            }
8031        }
8032        #[automatically_derived]
8033        impl alloy_sol_types::SolCall for ownerCall {
8034            type Parameters<'a> = ();
8035            type Token<'a> = <Self::Parameters<
8036                'a,
8037            > as alloy_sol_types::SolType>::Token<'a>;
8038            type Return = alloy::sol_types::private::Address;
8039            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
8040            type ReturnToken<'a> = <Self::ReturnTuple<
8041                'a,
8042            > as alloy_sol_types::SolType>::Token<'a>;
8043            const SIGNATURE: &'static str = "owner()";
8044            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
8045            #[inline]
8046            fn new<'a>(
8047                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8048            ) -> Self {
8049                tuple.into()
8050            }
8051            #[inline]
8052            fn tokenize(&self) -> Self::Token<'_> {
8053                ()
8054            }
8055            #[inline]
8056            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8057                (
8058                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8059                        ret,
8060                    ),
8061                )
8062            }
8063            #[inline]
8064            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8065                <Self::ReturnTuple<
8066                    '_,
8067                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8068                    .map(|r| {
8069                        let r: ownerReturn = r.into();
8070                        r._0
8071                    })
8072            }
8073            #[inline]
8074            fn abi_decode_returns_validate(
8075                data: &[u8],
8076            ) -> alloy_sol_types::Result<Self::Return> {
8077                <Self::ReturnTuple<
8078                    '_,
8079                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8080                    .map(|r| {
8081                        let r: ownerReturn = r.into();
8082                        r._0
8083                    })
8084            }
8085        }
8086    };
8087    #[derive(serde::Serialize, serde::Deserialize)]
8088    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8089    /**Function with signature `proxiableUUID()` and selector `0x52d1902d`.
8090```solidity
8091function proxiableUUID() external view returns (bytes32);
8092```*/
8093    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8094    #[derive(Clone)]
8095    pub struct proxiableUUIDCall;
8096    #[derive(serde::Serialize, serde::Deserialize)]
8097    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8098    ///Container type for the return parameters of the [`proxiableUUID()`](proxiableUUIDCall) function.
8099    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8100    #[derive(Clone)]
8101    pub struct proxiableUUIDReturn {
8102        #[allow(missing_docs)]
8103        pub _0: alloy::sol_types::private::FixedBytes<32>,
8104    }
8105    #[allow(
8106        non_camel_case_types,
8107        non_snake_case,
8108        clippy::pub_underscore_fields,
8109        clippy::style
8110    )]
8111    const _: () = {
8112        use alloy::sol_types as alloy_sol_types;
8113        {
8114            #[doc(hidden)]
8115            #[allow(dead_code)]
8116            type UnderlyingSolTuple<'a> = ();
8117            #[doc(hidden)]
8118            type UnderlyingRustTuple<'a> = ();
8119            #[cfg(test)]
8120            #[allow(dead_code, unreachable_patterns)]
8121            fn _type_assertion(
8122                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8123            ) {
8124                match _t {
8125                    alloy_sol_types::private::AssertTypeEq::<
8126                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8127                    >(_) => {}
8128                }
8129            }
8130            #[automatically_derived]
8131            #[doc(hidden)]
8132            impl ::core::convert::From<proxiableUUIDCall> for UnderlyingRustTuple<'_> {
8133                fn from(value: proxiableUUIDCall) -> Self {
8134                    ()
8135                }
8136            }
8137            #[automatically_derived]
8138            #[doc(hidden)]
8139            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDCall {
8140                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8141                    Self
8142                }
8143            }
8144        }
8145        {
8146            #[doc(hidden)]
8147            #[allow(dead_code)]
8148            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8149            #[doc(hidden)]
8150            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
8151            #[cfg(test)]
8152            #[allow(dead_code, unreachable_patterns)]
8153            fn _type_assertion(
8154                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8155            ) {
8156                match _t {
8157                    alloy_sol_types::private::AssertTypeEq::<
8158                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8159                    >(_) => {}
8160                }
8161            }
8162            #[automatically_derived]
8163            #[doc(hidden)]
8164            impl ::core::convert::From<proxiableUUIDReturn> for UnderlyingRustTuple<'_> {
8165                fn from(value: proxiableUUIDReturn) -> Self {
8166                    (value._0,)
8167                }
8168            }
8169            #[automatically_derived]
8170            #[doc(hidden)]
8171            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDReturn {
8172                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8173                    Self { _0: tuple.0 }
8174                }
8175            }
8176        }
8177        #[automatically_derived]
8178        impl alloy_sol_types::SolCall for proxiableUUIDCall {
8179            type Parameters<'a> = ();
8180            type Token<'a> = <Self::Parameters<
8181                'a,
8182            > as alloy_sol_types::SolType>::Token<'a>;
8183            type Return = alloy::sol_types::private::FixedBytes<32>;
8184            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8185            type ReturnToken<'a> = <Self::ReturnTuple<
8186                'a,
8187            > as alloy_sol_types::SolType>::Token<'a>;
8188            const SIGNATURE: &'static str = "proxiableUUID()";
8189            const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8];
8190            #[inline]
8191            fn new<'a>(
8192                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8193            ) -> Self {
8194                tuple.into()
8195            }
8196            #[inline]
8197            fn tokenize(&self) -> Self::Token<'_> {
8198                ()
8199            }
8200            #[inline]
8201            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8202                (
8203                    <alloy::sol_types::sol_data::FixedBytes<
8204                        32,
8205                    > as alloy_sol_types::SolType>::tokenize(ret),
8206                )
8207            }
8208            #[inline]
8209            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8210                <Self::ReturnTuple<
8211                    '_,
8212                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8213                    .map(|r| {
8214                        let r: proxiableUUIDReturn = r.into();
8215                        r._0
8216                    })
8217            }
8218            #[inline]
8219            fn abi_decode_returns_validate(
8220                data: &[u8],
8221            ) -> alloy_sol_types::Result<Self::Return> {
8222                <Self::ReturnTuple<
8223                    '_,
8224                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8225                    .map(|r| {
8226                        let r: proxiableUUIDReturn = r.into();
8227                        r._0
8228                    })
8229            }
8230        }
8231    };
8232    #[derive(serde::Serialize, serde::Deserialize)]
8233    #[derive()]
8234    /**Function with signature `registerValidator((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256),uint16)` and selector `0x13b9057a`.
8235```solidity
8236function registerValidator(BN254.G2Point memory blsVK, EdOnBN254.EdOnBN254Point memory schnorrVK, BN254.G1Point memory blsSig, uint16 commission) external;
8237```*/
8238    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8239    #[derive(Clone)]
8240    pub struct registerValidatorCall {
8241        #[allow(missing_docs)]
8242        pub blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
8243        #[allow(missing_docs)]
8244        pub schnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
8245        #[allow(missing_docs)]
8246        pub blsSig: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
8247        #[allow(missing_docs)]
8248        pub commission: u16,
8249    }
8250    ///Container type for the return parameters of the [`registerValidator((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256),uint16)`](registerValidatorCall) function.
8251    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8252    #[derive(Clone)]
8253    pub struct registerValidatorReturn {}
8254    #[allow(
8255        non_camel_case_types,
8256        non_snake_case,
8257        clippy::pub_underscore_fields,
8258        clippy::style
8259    )]
8260    const _: () = {
8261        use alloy::sol_types as alloy_sol_types;
8262        {
8263            #[doc(hidden)]
8264            #[allow(dead_code)]
8265            type UnderlyingSolTuple<'a> = (
8266                BN254::G2Point,
8267                EdOnBN254::EdOnBN254Point,
8268                BN254::G1Point,
8269                alloy::sol_types::sol_data::Uint<16>,
8270            );
8271            #[doc(hidden)]
8272            type UnderlyingRustTuple<'a> = (
8273                <BN254::G2Point as alloy::sol_types::SolType>::RustType,
8274                <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
8275                <BN254::G1Point as alloy::sol_types::SolType>::RustType,
8276                u16,
8277            );
8278            #[cfg(test)]
8279            #[allow(dead_code, unreachable_patterns)]
8280            fn _type_assertion(
8281                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8282            ) {
8283                match _t {
8284                    alloy_sol_types::private::AssertTypeEq::<
8285                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8286                    >(_) => {}
8287                }
8288            }
8289            #[automatically_derived]
8290            #[doc(hidden)]
8291            impl ::core::convert::From<registerValidatorCall>
8292            for UnderlyingRustTuple<'_> {
8293                fn from(value: registerValidatorCall) -> Self {
8294                    (value.blsVK, value.schnorrVK, value.blsSig, value.commission)
8295                }
8296            }
8297            #[automatically_derived]
8298            #[doc(hidden)]
8299            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8300            for registerValidatorCall {
8301                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8302                    Self {
8303                        blsVK: tuple.0,
8304                        schnorrVK: tuple.1,
8305                        blsSig: tuple.2,
8306                        commission: tuple.3,
8307                    }
8308                }
8309            }
8310        }
8311        {
8312            #[doc(hidden)]
8313            #[allow(dead_code)]
8314            type UnderlyingSolTuple<'a> = ();
8315            #[doc(hidden)]
8316            type UnderlyingRustTuple<'a> = ();
8317            #[cfg(test)]
8318            #[allow(dead_code, unreachable_patterns)]
8319            fn _type_assertion(
8320                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8321            ) {
8322                match _t {
8323                    alloy_sol_types::private::AssertTypeEq::<
8324                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8325                    >(_) => {}
8326                }
8327            }
8328            #[automatically_derived]
8329            #[doc(hidden)]
8330            impl ::core::convert::From<registerValidatorReturn>
8331            for UnderlyingRustTuple<'_> {
8332                fn from(value: registerValidatorReturn) -> Self {
8333                    ()
8334                }
8335            }
8336            #[automatically_derived]
8337            #[doc(hidden)]
8338            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8339            for registerValidatorReturn {
8340                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8341                    Self {}
8342                }
8343            }
8344        }
8345        impl registerValidatorReturn {
8346            fn _tokenize(
8347                &self,
8348            ) -> <registerValidatorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
8349                ()
8350            }
8351        }
8352        #[automatically_derived]
8353        impl alloy_sol_types::SolCall for registerValidatorCall {
8354            type Parameters<'a> = (
8355                BN254::G2Point,
8356                EdOnBN254::EdOnBN254Point,
8357                BN254::G1Point,
8358                alloy::sol_types::sol_data::Uint<16>,
8359            );
8360            type Token<'a> = <Self::Parameters<
8361                'a,
8362            > as alloy_sol_types::SolType>::Token<'a>;
8363            type Return = registerValidatorReturn;
8364            type ReturnTuple<'a> = ();
8365            type ReturnToken<'a> = <Self::ReturnTuple<
8366                'a,
8367            > as alloy_sol_types::SolType>::Token<'a>;
8368            const SIGNATURE: &'static str = "registerValidator((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256),uint16)";
8369            const SELECTOR: [u8; 4] = [19u8, 185u8, 5u8, 122u8];
8370            #[inline]
8371            fn new<'a>(
8372                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8373            ) -> Self {
8374                tuple.into()
8375            }
8376            #[inline]
8377            fn tokenize(&self) -> Self::Token<'_> {
8378                (
8379                    <BN254::G2Point as alloy_sol_types::SolType>::tokenize(&self.blsVK),
8380                    <EdOnBN254::EdOnBN254Point as alloy_sol_types::SolType>::tokenize(
8381                        &self.schnorrVK,
8382                    ),
8383                    <BN254::G1Point as alloy_sol_types::SolType>::tokenize(&self.blsSig),
8384                    <alloy::sol_types::sol_data::Uint<
8385                        16,
8386                    > as alloy_sol_types::SolType>::tokenize(&self.commission),
8387                )
8388            }
8389            #[inline]
8390            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8391                registerValidatorReturn::_tokenize(ret)
8392            }
8393            #[inline]
8394            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8395                <Self::ReturnTuple<
8396                    '_,
8397                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8398                    .map(Into::into)
8399            }
8400            #[inline]
8401            fn abi_decode_returns_validate(
8402                data: &[u8],
8403            ) -> alloy_sol_types::Result<Self::Return> {
8404                <Self::ReturnTuple<
8405                    '_,
8406                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8407                    .map(Into::into)
8408            }
8409        }
8410    };
8411    #[derive(serde::Serialize, serde::Deserialize)]
8412    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8413    /**Function with signature `renounceOwnership()` and selector `0x715018a6`.
8414```solidity
8415function renounceOwnership() external;
8416```*/
8417    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8418    #[derive(Clone)]
8419    pub struct renounceOwnershipCall;
8420    ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function.
8421    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8422    #[derive(Clone)]
8423    pub struct renounceOwnershipReturn {}
8424    #[allow(
8425        non_camel_case_types,
8426        non_snake_case,
8427        clippy::pub_underscore_fields,
8428        clippy::style
8429    )]
8430    const _: () = {
8431        use alloy::sol_types as alloy_sol_types;
8432        {
8433            #[doc(hidden)]
8434            #[allow(dead_code)]
8435            type UnderlyingSolTuple<'a> = ();
8436            #[doc(hidden)]
8437            type UnderlyingRustTuple<'a> = ();
8438            #[cfg(test)]
8439            #[allow(dead_code, unreachable_patterns)]
8440            fn _type_assertion(
8441                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8442            ) {
8443                match _t {
8444                    alloy_sol_types::private::AssertTypeEq::<
8445                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8446                    >(_) => {}
8447                }
8448            }
8449            #[automatically_derived]
8450            #[doc(hidden)]
8451            impl ::core::convert::From<renounceOwnershipCall>
8452            for UnderlyingRustTuple<'_> {
8453                fn from(value: renounceOwnershipCall) -> Self {
8454                    ()
8455                }
8456            }
8457            #[automatically_derived]
8458            #[doc(hidden)]
8459            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8460            for renounceOwnershipCall {
8461                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8462                    Self
8463                }
8464            }
8465        }
8466        {
8467            #[doc(hidden)]
8468            #[allow(dead_code)]
8469            type UnderlyingSolTuple<'a> = ();
8470            #[doc(hidden)]
8471            type UnderlyingRustTuple<'a> = ();
8472            #[cfg(test)]
8473            #[allow(dead_code, unreachable_patterns)]
8474            fn _type_assertion(
8475                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8476            ) {
8477                match _t {
8478                    alloy_sol_types::private::AssertTypeEq::<
8479                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8480                    >(_) => {}
8481                }
8482            }
8483            #[automatically_derived]
8484            #[doc(hidden)]
8485            impl ::core::convert::From<renounceOwnershipReturn>
8486            for UnderlyingRustTuple<'_> {
8487                fn from(value: renounceOwnershipReturn) -> Self {
8488                    ()
8489                }
8490            }
8491            #[automatically_derived]
8492            #[doc(hidden)]
8493            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8494            for renounceOwnershipReturn {
8495                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8496                    Self {}
8497                }
8498            }
8499        }
8500        impl renounceOwnershipReturn {
8501            fn _tokenize(
8502                &self,
8503            ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
8504                ()
8505            }
8506        }
8507        #[automatically_derived]
8508        impl alloy_sol_types::SolCall for renounceOwnershipCall {
8509            type Parameters<'a> = ();
8510            type Token<'a> = <Self::Parameters<
8511                'a,
8512            > as alloy_sol_types::SolType>::Token<'a>;
8513            type Return = renounceOwnershipReturn;
8514            type ReturnTuple<'a> = ();
8515            type ReturnToken<'a> = <Self::ReturnTuple<
8516                'a,
8517            > as alloy_sol_types::SolType>::Token<'a>;
8518            const SIGNATURE: &'static str = "renounceOwnership()";
8519            const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
8520            #[inline]
8521            fn new<'a>(
8522                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8523            ) -> Self {
8524                tuple.into()
8525            }
8526            #[inline]
8527            fn tokenize(&self) -> Self::Token<'_> {
8528                ()
8529            }
8530            #[inline]
8531            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8532                renounceOwnershipReturn::_tokenize(ret)
8533            }
8534            #[inline]
8535            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8536                <Self::ReturnTuple<
8537                    '_,
8538                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8539                    .map(Into::into)
8540            }
8541            #[inline]
8542            fn abi_decode_returns_validate(
8543                data: &[u8],
8544            ) -> alloy_sol_types::Result<Self::Return> {
8545                <Self::ReturnTuple<
8546                    '_,
8547                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8548                    .map(Into::into)
8549            }
8550        }
8551    };
8552    #[derive(serde::Serialize, serde::Deserialize)]
8553    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8554    /**Function with signature `token()` and selector `0xfc0c546a`.
8555```solidity
8556function token() external view returns (address);
8557```*/
8558    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8559    #[derive(Clone)]
8560    pub struct tokenCall;
8561    #[derive(serde::Serialize, serde::Deserialize)]
8562    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8563    ///Container type for the return parameters of the [`token()`](tokenCall) function.
8564    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8565    #[derive(Clone)]
8566    pub struct tokenReturn {
8567        #[allow(missing_docs)]
8568        pub _0: alloy::sol_types::private::Address,
8569    }
8570    #[allow(
8571        non_camel_case_types,
8572        non_snake_case,
8573        clippy::pub_underscore_fields,
8574        clippy::style
8575    )]
8576    const _: () = {
8577        use alloy::sol_types as alloy_sol_types;
8578        {
8579            #[doc(hidden)]
8580            #[allow(dead_code)]
8581            type UnderlyingSolTuple<'a> = ();
8582            #[doc(hidden)]
8583            type UnderlyingRustTuple<'a> = ();
8584            #[cfg(test)]
8585            #[allow(dead_code, unreachable_patterns)]
8586            fn _type_assertion(
8587                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8588            ) {
8589                match _t {
8590                    alloy_sol_types::private::AssertTypeEq::<
8591                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8592                    >(_) => {}
8593                }
8594            }
8595            #[automatically_derived]
8596            #[doc(hidden)]
8597            impl ::core::convert::From<tokenCall> for UnderlyingRustTuple<'_> {
8598                fn from(value: tokenCall) -> Self {
8599                    ()
8600                }
8601            }
8602            #[automatically_derived]
8603            #[doc(hidden)]
8604            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenCall {
8605                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8606                    Self
8607                }
8608            }
8609        }
8610        {
8611            #[doc(hidden)]
8612            #[allow(dead_code)]
8613            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8614            #[doc(hidden)]
8615            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8616            #[cfg(test)]
8617            #[allow(dead_code, unreachable_patterns)]
8618            fn _type_assertion(
8619                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8620            ) {
8621                match _t {
8622                    alloy_sol_types::private::AssertTypeEq::<
8623                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8624                    >(_) => {}
8625                }
8626            }
8627            #[automatically_derived]
8628            #[doc(hidden)]
8629            impl ::core::convert::From<tokenReturn> for UnderlyingRustTuple<'_> {
8630                fn from(value: tokenReturn) -> Self {
8631                    (value._0,)
8632                }
8633            }
8634            #[automatically_derived]
8635            #[doc(hidden)]
8636            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenReturn {
8637                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8638                    Self { _0: tuple.0 }
8639                }
8640            }
8641        }
8642        #[automatically_derived]
8643        impl alloy_sol_types::SolCall for tokenCall {
8644            type Parameters<'a> = ();
8645            type Token<'a> = <Self::Parameters<
8646                'a,
8647            > as alloy_sol_types::SolType>::Token<'a>;
8648            type Return = alloy::sol_types::private::Address;
8649            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
8650            type ReturnToken<'a> = <Self::ReturnTuple<
8651                'a,
8652            > as alloy_sol_types::SolType>::Token<'a>;
8653            const SIGNATURE: &'static str = "token()";
8654            const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8];
8655            #[inline]
8656            fn new<'a>(
8657                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8658            ) -> Self {
8659                tuple.into()
8660            }
8661            #[inline]
8662            fn tokenize(&self) -> Self::Token<'_> {
8663                ()
8664            }
8665            #[inline]
8666            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8667                (
8668                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8669                        ret,
8670                    ),
8671                )
8672            }
8673            #[inline]
8674            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8675                <Self::ReturnTuple<
8676                    '_,
8677                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8678                    .map(|r| {
8679                        let r: tokenReturn = r.into();
8680                        r._0
8681                    })
8682            }
8683            #[inline]
8684            fn abi_decode_returns_validate(
8685                data: &[u8],
8686            ) -> alloy_sol_types::Result<Self::Return> {
8687                <Self::ReturnTuple<
8688                    '_,
8689                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8690                    .map(|r| {
8691                        let r: tokenReturn = r.into();
8692                        r._0
8693                    })
8694            }
8695        }
8696    };
8697    #[derive(serde::Serialize, serde::Deserialize)]
8698    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8699    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
8700```solidity
8701function transferOwnership(address newOwner) external;
8702```*/
8703    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8704    #[derive(Clone)]
8705    pub struct transferOwnershipCall {
8706        #[allow(missing_docs)]
8707        pub newOwner: alloy::sol_types::private::Address,
8708    }
8709    ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function.
8710    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8711    #[derive(Clone)]
8712    pub struct transferOwnershipReturn {}
8713    #[allow(
8714        non_camel_case_types,
8715        non_snake_case,
8716        clippy::pub_underscore_fields,
8717        clippy::style
8718    )]
8719    const _: () = {
8720        use alloy::sol_types as alloy_sol_types;
8721        {
8722            #[doc(hidden)]
8723            #[allow(dead_code)]
8724            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8725            #[doc(hidden)]
8726            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8727            #[cfg(test)]
8728            #[allow(dead_code, unreachable_patterns)]
8729            fn _type_assertion(
8730                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8731            ) {
8732                match _t {
8733                    alloy_sol_types::private::AssertTypeEq::<
8734                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8735                    >(_) => {}
8736                }
8737            }
8738            #[automatically_derived]
8739            #[doc(hidden)]
8740            impl ::core::convert::From<transferOwnershipCall>
8741            for UnderlyingRustTuple<'_> {
8742                fn from(value: transferOwnershipCall) -> Self {
8743                    (value.newOwner,)
8744                }
8745            }
8746            #[automatically_derived]
8747            #[doc(hidden)]
8748            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8749            for transferOwnershipCall {
8750                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8751                    Self { newOwner: tuple.0 }
8752                }
8753            }
8754        }
8755        {
8756            #[doc(hidden)]
8757            #[allow(dead_code)]
8758            type UnderlyingSolTuple<'a> = ();
8759            #[doc(hidden)]
8760            type UnderlyingRustTuple<'a> = ();
8761            #[cfg(test)]
8762            #[allow(dead_code, unreachable_patterns)]
8763            fn _type_assertion(
8764                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8765            ) {
8766                match _t {
8767                    alloy_sol_types::private::AssertTypeEq::<
8768                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8769                    >(_) => {}
8770                }
8771            }
8772            #[automatically_derived]
8773            #[doc(hidden)]
8774            impl ::core::convert::From<transferOwnershipReturn>
8775            for UnderlyingRustTuple<'_> {
8776                fn from(value: transferOwnershipReturn) -> Self {
8777                    ()
8778                }
8779            }
8780            #[automatically_derived]
8781            #[doc(hidden)]
8782            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8783            for transferOwnershipReturn {
8784                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8785                    Self {}
8786                }
8787            }
8788        }
8789        impl transferOwnershipReturn {
8790            fn _tokenize(
8791                &self,
8792            ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
8793                ()
8794            }
8795        }
8796        #[automatically_derived]
8797        impl alloy_sol_types::SolCall for transferOwnershipCall {
8798            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
8799            type Token<'a> = <Self::Parameters<
8800                'a,
8801            > as alloy_sol_types::SolType>::Token<'a>;
8802            type Return = transferOwnershipReturn;
8803            type ReturnTuple<'a> = ();
8804            type ReturnToken<'a> = <Self::ReturnTuple<
8805                'a,
8806            > as alloy_sol_types::SolType>::Token<'a>;
8807            const SIGNATURE: &'static str = "transferOwnership(address)";
8808            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
8809            #[inline]
8810            fn new<'a>(
8811                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8812            ) -> Self {
8813                tuple.into()
8814            }
8815            #[inline]
8816            fn tokenize(&self) -> Self::Token<'_> {
8817                (
8818                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8819                        &self.newOwner,
8820                    ),
8821                )
8822            }
8823            #[inline]
8824            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8825                transferOwnershipReturn::_tokenize(ret)
8826            }
8827            #[inline]
8828            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8829                <Self::ReturnTuple<
8830                    '_,
8831                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8832                    .map(Into::into)
8833            }
8834            #[inline]
8835            fn abi_decode_returns_validate(
8836                data: &[u8],
8837            ) -> alloy_sol_types::Result<Self::Return> {
8838                <Self::ReturnTuple<
8839                    '_,
8840                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8841                    .map(Into::into)
8842            }
8843        }
8844    };
8845    #[derive(serde::Serialize, serde::Deserialize)]
8846    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8847    /**Function with signature `undelegate(address,uint256)` and selector `0x4d99dd16`.
8848```solidity
8849function undelegate(address validator, uint256 amount) external;
8850```*/
8851    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8852    #[derive(Clone)]
8853    pub struct undelegateCall {
8854        #[allow(missing_docs)]
8855        pub validator: alloy::sol_types::private::Address,
8856        #[allow(missing_docs)]
8857        pub amount: alloy::sol_types::private::primitives::aliases::U256,
8858    }
8859    ///Container type for the return parameters of the [`undelegate(address,uint256)`](undelegateCall) function.
8860    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8861    #[derive(Clone)]
8862    pub struct undelegateReturn {}
8863    #[allow(
8864        non_camel_case_types,
8865        non_snake_case,
8866        clippy::pub_underscore_fields,
8867        clippy::style
8868    )]
8869    const _: () = {
8870        use alloy::sol_types as alloy_sol_types;
8871        {
8872            #[doc(hidden)]
8873            #[allow(dead_code)]
8874            type UnderlyingSolTuple<'a> = (
8875                alloy::sol_types::sol_data::Address,
8876                alloy::sol_types::sol_data::Uint<256>,
8877            );
8878            #[doc(hidden)]
8879            type UnderlyingRustTuple<'a> = (
8880                alloy::sol_types::private::Address,
8881                alloy::sol_types::private::primitives::aliases::U256,
8882            );
8883            #[cfg(test)]
8884            #[allow(dead_code, unreachable_patterns)]
8885            fn _type_assertion(
8886                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8887            ) {
8888                match _t {
8889                    alloy_sol_types::private::AssertTypeEq::<
8890                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8891                    >(_) => {}
8892                }
8893            }
8894            #[automatically_derived]
8895            #[doc(hidden)]
8896            impl ::core::convert::From<undelegateCall> for UnderlyingRustTuple<'_> {
8897                fn from(value: undelegateCall) -> Self {
8898                    (value.validator, value.amount)
8899                }
8900            }
8901            #[automatically_derived]
8902            #[doc(hidden)]
8903            impl ::core::convert::From<UnderlyingRustTuple<'_>> for undelegateCall {
8904                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8905                    Self {
8906                        validator: tuple.0,
8907                        amount: tuple.1,
8908                    }
8909                }
8910            }
8911        }
8912        {
8913            #[doc(hidden)]
8914            #[allow(dead_code)]
8915            type UnderlyingSolTuple<'a> = ();
8916            #[doc(hidden)]
8917            type UnderlyingRustTuple<'a> = ();
8918            #[cfg(test)]
8919            #[allow(dead_code, unreachable_patterns)]
8920            fn _type_assertion(
8921                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8922            ) {
8923                match _t {
8924                    alloy_sol_types::private::AssertTypeEq::<
8925                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8926                    >(_) => {}
8927                }
8928            }
8929            #[automatically_derived]
8930            #[doc(hidden)]
8931            impl ::core::convert::From<undelegateReturn> for UnderlyingRustTuple<'_> {
8932                fn from(value: undelegateReturn) -> Self {
8933                    ()
8934                }
8935            }
8936            #[automatically_derived]
8937            #[doc(hidden)]
8938            impl ::core::convert::From<UnderlyingRustTuple<'_>> for undelegateReturn {
8939                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8940                    Self {}
8941                }
8942            }
8943        }
8944        impl undelegateReturn {
8945            fn _tokenize(
8946                &self,
8947            ) -> <undelegateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
8948                ()
8949            }
8950        }
8951        #[automatically_derived]
8952        impl alloy_sol_types::SolCall for undelegateCall {
8953            type Parameters<'a> = (
8954                alloy::sol_types::sol_data::Address,
8955                alloy::sol_types::sol_data::Uint<256>,
8956            );
8957            type Token<'a> = <Self::Parameters<
8958                'a,
8959            > as alloy_sol_types::SolType>::Token<'a>;
8960            type Return = undelegateReturn;
8961            type ReturnTuple<'a> = ();
8962            type ReturnToken<'a> = <Self::ReturnTuple<
8963                'a,
8964            > as alloy_sol_types::SolType>::Token<'a>;
8965            const SIGNATURE: &'static str = "undelegate(address,uint256)";
8966            const SELECTOR: [u8; 4] = [77u8, 153u8, 221u8, 22u8];
8967            #[inline]
8968            fn new<'a>(
8969                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8970            ) -> Self {
8971                tuple.into()
8972            }
8973            #[inline]
8974            fn tokenize(&self) -> Self::Token<'_> {
8975                (
8976                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8977                        &self.validator,
8978                    ),
8979                    <alloy::sol_types::sol_data::Uint<
8980                        256,
8981                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
8982                )
8983            }
8984            #[inline]
8985            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8986                undelegateReturn::_tokenize(ret)
8987            }
8988            #[inline]
8989            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8990                <Self::ReturnTuple<
8991                    '_,
8992                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8993                    .map(Into::into)
8994            }
8995            #[inline]
8996            fn abi_decode_returns_validate(
8997                data: &[u8],
8998            ) -> alloy_sol_types::Result<Self::Return> {
8999                <Self::ReturnTuple<
9000                    '_,
9001                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9002                    .map(Into::into)
9003            }
9004        }
9005    };
9006    #[derive(serde::Serialize, serde::Deserialize)]
9007    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9008    /**Function with signature `undelegations(address,address)` and selector `0xa2d78dd5`.
9009```solidity
9010function undelegations(address validator, address delegator) external view returns (uint256 amount, uint256 unlocksAt);
9011```*/
9012    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9013    #[derive(Clone)]
9014    pub struct undelegationsCall {
9015        #[allow(missing_docs)]
9016        pub validator: alloy::sol_types::private::Address,
9017        #[allow(missing_docs)]
9018        pub delegator: alloy::sol_types::private::Address,
9019    }
9020    #[derive(serde::Serialize, serde::Deserialize)]
9021    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9022    ///Container type for the return parameters of the [`undelegations(address,address)`](undelegationsCall) function.
9023    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9024    #[derive(Clone)]
9025    pub struct undelegationsReturn {
9026        #[allow(missing_docs)]
9027        pub amount: alloy::sol_types::private::primitives::aliases::U256,
9028        #[allow(missing_docs)]
9029        pub unlocksAt: alloy::sol_types::private::primitives::aliases::U256,
9030    }
9031    #[allow(
9032        non_camel_case_types,
9033        non_snake_case,
9034        clippy::pub_underscore_fields,
9035        clippy::style
9036    )]
9037    const _: () = {
9038        use alloy::sol_types as alloy_sol_types;
9039        {
9040            #[doc(hidden)]
9041            #[allow(dead_code)]
9042            type UnderlyingSolTuple<'a> = (
9043                alloy::sol_types::sol_data::Address,
9044                alloy::sol_types::sol_data::Address,
9045            );
9046            #[doc(hidden)]
9047            type UnderlyingRustTuple<'a> = (
9048                alloy::sol_types::private::Address,
9049                alloy::sol_types::private::Address,
9050            );
9051            #[cfg(test)]
9052            #[allow(dead_code, unreachable_patterns)]
9053            fn _type_assertion(
9054                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9055            ) {
9056                match _t {
9057                    alloy_sol_types::private::AssertTypeEq::<
9058                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9059                    >(_) => {}
9060                }
9061            }
9062            #[automatically_derived]
9063            #[doc(hidden)]
9064            impl ::core::convert::From<undelegationsCall> for UnderlyingRustTuple<'_> {
9065                fn from(value: undelegationsCall) -> Self {
9066                    (value.validator, value.delegator)
9067                }
9068            }
9069            #[automatically_derived]
9070            #[doc(hidden)]
9071            impl ::core::convert::From<UnderlyingRustTuple<'_>> for undelegationsCall {
9072                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9073                    Self {
9074                        validator: tuple.0,
9075                        delegator: tuple.1,
9076                    }
9077                }
9078            }
9079        }
9080        {
9081            #[doc(hidden)]
9082            #[allow(dead_code)]
9083            type UnderlyingSolTuple<'a> = (
9084                alloy::sol_types::sol_data::Uint<256>,
9085                alloy::sol_types::sol_data::Uint<256>,
9086            );
9087            #[doc(hidden)]
9088            type UnderlyingRustTuple<'a> = (
9089                alloy::sol_types::private::primitives::aliases::U256,
9090                alloy::sol_types::private::primitives::aliases::U256,
9091            );
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<undelegationsReturn> for UnderlyingRustTuple<'_> {
9106                fn from(value: undelegationsReturn) -> Self {
9107                    (value.amount, value.unlocksAt)
9108                }
9109            }
9110            #[automatically_derived]
9111            #[doc(hidden)]
9112            impl ::core::convert::From<UnderlyingRustTuple<'_>> for undelegationsReturn {
9113                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9114                    Self {
9115                        amount: tuple.0,
9116                        unlocksAt: tuple.1,
9117                    }
9118                }
9119            }
9120        }
9121        impl undelegationsReturn {
9122            fn _tokenize(
9123                &self,
9124            ) -> <undelegationsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
9125                (
9126                    <alloy::sol_types::sol_data::Uint<
9127                        256,
9128                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
9129                    <alloy::sol_types::sol_data::Uint<
9130                        256,
9131                    > as alloy_sol_types::SolType>::tokenize(&self.unlocksAt),
9132                )
9133            }
9134        }
9135        #[automatically_derived]
9136        impl alloy_sol_types::SolCall for undelegationsCall {
9137            type Parameters<'a> = (
9138                alloy::sol_types::sol_data::Address,
9139                alloy::sol_types::sol_data::Address,
9140            );
9141            type Token<'a> = <Self::Parameters<
9142                'a,
9143            > as alloy_sol_types::SolType>::Token<'a>;
9144            type Return = undelegationsReturn;
9145            type ReturnTuple<'a> = (
9146                alloy::sol_types::sol_data::Uint<256>,
9147                alloy::sol_types::sol_data::Uint<256>,
9148            );
9149            type ReturnToken<'a> = <Self::ReturnTuple<
9150                'a,
9151            > as alloy_sol_types::SolType>::Token<'a>;
9152            const SIGNATURE: &'static str = "undelegations(address,address)";
9153            const SELECTOR: [u8; 4] = [162u8, 215u8, 141u8, 213u8];
9154            #[inline]
9155            fn new<'a>(
9156                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9157            ) -> Self {
9158                tuple.into()
9159            }
9160            #[inline]
9161            fn tokenize(&self) -> Self::Token<'_> {
9162                (
9163                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9164                        &self.validator,
9165                    ),
9166                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9167                        &self.delegator,
9168                    ),
9169                )
9170            }
9171            #[inline]
9172            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9173                undelegationsReturn::_tokenize(ret)
9174            }
9175            #[inline]
9176            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9177                <Self::ReturnTuple<
9178                    '_,
9179                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9180                    .map(Into::into)
9181            }
9182            #[inline]
9183            fn abi_decode_returns_validate(
9184                data: &[u8],
9185            ) -> alloy_sol_types::Result<Self::Return> {
9186                <Self::ReturnTuple<
9187                    '_,
9188                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9189                    .map(Into::into)
9190            }
9191        }
9192    };
9193    #[derive(serde::Serialize, serde::Deserialize)]
9194    #[derive()]
9195    /**Function with signature `updateConsensusKeys((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256))` and selector `0x5544c2f1`.
9196```solidity
9197function updateConsensusKeys(BN254.G2Point memory newBlsVK, EdOnBN254.EdOnBN254Point memory newSchnorrVK, BN254.G1Point memory newBlsSig) external;
9198```*/
9199    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9200    #[derive(Clone)]
9201    pub struct updateConsensusKeysCall {
9202        #[allow(missing_docs)]
9203        pub newBlsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
9204        #[allow(missing_docs)]
9205        pub newSchnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
9206        #[allow(missing_docs)]
9207        pub newBlsSig: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
9208    }
9209    ///Container type for the return parameters of the [`updateConsensusKeys((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256))`](updateConsensusKeysCall) function.
9210    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9211    #[derive(Clone)]
9212    pub struct updateConsensusKeysReturn {}
9213    #[allow(
9214        non_camel_case_types,
9215        non_snake_case,
9216        clippy::pub_underscore_fields,
9217        clippy::style
9218    )]
9219    const _: () = {
9220        use alloy::sol_types as alloy_sol_types;
9221        {
9222            #[doc(hidden)]
9223            #[allow(dead_code)]
9224            type UnderlyingSolTuple<'a> = (
9225                BN254::G2Point,
9226                EdOnBN254::EdOnBN254Point,
9227                BN254::G1Point,
9228            );
9229            #[doc(hidden)]
9230            type UnderlyingRustTuple<'a> = (
9231                <BN254::G2Point as alloy::sol_types::SolType>::RustType,
9232                <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
9233                <BN254::G1Point as alloy::sol_types::SolType>::RustType,
9234            );
9235            #[cfg(test)]
9236            #[allow(dead_code, unreachable_patterns)]
9237            fn _type_assertion(
9238                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9239            ) {
9240                match _t {
9241                    alloy_sol_types::private::AssertTypeEq::<
9242                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9243                    >(_) => {}
9244                }
9245            }
9246            #[automatically_derived]
9247            #[doc(hidden)]
9248            impl ::core::convert::From<updateConsensusKeysCall>
9249            for UnderlyingRustTuple<'_> {
9250                fn from(value: updateConsensusKeysCall) -> Self {
9251                    (value.newBlsVK, value.newSchnorrVK, value.newBlsSig)
9252                }
9253            }
9254            #[automatically_derived]
9255            #[doc(hidden)]
9256            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9257            for updateConsensusKeysCall {
9258                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9259                    Self {
9260                        newBlsVK: tuple.0,
9261                        newSchnorrVK: tuple.1,
9262                        newBlsSig: tuple.2,
9263                    }
9264                }
9265            }
9266        }
9267        {
9268            #[doc(hidden)]
9269            #[allow(dead_code)]
9270            type UnderlyingSolTuple<'a> = ();
9271            #[doc(hidden)]
9272            type UnderlyingRustTuple<'a> = ();
9273            #[cfg(test)]
9274            #[allow(dead_code, unreachable_patterns)]
9275            fn _type_assertion(
9276                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9277            ) {
9278                match _t {
9279                    alloy_sol_types::private::AssertTypeEq::<
9280                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9281                    >(_) => {}
9282                }
9283            }
9284            #[automatically_derived]
9285            #[doc(hidden)]
9286            impl ::core::convert::From<updateConsensusKeysReturn>
9287            for UnderlyingRustTuple<'_> {
9288                fn from(value: updateConsensusKeysReturn) -> Self {
9289                    ()
9290                }
9291            }
9292            #[automatically_derived]
9293            #[doc(hidden)]
9294            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9295            for updateConsensusKeysReturn {
9296                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9297                    Self {}
9298                }
9299            }
9300        }
9301        impl updateConsensusKeysReturn {
9302            fn _tokenize(
9303                &self,
9304            ) -> <updateConsensusKeysCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
9305                ()
9306            }
9307        }
9308        #[automatically_derived]
9309        impl alloy_sol_types::SolCall for updateConsensusKeysCall {
9310            type Parameters<'a> = (
9311                BN254::G2Point,
9312                EdOnBN254::EdOnBN254Point,
9313                BN254::G1Point,
9314            );
9315            type Token<'a> = <Self::Parameters<
9316                'a,
9317            > as alloy_sol_types::SolType>::Token<'a>;
9318            type Return = updateConsensusKeysReturn;
9319            type ReturnTuple<'a> = ();
9320            type ReturnToken<'a> = <Self::ReturnTuple<
9321                'a,
9322            > as alloy_sol_types::SolType>::Token<'a>;
9323            const SIGNATURE: &'static str = "updateConsensusKeys((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256))";
9324            const SELECTOR: [u8; 4] = [85u8, 68u8, 194u8, 241u8];
9325            #[inline]
9326            fn new<'a>(
9327                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9328            ) -> Self {
9329                tuple.into()
9330            }
9331            #[inline]
9332            fn tokenize(&self) -> Self::Token<'_> {
9333                (
9334                    <BN254::G2Point as alloy_sol_types::SolType>::tokenize(
9335                        &self.newBlsVK,
9336                    ),
9337                    <EdOnBN254::EdOnBN254Point as alloy_sol_types::SolType>::tokenize(
9338                        &self.newSchnorrVK,
9339                    ),
9340                    <BN254::G1Point as alloy_sol_types::SolType>::tokenize(
9341                        &self.newBlsSig,
9342                    ),
9343                )
9344            }
9345            #[inline]
9346            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9347                updateConsensusKeysReturn::_tokenize(ret)
9348            }
9349            #[inline]
9350            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9351                <Self::ReturnTuple<
9352                    '_,
9353                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9354                    .map(Into::into)
9355            }
9356            #[inline]
9357            fn abi_decode_returns_validate(
9358                data: &[u8],
9359            ) -> alloy_sol_types::Result<Self::Return> {
9360                <Self::ReturnTuple<
9361                    '_,
9362                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9363                    .map(Into::into)
9364            }
9365        }
9366    };
9367    #[derive(serde::Serialize, serde::Deserialize)]
9368    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9369    /**Function with signature `upgradeToAndCall(address,bytes)` and selector `0x4f1ef286`.
9370```solidity
9371function upgradeToAndCall(address newImplementation, bytes memory data) external payable;
9372```*/
9373    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9374    #[derive(Clone)]
9375    pub struct upgradeToAndCallCall {
9376        #[allow(missing_docs)]
9377        pub newImplementation: alloy::sol_types::private::Address,
9378        #[allow(missing_docs)]
9379        pub data: alloy::sol_types::private::Bytes,
9380    }
9381    ///Container type for the return parameters of the [`upgradeToAndCall(address,bytes)`](upgradeToAndCallCall) function.
9382    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9383    #[derive(Clone)]
9384    pub struct upgradeToAndCallReturn {}
9385    #[allow(
9386        non_camel_case_types,
9387        non_snake_case,
9388        clippy::pub_underscore_fields,
9389        clippy::style
9390    )]
9391    const _: () = {
9392        use alloy::sol_types as alloy_sol_types;
9393        {
9394            #[doc(hidden)]
9395            #[allow(dead_code)]
9396            type UnderlyingSolTuple<'a> = (
9397                alloy::sol_types::sol_data::Address,
9398                alloy::sol_types::sol_data::Bytes,
9399            );
9400            #[doc(hidden)]
9401            type UnderlyingRustTuple<'a> = (
9402                alloy::sol_types::private::Address,
9403                alloy::sol_types::private::Bytes,
9404            );
9405            #[cfg(test)]
9406            #[allow(dead_code, unreachable_patterns)]
9407            fn _type_assertion(
9408                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9409            ) {
9410                match _t {
9411                    alloy_sol_types::private::AssertTypeEq::<
9412                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9413                    >(_) => {}
9414                }
9415            }
9416            #[automatically_derived]
9417            #[doc(hidden)]
9418            impl ::core::convert::From<upgradeToAndCallCall>
9419            for UnderlyingRustTuple<'_> {
9420                fn from(value: upgradeToAndCallCall) -> Self {
9421                    (value.newImplementation, value.data)
9422                }
9423            }
9424            #[automatically_derived]
9425            #[doc(hidden)]
9426            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9427            for upgradeToAndCallCall {
9428                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9429                    Self {
9430                        newImplementation: tuple.0,
9431                        data: tuple.1,
9432                    }
9433                }
9434            }
9435        }
9436        {
9437            #[doc(hidden)]
9438            #[allow(dead_code)]
9439            type UnderlyingSolTuple<'a> = ();
9440            #[doc(hidden)]
9441            type UnderlyingRustTuple<'a> = ();
9442            #[cfg(test)]
9443            #[allow(dead_code, unreachable_patterns)]
9444            fn _type_assertion(
9445                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9446            ) {
9447                match _t {
9448                    alloy_sol_types::private::AssertTypeEq::<
9449                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9450                    >(_) => {}
9451                }
9452            }
9453            #[automatically_derived]
9454            #[doc(hidden)]
9455            impl ::core::convert::From<upgradeToAndCallReturn>
9456            for UnderlyingRustTuple<'_> {
9457                fn from(value: upgradeToAndCallReturn) -> Self {
9458                    ()
9459                }
9460            }
9461            #[automatically_derived]
9462            #[doc(hidden)]
9463            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9464            for upgradeToAndCallReturn {
9465                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9466                    Self {}
9467                }
9468            }
9469        }
9470        impl upgradeToAndCallReturn {
9471            fn _tokenize(
9472                &self,
9473            ) -> <upgradeToAndCallCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
9474                ()
9475            }
9476        }
9477        #[automatically_derived]
9478        impl alloy_sol_types::SolCall for upgradeToAndCallCall {
9479            type Parameters<'a> = (
9480                alloy::sol_types::sol_data::Address,
9481                alloy::sol_types::sol_data::Bytes,
9482            );
9483            type Token<'a> = <Self::Parameters<
9484                'a,
9485            > as alloy_sol_types::SolType>::Token<'a>;
9486            type Return = upgradeToAndCallReturn;
9487            type ReturnTuple<'a> = ();
9488            type ReturnToken<'a> = <Self::ReturnTuple<
9489                'a,
9490            > as alloy_sol_types::SolType>::Token<'a>;
9491            const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)";
9492            const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8];
9493            #[inline]
9494            fn new<'a>(
9495                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9496            ) -> Self {
9497                tuple.into()
9498            }
9499            #[inline]
9500            fn tokenize(&self) -> Self::Token<'_> {
9501                (
9502                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9503                        &self.newImplementation,
9504                    ),
9505                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
9506                        &self.data,
9507                    ),
9508                )
9509            }
9510            #[inline]
9511            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9512                upgradeToAndCallReturn::_tokenize(ret)
9513            }
9514            #[inline]
9515            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9516                <Self::ReturnTuple<
9517                    '_,
9518                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9519                    .map(Into::into)
9520            }
9521            #[inline]
9522            fn abi_decode_returns_validate(
9523                data: &[u8],
9524            ) -> alloy_sol_types::Result<Self::Return> {
9525                <Self::ReturnTuple<
9526                    '_,
9527                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9528                    .map(Into::into)
9529            }
9530        }
9531    };
9532    #[derive(serde::Serialize, serde::Deserialize)]
9533    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9534    /**Function with signature `validatorExits(address)` and selector `0xb5ecb344`.
9535```solidity
9536function validatorExits(address validator) external view returns (uint256 unlocksAt);
9537```*/
9538    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9539    #[derive(Clone)]
9540    pub struct validatorExitsCall {
9541        #[allow(missing_docs)]
9542        pub validator: alloy::sol_types::private::Address,
9543    }
9544    #[derive(serde::Serialize, serde::Deserialize)]
9545    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9546    ///Container type for the return parameters of the [`validatorExits(address)`](validatorExitsCall) function.
9547    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9548    #[derive(Clone)]
9549    pub struct validatorExitsReturn {
9550        #[allow(missing_docs)]
9551        pub unlocksAt: alloy::sol_types::private::primitives::aliases::U256,
9552    }
9553    #[allow(
9554        non_camel_case_types,
9555        non_snake_case,
9556        clippy::pub_underscore_fields,
9557        clippy::style
9558    )]
9559    const _: () = {
9560        use alloy::sol_types as alloy_sol_types;
9561        {
9562            #[doc(hidden)]
9563            #[allow(dead_code)]
9564            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
9565            #[doc(hidden)]
9566            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
9567            #[cfg(test)]
9568            #[allow(dead_code, unreachable_patterns)]
9569            fn _type_assertion(
9570                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9571            ) {
9572                match _t {
9573                    alloy_sol_types::private::AssertTypeEq::<
9574                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9575                    >(_) => {}
9576                }
9577            }
9578            #[automatically_derived]
9579            #[doc(hidden)]
9580            impl ::core::convert::From<validatorExitsCall> for UnderlyingRustTuple<'_> {
9581                fn from(value: validatorExitsCall) -> Self {
9582                    (value.validator,)
9583                }
9584            }
9585            #[automatically_derived]
9586            #[doc(hidden)]
9587            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validatorExitsCall {
9588                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9589                    Self { validator: tuple.0 }
9590                }
9591            }
9592        }
9593        {
9594            #[doc(hidden)]
9595            #[allow(dead_code)]
9596            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9597            #[doc(hidden)]
9598            type UnderlyingRustTuple<'a> = (
9599                alloy::sol_types::private::primitives::aliases::U256,
9600            );
9601            #[cfg(test)]
9602            #[allow(dead_code, unreachable_patterns)]
9603            fn _type_assertion(
9604                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9605            ) {
9606                match _t {
9607                    alloy_sol_types::private::AssertTypeEq::<
9608                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9609                    >(_) => {}
9610                }
9611            }
9612            #[automatically_derived]
9613            #[doc(hidden)]
9614            impl ::core::convert::From<validatorExitsReturn>
9615            for UnderlyingRustTuple<'_> {
9616                fn from(value: validatorExitsReturn) -> Self {
9617                    (value.unlocksAt,)
9618                }
9619            }
9620            #[automatically_derived]
9621            #[doc(hidden)]
9622            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9623            for validatorExitsReturn {
9624                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9625                    Self { unlocksAt: tuple.0 }
9626                }
9627            }
9628        }
9629        #[automatically_derived]
9630        impl alloy_sol_types::SolCall for validatorExitsCall {
9631            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
9632            type Token<'a> = <Self::Parameters<
9633                'a,
9634            > as alloy_sol_types::SolType>::Token<'a>;
9635            type Return = alloy::sol_types::private::primitives::aliases::U256;
9636            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9637            type ReturnToken<'a> = <Self::ReturnTuple<
9638                'a,
9639            > as alloy_sol_types::SolType>::Token<'a>;
9640            const SIGNATURE: &'static str = "validatorExits(address)";
9641            const SELECTOR: [u8; 4] = [181u8, 236u8, 179u8, 68u8];
9642            #[inline]
9643            fn new<'a>(
9644                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9645            ) -> Self {
9646                tuple.into()
9647            }
9648            #[inline]
9649            fn tokenize(&self) -> Self::Token<'_> {
9650                (
9651                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9652                        &self.validator,
9653                    ),
9654                )
9655            }
9656            #[inline]
9657            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9658                (
9659                    <alloy::sol_types::sol_data::Uint<
9660                        256,
9661                    > as alloy_sol_types::SolType>::tokenize(ret),
9662                )
9663            }
9664            #[inline]
9665            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9666                <Self::ReturnTuple<
9667                    '_,
9668                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9669                    .map(|r| {
9670                        let r: validatorExitsReturn = r.into();
9671                        r.unlocksAt
9672                    })
9673            }
9674            #[inline]
9675            fn abi_decode_returns_validate(
9676                data: &[u8],
9677            ) -> alloy_sol_types::Result<Self::Return> {
9678                <Self::ReturnTuple<
9679                    '_,
9680                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9681                    .map(|r| {
9682                        let r: validatorExitsReturn = r.into();
9683                        r.unlocksAt
9684                    })
9685            }
9686        }
9687    };
9688    #[derive(serde::Serialize, serde::Deserialize)]
9689    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9690    /**Function with signature `validators(address)` and selector `0xfa52c7d8`.
9691```solidity
9692function validators(address account) external view returns (uint256 delegatedAmount, ValidatorStatus status);
9693```*/
9694    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9695    #[derive(Clone)]
9696    pub struct validatorsCall {
9697        #[allow(missing_docs)]
9698        pub account: alloy::sol_types::private::Address,
9699    }
9700    #[derive(serde::Serialize, serde::Deserialize)]
9701    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9702    ///Container type for the return parameters of the [`validators(address)`](validatorsCall) function.
9703    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9704    #[derive(Clone)]
9705    pub struct validatorsReturn {
9706        #[allow(missing_docs)]
9707        pub delegatedAmount: alloy::sol_types::private::primitives::aliases::U256,
9708        #[allow(missing_docs)]
9709        pub status: <ValidatorStatus as alloy::sol_types::SolType>::RustType,
9710    }
9711    #[allow(
9712        non_camel_case_types,
9713        non_snake_case,
9714        clippy::pub_underscore_fields,
9715        clippy::style
9716    )]
9717    const _: () = {
9718        use alloy::sol_types as alloy_sol_types;
9719        {
9720            #[doc(hidden)]
9721            #[allow(dead_code)]
9722            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
9723            #[doc(hidden)]
9724            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
9725            #[cfg(test)]
9726            #[allow(dead_code, unreachable_patterns)]
9727            fn _type_assertion(
9728                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9729            ) {
9730                match _t {
9731                    alloy_sol_types::private::AssertTypeEq::<
9732                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9733                    >(_) => {}
9734                }
9735            }
9736            #[automatically_derived]
9737            #[doc(hidden)]
9738            impl ::core::convert::From<validatorsCall> for UnderlyingRustTuple<'_> {
9739                fn from(value: validatorsCall) -> Self {
9740                    (value.account,)
9741                }
9742            }
9743            #[automatically_derived]
9744            #[doc(hidden)]
9745            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validatorsCall {
9746                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9747                    Self { account: tuple.0 }
9748                }
9749            }
9750        }
9751        {
9752            #[doc(hidden)]
9753            #[allow(dead_code)]
9754            type UnderlyingSolTuple<'a> = (
9755                alloy::sol_types::sol_data::Uint<256>,
9756                ValidatorStatus,
9757            );
9758            #[doc(hidden)]
9759            type UnderlyingRustTuple<'a> = (
9760                alloy::sol_types::private::primitives::aliases::U256,
9761                <ValidatorStatus as alloy::sol_types::SolType>::RustType,
9762            );
9763            #[cfg(test)]
9764            #[allow(dead_code, unreachable_patterns)]
9765            fn _type_assertion(
9766                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9767            ) {
9768                match _t {
9769                    alloy_sol_types::private::AssertTypeEq::<
9770                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9771                    >(_) => {}
9772                }
9773            }
9774            #[automatically_derived]
9775            #[doc(hidden)]
9776            impl ::core::convert::From<validatorsReturn> for UnderlyingRustTuple<'_> {
9777                fn from(value: validatorsReturn) -> Self {
9778                    (value.delegatedAmount, value.status)
9779                }
9780            }
9781            #[automatically_derived]
9782            #[doc(hidden)]
9783            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validatorsReturn {
9784                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9785                    Self {
9786                        delegatedAmount: tuple.0,
9787                        status: tuple.1,
9788                    }
9789                }
9790            }
9791        }
9792        impl validatorsReturn {
9793            fn _tokenize(
9794                &self,
9795            ) -> <validatorsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
9796                (
9797                    <alloy::sol_types::sol_data::Uint<
9798                        256,
9799                    > as alloy_sol_types::SolType>::tokenize(&self.delegatedAmount),
9800                    <ValidatorStatus as alloy_sol_types::SolType>::tokenize(&self.status),
9801                )
9802            }
9803        }
9804        #[automatically_derived]
9805        impl alloy_sol_types::SolCall for validatorsCall {
9806            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
9807            type Token<'a> = <Self::Parameters<
9808                'a,
9809            > as alloy_sol_types::SolType>::Token<'a>;
9810            type Return = validatorsReturn;
9811            type ReturnTuple<'a> = (
9812                alloy::sol_types::sol_data::Uint<256>,
9813                ValidatorStatus,
9814            );
9815            type ReturnToken<'a> = <Self::ReturnTuple<
9816                'a,
9817            > as alloy_sol_types::SolType>::Token<'a>;
9818            const SIGNATURE: &'static str = "validators(address)";
9819            const SELECTOR: [u8; 4] = [250u8, 82u8, 199u8, 216u8];
9820            #[inline]
9821            fn new<'a>(
9822                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9823            ) -> Self {
9824                tuple.into()
9825            }
9826            #[inline]
9827            fn tokenize(&self) -> Self::Token<'_> {
9828                (
9829                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9830                        &self.account,
9831                    ),
9832                )
9833            }
9834            #[inline]
9835            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9836                validatorsReturn::_tokenize(ret)
9837            }
9838            #[inline]
9839            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9840                <Self::ReturnTuple<
9841                    '_,
9842                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9843                    .map(Into::into)
9844            }
9845            #[inline]
9846            fn abi_decode_returns_validate(
9847                data: &[u8],
9848            ) -> alloy_sol_types::Result<Self::Return> {
9849                <Self::ReturnTuple<
9850                    '_,
9851                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9852                    .map(Into::into)
9853            }
9854        }
9855    };
9856    ///Container for all the [`StakeTable`](self) function calls.
9857    #[derive(Clone)]
9858    #[derive(serde::Serialize, serde::Deserialize)]
9859    #[derive()]
9860    pub enum StakeTableCalls {
9861        #[allow(missing_docs)]
9862        UPGRADE_INTERFACE_VERSION(UPGRADE_INTERFACE_VERSIONCall),
9863        #[allow(missing_docs)]
9864        _hashBlsKey(_hashBlsKeyCall),
9865        #[allow(missing_docs)]
9866        blsKeys(blsKeysCall),
9867        #[allow(missing_docs)]
9868        claimValidatorExit(claimValidatorExitCall),
9869        #[allow(missing_docs)]
9870        claimWithdrawal(claimWithdrawalCall),
9871        #[allow(missing_docs)]
9872        delegate(delegateCall),
9873        #[allow(missing_docs)]
9874        delegations(delegationsCall),
9875        #[allow(missing_docs)]
9876        deregisterValidator(deregisterValidatorCall),
9877        #[allow(missing_docs)]
9878        exitEscrowPeriod(exitEscrowPeriodCall),
9879        #[allow(missing_docs)]
9880        getVersion(getVersionCall),
9881        #[allow(missing_docs)]
9882        initialize(initializeCall),
9883        #[allow(missing_docs)]
9884        initializedAtBlock(initializedAtBlockCall),
9885        #[allow(missing_docs)]
9886        lightClient(lightClientCall),
9887        #[allow(missing_docs)]
9888        owner(ownerCall),
9889        #[allow(missing_docs)]
9890        proxiableUUID(proxiableUUIDCall),
9891        #[allow(missing_docs)]
9892        registerValidator(registerValidatorCall),
9893        #[allow(missing_docs)]
9894        renounceOwnership(renounceOwnershipCall),
9895        #[allow(missing_docs)]
9896        token(tokenCall),
9897        #[allow(missing_docs)]
9898        transferOwnership(transferOwnershipCall),
9899        #[allow(missing_docs)]
9900        undelegate(undelegateCall),
9901        #[allow(missing_docs)]
9902        undelegations(undelegationsCall),
9903        #[allow(missing_docs)]
9904        updateConsensusKeys(updateConsensusKeysCall),
9905        #[allow(missing_docs)]
9906        upgradeToAndCall(upgradeToAndCallCall),
9907        #[allow(missing_docs)]
9908        validatorExits(validatorExitsCall),
9909        #[allow(missing_docs)]
9910        validators(validatorsCall),
9911    }
9912    impl StakeTableCalls {
9913        /// All the selectors of this enum.
9914        ///
9915        /// Note that the selectors might not be in the same order as the variants.
9916        /// No guarantees are made about the order of the selectors.
9917        ///
9918        /// Prefer using `SolInterface` methods instead.
9919        pub const SELECTORS: &'static [[u8; 4usize]] = &[
9920            [2u8, 110u8, 64u8, 43u8],
9921            [13u8, 142u8, 110u8, 44u8],
9922            [19u8, 185u8, 5u8, 122u8],
9923            [33u8, 64u8, 254u8, 205u8],
9924            [62u8, 157u8, 249u8, 181u8],
9925            [77u8, 153u8, 221u8, 22u8],
9926            [79u8, 30u8, 242u8, 134u8],
9927            [82u8, 209u8, 144u8, 45u8],
9928            [85u8, 68u8, 194u8, 241u8],
9929            [106u8, 145u8, 28u8, 207u8],
9930            [113u8, 80u8, 24u8, 166u8],
9931            [141u8, 165u8, 203u8, 91u8],
9932            [155u8, 48u8, 165u8, 230u8],
9933            [158u8, 154u8, 143u8, 49u8],
9934            [162u8, 215u8, 141u8, 213u8],
9935            [163u8, 6u8, 106u8, 171u8],
9936            [173u8, 60u8, 177u8, 204u8],
9937            [179u8, 230u8, 235u8, 213u8],
9938            [181u8, 112u8, 14u8, 104u8],
9939            [181u8, 236u8, 179u8, 68u8],
9940            [190u8, 32u8, 48u8, 148u8],
9941            [198u8, 72u8, 20u8, 221u8],
9942            [242u8, 253u8, 227u8, 139u8],
9943            [250u8, 82u8, 199u8, 216u8],
9944            [252u8, 12u8, 84u8, 106u8],
9945        ];
9946        /// The names of the variants in the same order as `SELECTORS`.
9947        pub const VARIANT_NAMES: &'static [&'static str] = &[
9948            ::core::stringify!(delegate),
9949            ::core::stringify!(getVersion),
9950            ::core::stringify!(registerValidator),
9951            ::core::stringify!(claimValidatorExit),
9952            ::core::stringify!(initializedAtBlock),
9953            ::core::stringify!(undelegate),
9954            ::core::stringify!(upgradeToAndCall),
9955            ::core::stringify!(proxiableUUID),
9956            ::core::stringify!(updateConsensusKeys),
9957            ::core::stringify!(deregisterValidator),
9958            ::core::stringify!(renounceOwnership),
9959            ::core::stringify!(owner),
9960            ::core::stringify!(_hashBlsKey),
9961            ::core::stringify!(exitEscrowPeriod),
9962            ::core::stringify!(undelegations),
9963            ::core::stringify!(claimWithdrawal),
9964            ::core::stringify!(UPGRADE_INTERFACE_VERSION),
9965            ::core::stringify!(blsKeys),
9966            ::core::stringify!(lightClient),
9967            ::core::stringify!(validatorExits),
9968            ::core::stringify!(initialize),
9969            ::core::stringify!(delegations),
9970            ::core::stringify!(transferOwnership),
9971            ::core::stringify!(validators),
9972            ::core::stringify!(token),
9973        ];
9974        /// The signatures in the same order as `SELECTORS`.
9975        pub const SIGNATURES: &'static [&'static str] = &[
9976            <delegateCall as alloy_sol_types::SolCall>::SIGNATURE,
9977            <getVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
9978            <registerValidatorCall as alloy_sol_types::SolCall>::SIGNATURE,
9979            <claimValidatorExitCall as alloy_sol_types::SolCall>::SIGNATURE,
9980            <initializedAtBlockCall as alloy_sol_types::SolCall>::SIGNATURE,
9981            <undelegateCall as alloy_sol_types::SolCall>::SIGNATURE,
9982            <upgradeToAndCallCall as alloy_sol_types::SolCall>::SIGNATURE,
9983            <proxiableUUIDCall as alloy_sol_types::SolCall>::SIGNATURE,
9984            <updateConsensusKeysCall as alloy_sol_types::SolCall>::SIGNATURE,
9985            <deregisterValidatorCall as alloy_sol_types::SolCall>::SIGNATURE,
9986            <renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
9987            <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
9988            <_hashBlsKeyCall as alloy_sol_types::SolCall>::SIGNATURE,
9989            <exitEscrowPeriodCall as alloy_sol_types::SolCall>::SIGNATURE,
9990            <undelegationsCall as alloy_sol_types::SolCall>::SIGNATURE,
9991            <claimWithdrawalCall as alloy_sol_types::SolCall>::SIGNATURE,
9992            <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SIGNATURE,
9993            <blsKeysCall as alloy_sol_types::SolCall>::SIGNATURE,
9994            <lightClientCall as alloy_sol_types::SolCall>::SIGNATURE,
9995            <validatorExitsCall as alloy_sol_types::SolCall>::SIGNATURE,
9996            <initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
9997            <delegationsCall as alloy_sol_types::SolCall>::SIGNATURE,
9998            <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
9999            <validatorsCall as alloy_sol_types::SolCall>::SIGNATURE,
10000            <tokenCall as alloy_sol_types::SolCall>::SIGNATURE,
10001        ];
10002        /// Returns the signature for the given selector, if known.
10003        #[inline]
10004        pub fn signature_by_selector(
10005            selector: [u8; 4usize],
10006        ) -> ::core::option::Option<&'static str> {
10007            match Self::SELECTORS.binary_search(&selector) {
10008                ::core::result::Result::Ok(idx) => {
10009                    ::core::option::Option::Some(Self::SIGNATURES[idx])
10010                }
10011                ::core::result::Result::Err(_) => ::core::option::Option::None,
10012            }
10013        }
10014        /// Returns the enum variant name for the given selector, if known.
10015        #[inline]
10016        pub fn name_by_selector(
10017            selector: [u8; 4usize],
10018        ) -> ::core::option::Option<&'static str> {
10019            let sig = Self::signature_by_selector(selector)?;
10020            sig.split_once('(').map(|(name, _)| name)
10021        }
10022    }
10023    #[automatically_derived]
10024    impl alloy_sol_types::SolInterface for StakeTableCalls {
10025        const NAME: &'static str = "StakeTableCalls";
10026        const MIN_DATA_LENGTH: usize = 0usize;
10027        const COUNT: usize = 25usize;
10028        #[inline]
10029        fn selector(&self) -> [u8; 4] {
10030            match self {
10031                Self::UPGRADE_INTERFACE_VERSION(_) => {
10032                    <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SELECTOR
10033                }
10034                Self::_hashBlsKey(_) => {
10035                    <_hashBlsKeyCall as alloy_sol_types::SolCall>::SELECTOR
10036                }
10037                Self::blsKeys(_) => <blsKeysCall as alloy_sol_types::SolCall>::SELECTOR,
10038                Self::claimValidatorExit(_) => {
10039                    <claimValidatorExitCall as alloy_sol_types::SolCall>::SELECTOR
10040                }
10041                Self::claimWithdrawal(_) => {
10042                    <claimWithdrawalCall as alloy_sol_types::SolCall>::SELECTOR
10043                }
10044                Self::delegate(_) => <delegateCall as alloy_sol_types::SolCall>::SELECTOR,
10045                Self::delegations(_) => {
10046                    <delegationsCall as alloy_sol_types::SolCall>::SELECTOR
10047                }
10048                Self::deregisterValidator(_) => {
10049                    <deregisterValidatorCall as alloy_sol_types::SolCall>::SELECTOR
10050                }
10051                Self::exitEscrowPeriod(_) => {
10052                    <exitEscrowPeriodCall as alloy_sol_types::SolCall>::SELECTOR
10053                }
10054                Self::getVersion(_) => {
10055                    <getVersionCall as alloy_sol_types::SolCall>::SELECTOR
10056                }
10057                Self::initialize(_) => {
10058                    <initializeCall as alloy_sol_types::SolCall>::SELECTOR
10059                }
10060                Self::initializedAtBlock(_) => {
10061                    <initializedAtBlockCall as alloy_sol_types::SolCall>::SELECTOR
10062                }
10063                Self::lightClient(_) => {
10064                    <lightClientCall as alloy_sol_types::SolCall>::SELECTOR
10065                }
10066                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
10067                Self::proxiableUUID(_) => {
10068                    <proxiableUUIDCall as alloy_sol_types::SolCall>::SELECTOR
10069                }
10070                Self::registerValidator(_) => {
10071                    <registerValidatorCall as alloy_sol_types::SolCall>::SELECTOR
10072                }
10073                Self::renounceOwnership(_) => {
10074                    <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
10075                }
10076                Self::token(_) => <tokenCall as alloy_sol_types::SolCall>::SELECTOR,
10077                Self::transferOwnership(_) => {
10078                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
10079                }
10080                Self::undelegate(_) => {
10081                    <undelegateCall as alloy_sol_types::SolCall>::SELECTOR
10082                }
10083                Self::undelegations(_) => {
10084                    <undelegationsCall as alloy_sol_types::SolCall>::SELECTOR
10085                }
10086                Self::updateConsensusKeys(_) => {
10087                    <updateConsensusKeysCall as alloy_sol_types::SolCall>::SELECTOR
10088                }
10089                Self::upgradeToAndCall(_) => {
10090                    <upgradeToAndCallCall as alloy_sol_types::SolCall>::SELECTOR
10091                }
10092                Self::validatorExits(_) => {
10093                    <validatorExitsCall as alloy_sol_types::SolCall>::SELECTOR
10094                }
10095                Self::validators(_) => {
10096                    <validatorsCall as alloy_sol_types::SolCall>::SELECTOR
10097                }
10098            }
10099        }
10100        #[inline]
10101        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
10102            Self::SELECTORS.get(i).copied()
10103        }
10104        #[inline]
10105        fn valid_selector(selector: [u8; 4]) -> bool {
10106            Self::SELECTORS.binary_search(&selector).is_ok()
10107        }
10108        #[inline]
10109        #[allow(non_snake_case)]
10110        fn abi_decode_raw(
10111            selector: [u8; 4],
10112            data: &[u8],
10113        ) -> alloy_sol_types::Result<Self> {
10114            static DECODE_SHIMS: &[fn(
10115                &[u8],
10116            ) -> alloy_sol_types::Result<StakeTableCalls>] = &[
10117                {
10118                    fn delegate(
10119                        data: &[u8],
10120                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10121                        <delegateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
10122                            .map(StakeTableCalls::delegate)
10123                    }
10124                    delegate
10125                },
10126                {
10127                    fn getVersion(
10128                        data: &[u8],
10129                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10130                        <getVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(
10131                                data,
10132                            )
10133                            .map(StakeTableCalls::getVersion)
10134                    }
10135                    getVersion
10136                },
10137                {
10138                    fn registerValidator(
10139                        data: &[u8],
10140                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10141                        <registerValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
10142                                data,
10143                            )
10144                            .map(StakeTableCalls::registerValidator)
10145                    }
10146                    registerValidator
10147                },
10148                {
10149                    fn claimValidatorExit(
10150                        data: &[u8],
10151                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10152                        <claimValidatorExitCall as alloy_sol_types::SolCall>::abi_decode_raw(
10153                                data,
10154                            )
10155                            .map(StakeTableCalls::claimValidatorExit)
10156                    }
10157                    claimValidatorExit
10158                },
10159                {
10160                    fn initializedAtBlock(
10161                        data: &[u8],
10162                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10163                        <initializedAtBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
10164                                data,
10165                            )
10166                            .map(StakeTableCalls::initializedAtBlock)
10167                    }
10168                    initializedAtBlock
10169                },
10170                {
10171                    fn undelegate(
10172                        data: &[u8],
10173                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10174                        <undelegateCall as alloy_sol_types::SolCall>::abi_decode_raw(
10175                                data,
10176                            )
10177                            .map(StakeTableCalls::undelegate)
10178                    }
10179                    undelegate
10180                },
10181                {
10182                    fn upgradeToAndCall(
10183                        data: &[u8],
10184                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10185                        <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(
10186                                data,
10187                            )
10188                            .map(StakeTableCalls::upgradeToAndCall)
10189                    }
10190                    upgradeToAndCall
10191                },
10192                {
10193                    fn proxiableUUID(
10194                        data: &[u8],
10195                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10196                        <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
10197                                data,
10198                            )
10199                            .map(StakeTableCalls::proxiableUUID)
10200                    }
10201                    proxiableUUID
10202                },
10203                {
10204                    fn updateConsensusKeys(
10205                        data: &[u8],
10206                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10207                        <updateConsensusKeysCall as alloy_sol_types::SolCall>::abi_decode_raw(
10208                                data,
10209                            )
10210                            .map(StakeTableCalls::updateConsensusKeys)
10211                    }
10212                    updateConsensusKeys
10213                },
10214                {
10215                    fn deregisterValidator(
10216                        data: &[u8],
10217                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10218                        <deregisterValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
10219                                data,
10220                            )
10221                            .map(StakeTableCalls::deregisterValidator)
10222                    }
10223                    deregisterValidator
10224                },
10225                {
10226                    fn renounceOwnership(
10227                        data: &[u8],
10228                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10229                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
10230                                data,
10231                            )
10232                            .map(StakeTableCalls::renounceOwnership)
10233                    }
10234                    renounceOwnership
10235                },
10236                {
10237                    fn owner(data: &[u8]) -> alloy_sol_types::Result<StakeTableCalls> {
10238                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
10239                            .map(StakeTableCalls::owner)
10240                    }
10241                    owner
10242                },
10243                {
10244                    fn _hashBlsKey(
10245                        data: &[u8],
10246                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10247                        <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_decode_raw(
10248                                data,
10249                            )
10250                            .map(StakeTableCalls::_hashBlsKey)
10251                    }
10252                    _hashBlsKey
10253                },
10254                {
10255                    fn exitEscrowPeriod(
10256                        data: &[u8],
10257                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10258                        <exitEscrowPeriodCall as alloy_sol_types::SolCall>::abi_decode_raw(
10259                                data,
10260                            )
10261                            .map(StakeTableCalls::exitEscrowPeriod)
10262                    }
10263                    exitEscrowPeriod
10264                },
10265                {
10266                    fn undelegations(
10267                        data: &[u8],
10268                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10269                        <undelegationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
10270                                data,
10271                            )
10272                            .map(StakeTableCalls::undelegations)
10273                    }
10274                    undelegations
10275                },
10276                {
10277                    fn claimWithdrawal(
10278                        data: &[u8],
10279                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10280                        <claimWithdrawalCall as alloy_sol_types::SolCall>::abi_decode_raw(
10281                                data,
10282                            )
10283                            .map(StakeTableCalls::claimWithdrawal)
10284                    }
10285                    claimWithdrawal
10286                },
10287                {
10288                    fn UPGRADE_INTERFACE_VERSION(
10289                        data: &[u8],
10290                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10291                        <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(
10292                                data,
10293                            )
10294                            .map(StakeTableCalls::UPGRADE_INTERFACE_VERSION)
10295                    }
10296                    UPGRADE_INTERFACE_VERSION
10297                },
10298                {
10299                    fn blsKeys(data: &[u8]) -> alloy_sol_types::Result<StakeTableCalls> {
10300                        <blsKeysCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
10301                            .map(StakeTableCalls::blsKeys)
10302                    }
10303                    blsKeys
10304                },
10305                {
10306                    fn lightClient(
10307                        data: &[u8],
10308                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10309                        <lightClientCall as alloy_sol_types::SolCall>::abi_decode_raw(
10310                                data,
10311                            )
10312                            .map(StakeTableCalls::lightClient)
10313                    }
10314                    lightClient
10315                },
10316                {
10317                    fn validatorExits(
10318                        data: &[u8],
10319                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10320                        <validatorExitsCall as alloy_sol_types::SolCall>::abi_decode_raw(
10321                                data,
10322                            )
10323                            .map(StakeTableCalls::validatorExits)
10324                    }
10325                    validatorExits
10326                },
10327                {
10328                    fn initialize(
10329                        data: &[u8],
10330                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10331                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
10332                                data,
10333                            )
10334                            .map(StakeTableCalls::initialize)
10335                    }
10336                    initialize
10337                },
10338                {
10339                    fn delegations(
10340                        data: &[u8],
10341                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10342                        <delegationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
10343                                data,
10344                            )
10345                            .map(StakeTableCalls::delegations)
10346                    }
10347                    delegations
10348                },
10349                {
10350                    fn transferOwnership(
10351                        data: &[u8],
10352                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10353                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
10354                                data,
10355                            )
10356                            .map(StakeTableCalls::transferOwnership)
10357                    }
10358                    transferOwnership
10359                },
10360                {
10361                    fn validators(
10362                        data: &[u8],
10363                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10364                        <validatorsCall as alloy_sol_types::SolCall>::abi_decode_raw(
10365                                data,
10366                            )
10367                            .map(StakeTableCalls::validators)
10368                    }
10369                    validators
10370                },
10371                {
10372                    fn token(data: &[u8]) -> alloy_sol_types::Result<StakeTableCalls> {
10373                        <tokenCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
10374                            .map(StakeTableCalls::token)
10375                    }
10376                    token
10377                },
10378            ];
10379            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
10380                return Err(
10381                    alloy_sol_types::Error::unknown_selector(
10382                        <Self as alloy_sol_types::SolInterface>::NAME,
10383                        selector,
10384                    ),
10385                );
10386            };
10387            DECODE_SHIMS[idx](data)
10388        }
10389        #[inline]
10390        #[allow(non_snake_case)]
10391        fn abi_decode_raw_validate(
10392            selector: [u8; 4],
10393            data: &[u8],
10394        ) -> alloy_sol_types::Result<Self> {
10395            static DECODE_VALIDATE_SHIMS: &[fn(
10396                &[u8],
10397            ) -> alloy_sol_types::Result<StakeTableCalls>] = &[
10398                {
10399                    fn delegate(
10400                        data: &[u8],
10401                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10402                        <delegateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10403                                data,
10404                            )
10405                            .map(StakeTableCalls::delegate)
10406                    }
10407                    delegate
10408                },
10409                {
10410                    fn getVersion(
10411                        data: &[u8],
10412                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10413                        <getVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10414                                data,
10415                            )
10416                            .map(StakeTableCalls::getVersion)
10417                    }
10418                    getVersion
10419                },
10420                {
10421                    fn registerValidator(
10422                        data: &[u8],
10423                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10424                        <registerValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10425                                data,
10426                            )
10427                            .map(StakeTableCalls::registerValidator)
10428                    }
10429                    registerValidator
10430                },
10431                {
10432                    fn claimValidatorExit(
10433                        data: &[u8],
10434                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10435                        <claimValidatorExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10436                                data,
10437                            )
10438                            .map(StakeTableCalls::claimValidatorExit)
10439                    }
10440                    claimValidatorExit
10441                },
10442                {
10443                    fn initializedAtBlock(
10444                        data: &[u8],
10445                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10446                        <initializedAtBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10447                                data,
10448                            )
10449                            .map(StakeTableCalls::initializedAtBlock)
10450                    }
10451                    initializedAtBlock
10452                },
10453                {
10454                    fn undelegate(
10455                        data: &[u8],
10456                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10457                        <undelegateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10458                                data,
10459                            )
10460                            .map(StakeTableCalls::undelegate)
10461                    }
10462                    undelegate
10463                },
10464                {
10465                    fn upgradeToAndCall(
10466                        data: &[u8],
10467                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10468                        <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10469                                data,
10470                            )
10471                            .map(StakeTableCalls::upgradeToAndCall)
10472                    }
10473                    upgradeToAndCall
10474                },
10475                {
10476                    fn proxiableUUID(
10477                        data: &[u8],
10478                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10479                        <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10480                                data,
10481                            )
10482                            .map(StakeTableCalls::proxiableUUID)
10483                    }
10484                    proxiableUUID
10485                },
10486                {
10487                    fn updateConsensusKeys(
10488                        data: &[u8],
10489                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10490                        <updateConsensusKeysCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10491                                data,
10492                            )
10493                            .map(StakeTableCalls::updateConsensusKeys)
10494                    }
10495                    updateConsensusKeys
10496                },
10497                {
10498                    fn deregisterValidator(
10499                        data: &[u8],
10500                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10501                        <deregisterValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10502                                data,
10503                            )
10504                            .map(StakeTableCalls::deregisterValidator)
10505                    }
10506                    deregisterValidator
10507                },
10508                {
10509                    fn renounceOwnership(
10510                        data: &[u8],
10511                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10512                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10513                                data,
10514                            )
10515                            .map(StakeTableCalls::renounceOwnership)
10516                    }
10517                    renounceOwnership
10518                },
10519                {
10520                    fn owner(data: &[u8]) -> alloy_sol_types::Result<StakeTableCalls> {
10521                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10522                                data,
10523                            )
10524                            .map(StakeTableCalls::owner)
10525                    }
10526                    owner
10527                },
10528                {
10529                    fn _hashBlsKey(
10530                        data: &[u8],
10531                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10532                        <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10533                                data,
10534                            )
10535                            .map(StakeTableCalls::_hashBlsKey)
10536                    }
10537                    _hashBlsKey
10538                },
10539                {
10540                    fn exitEscrowPeriod(
10541                        data: &[u8],
10542                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10543                        <exitEscrowPeriodCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10544                                data,
10545                            )
10546                            .map(StakeTableCalls::exitEscrowPeriod)
10547                    }
10548                    exitEscrowPeriod
10549                },
10550                {
10551                    fn undelegations(
10552                        data: &[u8],
10553                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10554                        <undelegationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10555                                data,
10556                            )
10557                            .map(StakeTableCalls::undelegations)
10558                    }
10559                    undelegations
10560                },
10561                {
10562                    fn claimWithdrawal(
10563                        data: &[u8],
10564                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10565                        <claimWithdrawalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10566                                data,
10567                            )
10568                            .map(StakeTableCalls::claimWithdrawal)
10569                    }
10570                    claimWithdrawal
10571                },
10572                {
10573                    fn UPGRADE_INTERFACE_VERSION(
10574                        data: &[u8],
10575                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10576                        <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10577                                data,
10578                            )
10579                            .map(StakeTableCalls::UPGRADE_INTERFACE_VERSION)
10580                    }
10581                    UPGRADE_INTERFACE_VERSION
10582                },
10583                {
10584                    fn blsKeys(data: &[u8]) -> alloy_sol_types::Result<StakeTableCalls> {
10585                        <blsKeysCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10586                                data,
10587                            )
10588                            .map(StakeTableCalls::blsKeys)
10589                    }
10590                    blsKeys
10591                },
10592                {
10593                    fn lightClient(
10594                        data: &[u8],
10595                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10596                        <lightClientCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10597                                data,
10598                            )
10599                            .map(StakeTableCalls::lightClient)
10600                    }
10601                    lightClient
10602                },
10603                {
10604                    fn validatorExits(
10605                        data: &[u8],
10606                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10607                        <validatorExitsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10608                                data,
10609                            )
10610                            .map(StakeTableCalls::validatorExits)
10611                    }
10612                    validatorExits
10613                },
10614                {
10615                    fn initialize(
10616                        data: &[u8],
10617                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10618                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10619                                data,
10620                            )
10621                            .map(StakeTableCalls::initialize)
10622                    }
10623                    initialize
10624                },
10625                {
10626                    fn delegations(
10627                        data: &[u8],
10628                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10629                        <delegationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10630                                data,
10631                            )
10632                            .map(StakeTableCalls::delegations)
10633                    }
10634                    delegations
10635                },
10636                {
10637                    fn transferOwnership(
10638                        data: &[u8],
10639                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10640                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10641                                data,
10642                            )
10643                            .map(StakeTableCalls::transferOwnership)
10644                    }
10645                    transferOwnership
10646                },
10647                {
10648                    fn validators(
10649                        data: &[u8],
10650                    ) -> alloy_sol_types::Result<StakeTableCalls> {
10651                        <validatorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10652                                data,
10653                            )
10654                            .map(StakeTableCalls::validators)
10655                    }
10656                    validators
10657                },
10658                {
10659                    fn token(data: &[u8]) -> alloy_sol_types::Result<StakeTableCalls> {
10660                        <tokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
10661                                data,
10662                            )
10663                            .map(StakeTableCalls::token)
10664                    }
10665                    token
10666                },
10667            ];
10668            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
10669                return Err(
10670                    alloy_sol_types::Error::unknown_selector(
10671                        <Self as alloy_sol_types::SolInterface>::NAME,
10672                        selector,
10673                    ),
10674                );
10675            };
10676            DECODE_VALIDATE_SHIMS[idx](data)
10677        }
10678        #[inline]
10679        fn abi_encoded_size(&self) -> usize {
10680            match self {
10681                Self::UPGRADE_INTERFACE_VERSION(inner) => {
10682                    <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
10683                        inner,
10684                    )
10685                }
10686                Self::_hashBlsKey(inner) => {
10687                    <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_encoded_size(
10688                        inner,
10689                    )
10690                }
10691                Self::blsKeys(inner) => {
10692                    <blsKeysCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
10693                }
10694                Self::claimValidatorExit(inner) => {
10695                    <claimValidatorExitCall as alloy_sol_types::SolCall>::abi_encoded_size(
10696                        inner,
10697                    )
10698                }
10699                Self::claimWithdrawal(inner) => {
10700                    <claimWithdrawalCall as alloy_sol_types::SolCall>::abi_encoded_size(
10701                        inner,
10702                    )
10703                }
10704                Self::delegate(inner) => {
10705                    <delegateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
10706                }
10707                Self::delegations(inner) => {
10708                    <delegationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
10709                        inner,
10710                    )
10711                }
10712                Self::deregisterValidator(inner) => {
10713                    <deregisterValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
10714                        inner,
10715                    )
10716                }
10717                Self::exitEscrowPeriod(inner) => {
10718                    <exitEscrowPeriodCall as alloy_sol_types::SolCall>::abi_encoded_size(
10719                        inner,
10720                    )
10721                }
10722                Self::getVersion(inner) => {
10723                    <getVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
10724                }
10725                Self::initialize(inner) => {
10726                    <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
10727                }
10728                Self::initializedAtBlock(inner) => {
10729                    <initializedAtBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
10730                        inner,
10731                    )
10732                }
10733                Self::lightClient(inner) => {
10734                    <lightClientCall as alloy_sol_types::SolCall>::abi_encoded_size(
10735                        inner,
10736                    )
10737                }
10738                Self::owner(inner) => {
10739                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
10740                }
10741                Self::proxiableUUID(inner) => {
10742                    <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encoded_size(
10743                        inner,
10744                    )
10745                }
10746                Self::registerValidator(inner) => {
10747                    <registerValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
10748                        inner,
10749                    )
10750                }
10751                Self::renounceOwnership(inner) => {
10752                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
10753                        inner,
10754                    )
10755                }
10756                Self::token(inner) => {
10757                    <tokenCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
10758                }
10759                Self::transferOwnership(inner) => {
10760                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
10761                        inner,
10762                    )
10763                }
10764                Self::undelegate(inner) => {
10765                    <undelegateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
10766                }
10767                Self::undelegations(inner) => {
10768                    <undelegationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
10769                        inner,
10770                    )
10771                }
10772                Self::updateConsensusKeys(inner) => {
10773                    <updateConsensusKeysCall as alloy_sol_types::SolCall>::abi_encoded_size(
10774                        inner,
10775                    )
10776                }
10777                Self::upgradeToAndCall(inner) => {
10778                    <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(
10779                        inner,
10780                    )
10781                }
10782                Self::validatorExits(inner) => {
10783                    <validatorExitsCall as alloy_sol_types::SolCall>::abi_encoded_size(
10784                        inner,
10785                    )
10786                }
10787                Self::validators(inner) => {
10788                    <validatorsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
10789                }
10790            }
10791        }
10792        #[inline]
10793        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
10794            match self {
10795                Self::UPGRADE_INTERFACE_VERSION(inner) => {
10796                    <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
10797                        inner,
10798                        out,
10799                    )
10800                }
10801                Self::_hashBlsKey(inner) => {
10802                    <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_encode_raw(
10803                        inner,
10804                        out,
10805                    )
10806                }
10807                Self::blsKeys(inner) => {
10808                    <blsKeysCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
10809                }
10810                Self::claimValidatorExit(inner) => {
10811                    <claimValidatorExitCall as alloy_sol_types::SolCall>::abi_encode_raw(
10812                        inner,
10813                        out,
10814                    )
10815                }
10816                Self::claimWithdrawal(inner) => {
10817                    <claimWithdrawalCall as alloy_sol_types::SolCall>::abi_encode_raw(
10818                        inner,
10819                        out,
10820                    )
10821                }
10822                Self::delegate(inner) => {
10823                    <delegateCall as alloy_sol_types::SolCall>::abi_encode_raw(
10824                        inner,
10825                        out,
10826                    )
10827                }
10828                Self::delegations(inner) => {
10829                    <delegationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
10830                        inner,
10831                        out,
10832                    )
10833                }
10834                Self::deregisterValidator(inner) => {
10835                    <deregisterValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
10836                        inner,
10837                        out,
10838                    )
10839                }
10840                Self::exitEscrowPeriod(inner) => {
10841                    <exitEscrowPeriodCall as alloy_sol_types::SolCall>::abi_encode_raw(
10842                        inner,
10843                        out,
10844                    )
10845                }
10846                Self::getVersion(inner) => {
10847                    <getVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
10848                        inner,
10849                        out,
10850                    )
10851                }
10852                Self::initialize(inner) => {
10853                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
10854                        inner,
10855                        out,
10856                    )
10857                }
10858                Self::initializedAtBlock(inner) => {
10859                    <initializedAtBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
10860                        inner,
10861                        out,
10862                    )
10863                }
10864                Self::lightClient(inner) => {
10865                    <lightClientCall as alloy_sol_types::SolCall>::abi_encode_raw(
10866                        inner,
10867                        out,
10868                    )
10869                }
10870                Self::owner(inner) => {
10871                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
10872                }
10873                Self::proxiableUUID(inner) => {
10874                    <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encode_raw(
10875                        inner,
10876                        out,
10877                    )
10878                }
10879                Self::registerValidator(inner) => {
10880                    <registerValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
10881                        inner,
10882                        out,
10883                    )
10884                }
10885                Self::renounceOwnership(inner) => {
10886                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
10887                        inner,
10888                        out,
10889                    )
10890                }
10891                Self::token(inner) => {
10892                    <tokenCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
10893                }
10894                Self::transferOwnership(inner) => {
10895                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
10896                        inner,
10897                        out,
10898                    )
10899                }
10900                Self::undelegate(inner) => {
10901                    <undelegateCall as alloy_sol_types::SolCall>::abi_encode_raw(
10902                        inner,
10903                        out,
10904                    )
10905                }
10906                Self::undelegations(inner) => {
10907                    <undelegationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
10908                        inner,
10909                        out,
10910                    )
10911                }
10912                Self::updateConsensusKeys(inner) => {
10913                    <updateConsensusKeysCall as alloy_sol_types::SolCall>::abi_encode_raw(
10914                        inner,
10915                        out,
10916                    )
10917                }
10918                Self::upgradeToAndCall(inner) => {
10919                    <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(
10920                        inner,
10921                        out,
10922                    )
10923                }
10924                Self::validatorExits(inner) => {
10925                    <validatorExitsCall as alloy_sol_types::SolCall>::abi_encode_raw(
10926                        inner,
10927                        out,
10928                    )
10929                }
10930                Self::validators(inner) => {
10931                    <validatorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
10932                        inner,
10933                        out,
10934                    )
10935                }
10936            }
10937        }
10938    }
10939    ///Container for all the [`StakeTable`](self) custom errors.
10940    #[derive(Clone)]
10941    #[derive(serde::Serialize, serde::Deserialize)]
10942    #[derive(Debug, PartialEq, Eq, Hash)]
10943    pub enum StakeTableErrors {
10944        #[allow(missing_docs)]
10945        AddressEmptyCode(AddressEmptyCode),
10946        #[allow(missing_docs)]
10947        BLSSigIsInfinity(BLSSigIsInfinity),
10948        #[allow(missing_docs)]
10949        BLSSigVerificationFailed(BLSSigVerificationFailed),
10950        #[allow(missing_docs)]
10951        BLSVKIsInfinity(BLSVKIsInfinity),
10952        #[allow(missing_docs)]
10953        BN254PairingProdFailed(BN254PairingProdFailed),
10954        #[allow(missing_docs)]
10955        BlsKeyAlreadyUsed(BlsKeyAlreadyUsed),
10956        #[allow(missing_docs)]
10957        ERC1967InvalidImplementation(ERC1967InvalidImplementation),
10958        #[allow(missing_docs)]
10959        ERC1967NonPayable(ERC1967NonPayable),
10960        #[allow(missing_docs)]
10961        ExitEscrowPeriodInvalid(ExitEscrowPeriodInvalid),
10962        #[allow(missing_docs)]
10963        FailedInnerCall(FailedInnerCall),
10964        #[allow(missing_docs)]
10965        InsufficientAllowance(InsufficientAllowance),
10966        #[allow(missing_docs)]
10967        InsufficientBalance(InsufficientBalance),
10968        #[allow(missing_docs)]
10969        InvalidCommission(InvalidCommission),
10970        #[allow(missing_docs)]
10971        InvalidG1(InvalidG1),
10972        #[allow(missing_docs)]
10973        InvalidInitialization(InvalidInitialization),
10974        #[allow(missing_docs)]
10975        InvalidSchnorrVK(InvalidSchnorrVK),
10976        #[allow(missing_docs)]
10977        NotInitializing(NotInitializing),
10978        #[allow(missing_docs)]
10979        NothingToWithdraw(NothingToWithdraw),
10980        #[allow(missing_docs)]
10981        OwnableInvalidOwner(OwnableInvalidOwner),
10982        #[allow(missing_docs)]
10983        OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
10984        #[allow(missing_docs)]
10985        OwnershipCannotBeRenounced(OwnershipCannotBeRenounced),
10986        #[allow(missing_docs)]
10987        PowPrecompileFailed(PowPrecompileFailed),
10988        #[allow(missing_docs)]
10989        PrematureWithdrawal(PrematureWithdrawal),
10990        #[allow(missing_docs)]
10991        UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext),
10992        #[allow(missing_docs)]
10993        UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID),
10994        #[allow(missing_docs)]
10995        UndelegationAlreadyExists(UndelegationAlreadyExists),
10996        #[allow(missing_docs)]
10997        ValidatorAlreadyExited(ValidatorAlreadyExited),
10998        #[allow(missing_docs)]
10999        ValidatorAlreadyRegistered(ValidatorAlreadyRegistered),
11000        #[allow(missing_docs)]
11001        ValidatorInactive(ValidatorInactive),
11002        #[allow(missing_docs)]
11003        ValidatorNotExited(ValidatorNotExited),
11004        #[allow(missing_docs)]
11005        ZeroAddress(ZeroAddress),
11006        #[allow(missing_docs)]
11007        ZeroAmount(ZeroAmount),
11008    }
11009    impl StakeTableErrors {
11010        /// All the selectors of this enum.
11011        ///
11012        /// Note that the selectors might not be in the same order as the variants.
11013        /// No guarantees are made about the order of the selectors.
11014        ///
11015        /// Prefer using `SolInterface` methods instead.
11016        pub const SELECTORS: &'static [[u8; 4usize]] = &[
11017            [1u8, 181u8, 20u8, 174u8],
11018            [6u8, 207u8, 67u8, 143u8],
11019            [12u8, 237u8, 62u8, 80u8],
11020            [17u8, 140u8, 218u8, 167u8],
11021            [20u8, 37u8, 234u8, 66u8],
11022            [30u8, 79u8, 189u8, 247u8],
11023            [31u8, 42u8, 32u8, 5u8],
11024            [42u8, 27u8, 45u8, 216u8],
11025            [47u8, 171u8, 146u8, 202u8],
11026            [50u8, 116u8, 250u8, 100u8],
11027            [76u8, 156u8, 140u8, 227u8],
11028            [80u8, 138u8, 121u8, 63u8],
11029            [90u8, 119u8, 67u8, 87u8],
11030            [116u8, 39u8, 35u8, 50u8],
11031            [146u8, 102u8, 83u8, 81u8],
11032            [153u8, 115u8, 247u8, 216u8],
11033            [153u8, 150u8, 179u8, 21u8],
11034            [158u8, 120u8, 209u8, 76u8],
11035            [170u8, 29u8, 73u8, 164u8],
11036            [179u8, 152u8, 151u8, 159u8],
11037            [181u8, 126u8, 33u8, 223u8],
11038            [188u8, 134u8, 197u8, 154u8],
11039            [194u8, 6u8, 51u8, 79u8],
11040            [208u8, 208u8, 79u8, 96u8],
11041            [212u8, 35u8, 164u8, 241u8],
11042            [215u8, 230u8, 188u8, 248u8],
11043            [217u8, 46u8, 35u8, 61u8],
11044            [220u8, 129u8, 219u8, 133u8],
11045            [224u8, 124u8, 141u8, 186u8],
11046            [234u8, 180u8, 169u8, 99u8],
11047            [242u8, 83u8, 20u8, 166u8],
11048            [249u8, 46u8, 232u8, 169u8],
11049        ];
11050        /// The names of the variants in the same order as `SELECTORS`.
11051        pub const VARIANT_NAMES: &'static [&'static str] = &[
11052            ::core::stringify!(BlsKeyAlreadyUsed),
11053            ::core::stringify!(InvalidSchnorrVK),
11054            ::core::stringify!(BLSSigVerificationFailed),
11055            ::core::stringify!(OwnableUnauthorizedAccount),
11056            ::core::stringify!(FailedInnerCall),
11057            ::core::stringify!(OwnableInvalidOwner),
11058            ::core::stringify!(ZeroAmount),
11059            ::core::stringify!(InsufficientAllowance),
11060            ::core::stringify!(OwnershipCannotBeRenounced),
11061            ::core::stringify!(PowPrecompileFailed),
11062            ::core::stringify!(ERC1967InvalidImplementation),
11063            ::core::stringify!(ValidatorInactive),
11064            ::core::stringify!(PrematureWithdrawal),
11065            ::core::stringify!(BLSSigIsInfinity),
11066            ::core::stringify!(InsufficientBalance),
11067            ::core::stringify!(ValidatorAlreadyRegistered),
11068            ::core::stringify!(AddressEmptyCode),
11069            ::core::stringify!(InvalidG1),
11070            ::core::stringify!(UUPSUnsupportedProxiableUUID),
11071            ::core::stringify!(ERC1967NonPayable),
11072            ::core::stringify!(ExitEscrowPeriodInvalid),
11073            ::core::stringify!(BLSVKIsInfinity),
11074            ::core::stringify!(BN254PairingProdFailed),
11075            ::core::stringify!(NothingToWithdraw),
11076            ::core::stringify!(UndelegationAlreadyExists),
11077            ::core::stringify!(NotInitializing),
11078            ::core::stringify!(ZeroAddress),
11079            ::core::stringify!(InvalidCommission),
11080            ::core::stringify!(UUPSUnauthorizedCallContext),
11081            ::core::stringify!(ValidatorAlreadyExited),
11082            ::core::stringify!(ValidatorNotExited),
11083            ::core::stringify!(InvalidInitialization),
11084        ];
11085        /// The signatures in the same order as `SELECTORS`.
11086        pub const SIGNATURES: &'static [&'static str] = &[
11087            <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::SIGNATURE,
11088            <InvalidSchnorrVK as alloy_sol_types::SolError>::SIGNATURE,
11089            <BLSSigVerificationFailed as alloy_sol_types::SolError>::SIGNATURE,
11090            <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SIGNATURE,
11091            <FailedInnerCall as alloy_sol_types::SolError>::SIGNATURE,
11092            <OwnableInvalidOwner as alloy_sol_types::SolError>::SIGNATURE,
11093            <ZeroAmount as alloy_sol_types::SolError>::SIGNATURE,
11094            <InsufficientAllowance as alloy_sol_types::SolError>::SIGNATURE,
11095            <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::SIGNATURE,
11096            <PowPrecompileFailed as alloy_sol_types::SolError>::SIGNATURE,
11097            <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SIGNATURE,
11098            <ValidatorInactive as alloy_sol_types::SolError>::SIGNATURE,
11099            <PrematureWithdrawal as alloy_sol_types::SolError>::SIGNATURE,
11100            <BLSSigIsInfinity as alloy_sol_types::SolError>::SIGNATURE,
11101            <InsufficientBalance as alloy_sol_types::SolError>::SIGNATURE,
11102            <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::SIGNATURE,
11103            <AddressEmptyCode as alloy_sol_types::SolError>::SIGNATURE,
11104            <InvalidG1 as alloy_sol_types::SolError>::SIGNATURE,
11105            <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SIGNATURE,
11106            <ERC1967NonPayable as alloy_sol_types::SolError>::SIGNATURE,
11107            <ExitEscrowPeriodInvalid as alloy_sol_types::SolError>::SIGNATURE,
11108            <BLSVKIsInfinity as alloy_sol_types::SolError>::SIGNATURE,
11109            <BN254PairingProdFailed as alloy_sol_types::SolError>::SIGNATURE,
11110            <NothingToWithdraw as alloy_sol_types::SolError>::SIGNATURE,
11111            <UndelegationAlreadyExists as alloy_sol_types::SolError>::SIGNATURE,
11112            <NotInitializing as alloy_sol_types::SolError>::SIGNATURE,
11113            <ZeroAddress as alloy_sol_types::SolError>::SIGNATURE,
11114            <InvalidCommission as alloy_sol_types::SolError>::SIGNATURE,
11115            <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SIGNATURE,
11116            <ValidatorAlreadyExited as alloy_sol_types::SolError>::SIGNATURE,
11117            <ValidatorNotExited as alloy_sol_types::SolError>::SIGNATURE,
11118            <InvalidInitialization as alloy_sol_types::SolError>::SIGNATURE,
11119        ];
11120        /// Returns the signature for the given selector, if known.
11121        #[inline]
11122        pub fn signature_by_selector(
11123            selector: [u8; 4usize],
11124        ) -> ::core::option::Option<&'static str> {
11125            match Self::SELECTORS.binary_search(&selector) {
11126                ::core::result::Result::Ok(idx) => {
11127                    ::core::option::Option::Some(Self::SIGNATURES[idx])
11128                }
11129                ::core::result::Result::Err(_) => ::core::option::Option::None,
11130            }
11131        }
11132        /// Returns the enum variant name for the given selector, if known.
11133        #[inline]
11134        pub fn name_by_selector(
11135            selector: [u8; 4usize],
11136        ) -> ::core::option::Option<&'static str> {
11137            let sig = Self::signature_by_selector(selector)?;
11138            sig.split_once('(').map(|(name, _)| name)
11139        }
11140    }
11141    #[automatically_derived]
11142    impl alloy_sol_types::SolInterface for StakeTableErrors {
11143        const NAME: &'static str = "StakeTableErrors";
11144        const MIN_DATA_LENGTH: usize = 0usize;
11145        const COUNT: usize = 32usize;
11146        #[inline]
11147        fn selector(&self) -> [u8; 4] {
11148            match self {
11149                Self::AddressEmptyCode(_) => {
11150                    <AddressEmptyCode as alloy_sol_types::SolError>::SELECTOR
11151                }
11152                Self::BLSSigIsInfinity(_) => {
11153                    <BLSSigIsInfinity as alloy_sol_types::SolError>::SELECTOR
11154                }
11155                Self::BLSSigVerificationFailed(_) => {
11156                    <BLSSigVerificationFailed as alloy_sol_types::SolError>::SELECTOR
11157                }
11158                Self::BLSVKIsInfinity(_) => {
11159                    <BLSVKIsInfinity as alloy_sol_types::SolError>::SELECTOR
11160                }
11161                Self::BN254PairingProdFailed(_) => {
11162                    <BN254PairingProdFailed as alloy_sol_types::SolError>::SELECTOR
11163                }
11164                Self::BlsKeyAlreadyUsed(_) => {
11165                    <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::SELECTOR
11166                }
11167                Self::ERC1967InvalidImplementation(_) => {
11168                    <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SELECTOR
11169                }
11170                Self::ERC1967NonPayable(_) => {
11171                    <ERC1967NonPayable as alloy_sol_types::SolError>::SELECTOR
11172                }
11173                Self::ExitEscrowPeriodInvalid(_) => {
11174                    <ExitEscrowPeriodInvalid as alloy_sol_types::SolError>::SELECTOR
11175                }
11176                Self::FailedInnerCall(_) => {
11177                    <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
11178                }
11179                Self::InsufficientAllowance(_) => {
11180                    <InsufficientAllowance as alloy_sol_types::SolError>::SELECTOR
11181                }
11182                Self::InsufficientBalance(_) => {
11183                    <InsufficientBalance as alloy_sol_types::SolError>::SELECTOR
11184                }
11185                Self::InvalidCommission(_) => {
11186                    <InvalidCommission as alloy_sol_types::SolError>::SELECTOR
11187                }
11188                Self::InvalidG1(_) => <InvalidG1 as alloy_sol_types::SolError>::SELECTOR,
11189                Self::InvalidInitialization(_) => {
11190                    <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
11191                }
11192                Self::InvalidSchnorrVK(_) => {
11193                    <InvalidSchnorrVK as alloy_sol_types::SolError>::SELECTOR
11194                }
11195                Self::NotInitializing(_) => {
11196                    <NotInitializing as alloy_sol_types::SolError>::SELECTOR
11197                }
11198                Self::NothingToWithdraw(_) => {
11199                    <NothingToWithdraw as alloy_sol_types::SolError>::SELECTOR
11200                }
11201                Self::OwnableInvalidOwner(_) => {
11202                    <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
11203                }
11204                Self::OwnableUnauthorizedAccount(_) => {
11205                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
11206                }
11207                Self::OwnershipCannotBeRenounced(_) => {
11208                    <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::SELECTOR
11209                }
11210                Self::PowPrecompileFailed(_) => {
11211                    <PowPrecompileFailed as alloy_sol_types::SolError>::SELECTOR
11212                }
11213                Self::PrematureWithdrawal(_) => {
11214                    <PrematureWithdrawal as alloy_sol_types::SolError>::SELECTOR
11215                }
11216                Self::UUPSUnauthorizedCallContext(_) => {
11217                    <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SELECTOR
11218                }
11219                Self::UUPSUnsupportedProxiableUUID(_) => {
11220                    <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SELECTOR
11221                }
11222                Self::UndelegationAlreadyExists(_) => {
11223                    <UndelegationAlreadyExists as alloy_sol_types::SolError>::SELECTOR
11224                }
11225                Self::ValidatorAlreadyExited(_) => {
11226                    <ValidatorAlreadyExited as alloy_sol_types::SolError>::SELECTOR
11227                }
11228                Self::ValidatorAlreadyRegistered(_) => {
11229                    <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::SELECTOR
11230                }
11231                Self::ValidatorInactive(_) => {
11232                    <ValidatorInactive as alloy_sol_types::SolError>::SELECTOR
11233                }
11234                Self::ValidatorNotExited(_) => {
11235                    <ValidatorNotExited as alloy_sol_types::SolError>::SELECTOR
11236                }
11237                Self::ZeroAddress(_) => {
11238                    <ZeroAddress as alloy_sol_types::SolError>::SELECTOR
11239                }
11240                Self::ZeroAmount(_) => {
11241                    <ZeroAmount as alloy_sol_types::SolError>::SELECTOR
11242                }
11243            }
11244        }
11245        #[inline]
11246        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
11247            Self::SELECTORS.get(i).copied()
11248        }
11249        #[inline]
11250        fn valid_selector(selector: [u8; 4]) -> bool {
11251            Self::SELECTORS.binary_search(&selector).is_ok()
11252        }
11253        #[inline]
11254        #[allow(non_snake_case)]
11255        fn abi_decode_raw(
11256            selector: [u8; 4],
11257            data: &[u8],
11258        ) -> alloy_sol_types::Result<Self> {
11259            static DECODE_SHIMS: &[fn(
11260                &[u8],
11261            ) -> alloy_sol_types::Result<StakeTableErrors>] = &[
11262                {
11263                    fn BlsKeyAlreadyUsed(
11264                        data: &[u8],
11265                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11266                        <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::abi_decode_raw(
11267                                data,
11268                            )
11269                            .map(StakeTableErrors::BlsKeyAlreadyUsed)
11270                    }
11271                    BlsKeyAlreadyUsed
11272                },
11273                {
11274                    fn InvalidSchnorrVK(
11275                        data: &[u8],
11276                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11277                        <InvalidSchnorrVK as alloy_sol_types::SolError>::abi_decode_raw(
11278                                data,
11279                            )
11280                            .map(StakeTableErrors::InvalidSchnorrVK)
11281                    }
11282                    InvalidSchnorrVK
11283                },
11284                {
11285                    fn BLSSigVerificationFailed(
11286                        data: &[u8],
11287                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11288                        <BLSSigVerificationFailed as alloy_sol_types::SolError>::abi_decode_raw(
11289                                data,
11290                            )
11291                            .map(StakeTableErrors::BLSSigVerificationFailed)
11292                    }
11293                    BLSSigVerificationFailed
11294                },
11295                {
11296                    fn OwnableUnauthorizedAccount(
11297                        data: &[u8],
11298                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11299                        <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
11300                                data,
11301                            )
11302                            .map(StakeTableErrors::OwnableUnauthorizedAccount)
11303                    }
11304                    OwnableUnauthorizedAccount
11305                },
11306                {
11307                    fn FailedInnerCall(
11308                        data: &[u8],
11309                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11310                        <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(
11311                                data,
11312                            )
11313                            .map(StakeTableErrors::FailedInnerCall)
11314                    }
11315                    FailedInnerCall
11316                },
11317                {
11318                    fn OwnableInvalidOwner(
11319                        data: &[u8],
11320                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11321                        <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
11322                                data,
11323                            )
11324                            .map(StakeTableErrors::OwnableInvalidOwner)
11325                    }
11326                    OwnableInvalidOwner
11327                },
11328                {
11329                    fn ZeroAmount(
11330                        data: &[u8],
11331                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11332                        <ZeroAmount as alloy_sol_types::SolError>::abi_decode_raw(data)
11333                            .map(StakeTableErrors::ZeroAmount)
11334                    }
11335                    ZeroAmount
11336                },
11337                {
11338                    fn InsufficientAllowance(
11339                        data: &[u8],
11340                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11341                        <InsufficientAllowance as alloy_sol_types::SolError>::abi_decode_raw(
11342                                data,
11343                            )
11344                            .map(StakeTableErrors::InsufficientAllowance)
11345                    }
11346                    InsufficientAllowance
11347                },
11348                {
11349                    fn OwnershipCannotBeRenounced(
11350                        data: &[u8],
11351                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11352                        <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_decode_raw(
11353                                data,
11354                            )
11355                            .map(StakeTableErrors::OwnershipCannotBeRenounced)
11356                    }
11357                    OwnershipCannotBeRenounced
11358                },
11359                {
11360                    fn PowPrecompileFailed(
11361                        data: &[u8],
11362                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11363                        <PowPrecompileFailed as alloy_sol_types::SolError>::abi_decode_raw(
11364                                data,
11365                            )
11366                            .map(StakeTableErrors::PowPrecompileFailed)
11367                    }
11368                    PowPrecompileFailed
11369                },
11370                {
11371                    fn ERC1967InvalidImplementation(
11372                        data: &[u8],
11373                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11374                        <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_decode_raw(
11375                                data,
11376                            )
11377                            .map(StakeTableErrors::ERC1967InvalidImplementation)
11378                    }
11379                    ERC1967InvalidImplementation
11380                },
11381                {
11382                    fn ValidatorInactive(
11383                        data: &[u8],
11384                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11385                        <ValidatorInactive as alloy_sol_types::SolError>::abi_decode_raw(
11386                                data,
11387                            )
11388                            .map(StakeTableErrors::ValidatorInactive)
11389                    }
11390                    ValidatorInactive
11391                },
11392                {
11393                    fn PrematureWithdrawal(
11394                        data: &[u8],
11395                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11396                        <PrematureWithdrawal as alloy_sol_types::SolError>::abi_decode_raw(
11397                                data,
11398                            )
11399                            .map(StakeTableErrors::PrematureWithdrawal)
11400                    }
11401                    PrematureWithdrawal
11402                },
11403                {
11404                    fn BLSSigIsInfinity(
11405                        data: &[u8],
11406                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11407                        <BLSSigIsInfinity as alloy_sol_types::SolError>::abi_decode_raw(
11408                                data,
11409                            )
11410                            .map(StakeTableErrors::BLSSigIsInfinity)
11411                    }
11412                    BLSSigIsInfinity
11413                },
11414                {
11415                    fn InsufficientBalance(
11416                        data: &[u8],
11417                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11418                        <InsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw(
11419                                data,
11420                            )
11421                            .map(StakeTableErrors::InsufficientBalance)
11422                    }
11423                    InsufficientBalance
11424                },
11425                {
11426                    fn ValidatorAlreadyRegistered(
11427                        data: &[u8],
11428                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11429                        <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::abi_decode_raw(
11430                                data,
11431                            )
11432                            .map(StakeTableErrors::ValidatorAlreadyRegistered)
11433                    }
11434                    ValidatorAlreadyRegistered
11435                },
11436                {
11437                    fn AddressEmptyCode(
11438                        data: &[u8],
11439                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11440                        <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw(
11441                                data,
11442                            )
11443                            .map(StakeTableErrors::AddressEmptyCode)
11444                    }
11445                    AddressEmptyCode
11446                },
11447                {
11448                    fn InvalidG1(
11449                        data: &[u8],
11450                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11451                        <InvalidG1 as alloy_sol_types::SolError>::abi_decode_raw(data)
11452                            .map(StakeTableErrors::InvalidG1)
11453                    }
11454                    InvalidG1
11455                },
11456                {
11457                    fn UUPSUnsupportedProxiableUUID(
11458                        data: &[u8],
11459                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11460                        <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_decode_raw(
11461                                data,
11462                            )
11463                            .map(StakeTableErrors::UUPSUnsupportedProxiableUUID)
11464                    }
11465                    UUPSUnsupportedProxiableUUID
11466                },
11467                {
11468                    fn ERC1967NonPayable(
11469                        data: &[u8],
11470                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11471                        <ERC1967NonPayable as alloy_sol_types::SolError>::abi_decode_raw(
11472                                data,
11473                            )
11474                            .map(StakeTableErrors::ERC1967NonPayable)
11475                    }
11476                    ERC1967NonPayable
11477                },
11478                {
11479                    fn ExitEscrowPeriodInvalid(
11480                        data: &[u8],
11481                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11482                        <ExitEscrowPeriodInvalid as alloy_sol_types::SolError>::abi_decode_raw(
11483                                data,
11484                            )
11485                            .map(StakeTableErrors::ExitEscrowPeriodInvalid)
11486                    }
11487                    ExitEscrowPeriodInvalid
11488                },
11489                {
11490                    fn BLSVKIsInfinity(
11491                        data: &[u8],
11492                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11493                        <BLSVKIsInfinity as alloy_sol_types::SolError>::abi_decode_raw(
11494                                data,
11495                            )
11496                            .map(StakeTableErrors::BLSVKIsInfinity)
11497                    }
11498                    BLSVKIsInfinity
11499                },
11500                {
11501                    fn BN254PairingProdFailed(
11502                        data: &[u8],
11503                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11504                        <BN254PairingProdFailed as alloy_sol_types::SolError>::abi_decode_raw(
11505                                data,
11506                            )
11507                            .map(StakeTableErrors::BN254PairingProdFailed)
11508                    }
11509                    BN254PairingProdFailed
11510                },
11511                {
11512                    fn NothingToWithdraw(
11513                        data: &[u8],
11514                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11515                        <NothingToWithdraw as alloy_sol_types::SolError>::abi_decode_raw(
11516                                data,
11517                            )
11518                            .map(StakeTableErrors::NothingToWithdraw)
11519                    }
11520                    NothingToWithdraw
11521                },
11522                {
11523                    fn UndelegationAlreadyExists(
11524                        data: &[u8],
11525                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11526                        <UndelegationAlreadyExists as alloy_sol_types::SolError>::abi_decode_raw(
11527                                data,
11528                            )
11529                            .map(StakeTableErrors::UndelegationAlreadyExists)
11530                    }
11531                    UndelegationAlreadyExists
11532                },
11533                {
11534                    fn NotInitializing(
11535                        data: &[u8],
11536                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11537                        <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw(
11538                                data,
11539                            )
11540                            .map(StakeTableErrors::NotInitializing)
11541                    }
11542                    NotInitializing
11543                },
11544                {
11545                    fn ZeroAddress(
11546                        data: &[u8],
11547                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11548                        <ZeroAddress as alloy_sol_types::SolError>::abi_decode_raw(data)
11549                            .map(StakeTableErrors::ZeroAddress)
11550                    }
11551                    ZeroAddress
11552                },
11553                {
11554                    fn InvalidCommission(
11555                        data: &[u8],
11556                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11557                        <InvalidCommission as alloy_sol_types::SolError>::abi_decode_raw(
11558                                data,
11559                            )
11560                            .map(StakeTableErrors::InvalidCommission)
11561                    }
11562                    InvalidCommission
11563                },
11564                {
11565                    fn UUPSUnauthorizedCallContext(
11566                        data: &[u8],
11567                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11568                        <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_decode_raw(
11569                                data,
11570                            )
11571                            .map(StakeTableErrors::UUPSUnauthorizedCallContext)
11572                    }
11573                    UUPSUnauthorizedCallContext
11574                },
11575                {
11576                    fn ValidatorAlreadyExited(
11577                        data: &[u8],
11578                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11579                        <ValidatorAlreadyExited as alloy_sol_types::SolError>::abi_decode_raw(
11580                                data,
11581                            )
11582                            .map(StakeTableErrors::ValidatorAlreadyExited)
11583                    }
11584                    ValidatorAlreadyExited
11585                },
11586                {
11587                    fn ValidatorNotExited(
11588                        data: &[u8],
11589                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11590                        <ValidatorNotExited as alloy_sol_types::SolError>::abi_decode_raw(
11591                                data,
11592                            )
11593                            .map(StakeTableErrors::ValidatorNotExited)
11594                    }
11595                    ValidatorNotExited
11596                },
11597                {
11598                    fn InvalidInitialization(
11599                        data: &[u8],
11600                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11601                        <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw(
11602                                data,
11603                            )
11604                            .map(StakeTableErrors::InvalidInitialization)
11605                    }
11606                    InvalidInitialization
11607                },
11608            ];
11609            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
11610                return Err(
11611                    alloy_sol_types::Error::unknown_selector(
11612                        <Self as alloy_sol_types::SolInterface>::NAME,
11613                        selector,
11614                    ),
11615                );
11616            };
11617            DECODE_SHIMS[idx](data)
11618        }
11619        #[inline]
11620        #[allow(non_snake_case)]
11621        fn abi_decode_raw_validate(
11622            selector: [u8; 4],
11623            data: &[u8],
11624        ) -> alloy_sol_types::Result<Self> {
11625            static DECODE_VALIDATE_SHIMS: &[fn(
11626                &[u8],
11627            ) -> alloy_sol_types::Result<StakeTableErrors>] = &[
11628                {
11629                    fn BlsKeyAlreadyUsed(
11630                        data: &[u8],
11631                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11632                        <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::abi_decode_raw_validate(
11633                                data,
11634                            )
11635                            .map(StakeTableErrors::BlsKeyAlreadyUsed)
11636                    }
11637                    BlsKeyAlreadyUsed
11638                },
11639                {
11640                    fn InvalidSchnorrVK(
11641                        data: &[u8],
11642                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11643                        <InvalidSchnorrVK as alloy_sol_types::SolError>::abi_decode_raw_validate(
11644                                data,
11645                            )
11646                            .map(StakeTableErrors::InvalidSchnorrVK)
11647                    }
11648                    InvalidSchnorrVK
11649                },
11650                {
11651                    fn BLSSigVerificationFailed(
11652                        data: &[u8],
11653                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11654                        <BLSSigVerificationFailed as alloy_sol_types::SolError>::abi_decode_raw_validate(
11655                                data,
11656                            )
11657                            .map(StakeTableErrors::BLSSigVerificationFailed)
11658                    }
11659                    BLSSigVerificationFailed
11660                },
11661                {
11662                    fn OwnableUnauthorizedAccount(
11663                        data: &[u8],
11664                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11665                        <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw_validate(
11666                                data,
11667                            )
11668                            .map(StakeTableErrors::OwnableUnauthorizedAccount)
11669                    }
11670                    OwnableUnauthorizedAccount
11671                },
11672                {
11673                    fn FailedInnerCall(
11674                        data: &[u8],
11675                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11676                        <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
11677                                data,
11678                            )
11679                            .map(StakeTableErrors::FailedInnerCall)
11680                    }
11681                    FailedInnerCall
11682                },
11683                {
11684                    fn OwnableInvalidOwner(
11685                        data: &[u8],
11686                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11687                        <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw_validate(
11688                                data,
11689                            )
11690                            .map(StakeTableErrors::OwnableInvalidOwner)
11691                    }
11692                    OwnableInvalidOwner
11693                },
11694                {
11695                    fn ZeroAmount(
11696                        data: &[u8],
11697                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11698                        <ZeroAmount as alloy_sol_types::SolError>::abi_decode_raw_validate(
11699                                data,
11700                            )
11701                            .map(StakeTableErrors::ZeroAmount)
11702                    }
11703                    ZeroAmount
11704                },
11705                {
11706                    fn InsufficientAllowance(
11707                        data: &[u8],
11708                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11709                        <InsufficientAllowance as alloy_sol_types::SolError>::abi_decode_raw_validate(
11710                                data,
11711                            )
11712                            .map(StakeTableErrors::InsufficientAllowance)
11713                    }
11714                    InsufficientAllowance
11715                },
11716                {
11717                    fn OwnershipCannotBeRenounced(
11718                        data: &[u8],
11719                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11720                        <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_decode_raw_validate(
11721                                data,
11722                            )
11723                            .map(StakeTableErrors::OwnershipCannotBeRenounced)
11724                    }
11725                    OwnershipCannotBeRenounced
11726                },
11727                {
11728                    fn PowPrecompileFailed(
11729                        data: &[u8],
11730                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11731                        <PowPrecompileFailed as alloy_sol_types::SolError>::abi_decode_raw_validate(
11732                                data,
11733                            )
11734                            .map(StakeTableErrors::PowPrecompileFailed)
11735                    }
11736                    PowPrecompileFailed
11737                },
11738                {
11739                    fn ERC1967InvalidImplementation(
11740                        data: &[u8],
11741                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11742                        <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_decode_raw_validate(
11743                                data,
11744                            )
11745                            .map(StakeTableErrors::ERC1967InvalidImplementation)
11746                    }
11747                    ERC1967InvalidImplementation
11748                },
11749                {
11750                    fn ValidatorInactive(
11751                        data: &[u8],
11752                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11753                        <ValidatorInactive as alloy_sol_types::SolError>::abi_decode_raw_validate(
11754                                data,
11755                            )
11756                            .map(StakeTableErrors::ValidatorInactive)
11757                    }
11758                    ValidatorInactive
11759                },
11760                {
11761                    fn PrematureWithdrawal(
11762                        data: &[u8],
11763                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11764                        <PrematureWithdrawal as alloy_sol_types::SolError>::abi_decode_raw_validate(
11765                                data,
11766                            )
11767                            .map(StakeTableErrors::PrematureWithdrawal)
11768                    }
11769                    PrematureWithdrawal
11770                },
11771                {
11772                    fn BLSSigIsInfinity(
11773                        data: &[u8],
11774                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11775                        <BLSSigIsInfinity as alloy_sol_types::SolError>::abi_decode_raw_validate(
11776                                data,
11777                            )
11778                            .map(StakeTableErrors::BLSSigIsInfinity)
11779                    }
11780                    BLSSigIsInfinity
11781                },
11782                {
11783                    fn InsufficientBalance(
11784                        data: &[u8],
11785                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11786                        <InsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw_validate(
11787                                data,
11788                            )
11789                            .map(StakeTableErrors::InsufficientBalance)
11790                    }
11791                    InsufficientBalance
11792                },
11793                {
11794                    fn ValidatorAlreadyRegistered(
11795                        data: &[u8],
11796                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11797                        <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::abi_decode_raw_validate(
11798                                data,
11799                            )
11800                            .map(StakeTableErrors::ValidatorAlreadyRegistered)
11801                    }
11802                    ValidatorAlreadyRegistered
11803                },
11804                {
11805                    fn AddressEmptyCode(
11806                        data: &[u8],
11807                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11808                        <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw_validate(
11809                                data,
11810                            )
11811                            .map(StakeTableErrors::AddressEmptyCode)
11812                    }
11813                    AddressEmptyCode
11814                },
11815                {
11816                    fn InvalidG1(
11817                        data: &[u8],
11818                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11819                        <InvalidG1 as alloy_sol_types::SolError>::abi_decode_raw_validate(
11820                                data,
11821                            )
11822                            .map(StakeTableErrors::InvalidG1)
11823                    }
11824                    InvalidG1
11825                },
11826                {
11827                    fn UUPSUnsupportedProxiableUUID(
11828                        data: &[u8],
11829                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11830                        <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_decode_raw_validate(
11831                                data,
11832                            )
11833                            .map(StakeTableErrors::UUPSUnsupportedProxiableUUID)
11834                    }
11835                    UUPSUnsupportedProxiableUUID
11836                },
11837                {
11838                    fn ERC1967NonPayable(
11839                        data: &[u8],
11840                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11841                        <ERC1967NonPayable as alloy_sol_types::SolError>::abi_decode_raw_validate(
11842                                data,
11843                            )
11844                            .map(StakeTableErrors::ERC1967NonPayable)
11845                    }
11846                    ERC1967NonPayable
11847                },
11848                {
11849                    fn ExitEscrowPeriodInvalid(
11850                        data: &[u8],
11851                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11852                        <ExitEscrowPeriodInvalid as alloy_sol_types::SolError>::abi_decode_raw_validate(
11853                                data,
11854                            )
11855                            .map(StakeTableErrors::ExitEscrowPeriodInvalid)
11856                    }
11857                    ExitEscrowPeriodInvalid
11858                },
11859                {
11860                    fn BLSVKIsInfinity(
11861                        data: &[u8],
11862                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11863                        <BLSVKIsInfinity as alloy_sol_types::SolError>::abi_decode_raw_validate(
11864                                data,
11865                            )
11866                            .map(StakeTableErrors::BLSVKIsInfinity)
11867                    }
11868                    BLSVKIsInfinity
11869                },
11870                {
11871                    fn BN254PairingProdFailed(
11872                        data: &[u8],
11873                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11874                        <BN254PairingProdFailed as alloy_sol_types::SolError>::abi_decode_raw_validate(
11875                                data,
11876                            )
11877                            .map(StakeTableErrors::BN254PairingProdFailed)
11878                    }
11879                    BN254PairingProdFailed
11880                },
11881                {
11882                    fn NothingToWithdraw(
11883                        data: &[u8],
11884                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11885                        <NothingToWithdraw as alloy_sol_types::SolError>::abi_decode_raw_validate(
11886                                data,
11887                            )
11888                            .map(StakeTableErrors::NothingToWithdraw)
11889                    }
11890                    NothingToWithdraw
11891                },
11892                {
11893                    fn UndelegationAlreadyExists(
11894                        data: &[u8],
11895                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11896                        <UndelegationAlreadyExists as alloy_sol_types::SolError>::abi_decode_raw_validate(
11897                                data,
11898                            )
11899                            .map(StakeTableErrors::UndelegationAlreadyExists)
11900                    }
11901                    UndelegationAlreadyExists
11902                },
11903                {
11904                    fn NotInitializing(
11905                        data: &[u8],
11906                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11907                        <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw_validate(
11908                                data,
11909                            )
11910                            .map(StakeTableErrors::NotInitializing)
11911                    }
11912                    NotInitializing
11913                },
11914                {
11915                    fn ZeroAddress(
11916                        data: &[u8],
11917                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11918                        <ZeroAddress as alloy_sol_types::SolError>::abi_decode_raw_validate(
11919                                data,
11920                            )
11921                            .map(StakeTableErrors::ZeroAddress)
11922                    }
11923                    ZeroAddress
11924                },
11925                {
11926                    fn InvalidCommission(
11927                        data: &[u8],
11928                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11929                        <InvalidCommission as alloy_sol_types::SolError>::abi_decode_raw_validate(
11930                                data,
11931                            )
11932                            .map(StakeTableErrors::InvalidCommission)
11933                    }
11934                    InvalidCommission
11935                },
11936                {
11937                    fn UUPSUnauthorizedCallContext(
11938                        data: &[u8],
11939                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11940                        <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_decode_raw_validate(
11941                                data,
11942                            )
11943                            .map(StakeTableErrors::UUPSUnauthorizedCallContext)
11944                    }
11945                    UUPSUnauthorizedCallContext
11946                },
11947                {
11948                    fn ValidatorAlreadyExited(
11949                        data: &[u8],
11950                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11951                        <ValidatorAlreadyExited as alloy_sol_types::SolError>::abi_decode_raw_validate(
11952                                data,
11953                            )
11954                            .map(StakeTableErrors::ValidatorAlreadyExited)
11955                    }
11956                    ValidatorAlreadyExited
11957                },
11958                {
11959                    fn ValidatorNotExited(
11960                        data: &[u8],
11961                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11962                        <ValidatorNotExited as alloy_sol_types::SolError>::abi_decode_raw_validate(
11963                                data,
11964                            )
11965                            .map(StakeTableErrors::ValidatorNotExited)
11966                    }
11967                    ValidatorNotExited
11968                },
11969                {
11970                    fn InvalidInitialization(
11971                        data: &[u8],
11972                    ) -> alloy_sol_types::Result<StakeTableErrors> {
11973                        <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw_validate(
11974                                data,
11975                            )
11976                            .map(StakeTableErrors::InvalidInitialization)
11977                    }
11978                    InvalidInitialization
11979                },
11980            ];
11981            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
11982                return Err(
11983                    alloy_sol_types::Error::unknown_selector(
11984                        <Self as alloy_sol_types::SolInterface>::NAME,
11985                        selector,
11986                    ),
11987                );
11988            };
11989            DECODE_VALIDATE_SHIMS[idx](data)
11990        }
11991        #[inline]
11992        fn abi_encoded_size(&self) -> usize {
11993            match self {
11994                Self::AddressEmptyCode(inner) => {
11995                    <AddressEmptyCode as alloy_sol_types::SolError>::abi_encoded_size(
11996                        inner,
11997                    )
11998                }
11999                Self::BLSSigIsInfinity(inner) => {
12000                    <BLSSigIsInfinity as alloy_sol_types::SolError>::abi_encoded_size(
12001                        inner,
12002                    )
12003                }
12004                Self::BLSSigVerificationFailed(inner) => {
12005                    <BLSSigVerificationFailed as alloy_sol_types::SolError>::abi_encoded_size(
12006                        inner,
12007                    )
12008                }
12009                Self::BLSVKIsInfinity(inner) => {
12010                    <BLSVKIsInfinity as alloy_sol_types::SolError>::abi_encoded_size(
12011                        inner,
12012                    )
12013                }
12014                Self::BN254PairingProdFailed(inner) => {
12015                    <BN254PairingProdFailed as alloy_sol_types::SolError>::abi_encoded_size(
12016                        inner,
12017                    )
12018                }
12019                Self::BlsKeyAlreadyUsed(inner) => {
12020                    <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::abi_encoded_size(
12021                        inner,
12022                    )
12023                }
12024                Self::ERC1967InvalidImplementation(inner) => {
12025                    <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encoded_size(
12026                        inner,
12027                    )
12028                }
12029                Self::ERC1967NonPayable(inner) => {
12030                    <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encoded_size(
12031                        inner,
12032                    )
12033                }
12034                Self::ExitEscrowPeriodInvalid(inner) => {
12035                    <ExitEscrowPeriodInvalid as alloy_sol_types::SolError>::abi_encoded_size(
12036                        inner,
12037                    )
12038                }
12039                Self::FailedInnerCall(inner) => {
12040                    <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(
12041                        inner,
12042                    )
12043                }
12044                Self::InsufficientAllowance(inner) => {
12045                    <InsufficientAllowance as alloy_sol_types::SolError>::abi_encoded_size(
12046                        inner,
12047                    )
12048                }
12049                Self::InsufficientBalance(inner) => {
12050                    <InsufficientBalance as alloy_sol_types::SolError>::abi_encoded_size(
12051                        inner,
12052                    )
12053                }
12054                Self::InvalidCommission(inner) => {
12055                    <InvalidCommission as alloy_sol_types::SolError>::abi_encoded_size(
12056                        inner,
12057                    )
12058                }
12059                Self::InvalidG1(inner) => {
12060                    <InvalidG1 as alloy_sol_types::SolError>::abi_encoded_size(inner)
12061                }
12062                Self::InvalidInitialization(inner) => {
12063                    <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(
12064                        inner,
12065                    )
12066                }
12067                Self::InvalidSchnorrVK(inner) => {
12068                    <InvalidSchnorrVK as alloy_sol_types::SolError>::abi_encoded_size(
12069                        inner,
12070                    )
12071                }
12072                Self::NotInitializing(inner) => {
12073                    <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(
12074                        inner,
12075                    )
12076                }
12077                Self::NothingToWithdraw(inner) => {
12078                    <NothingToWithdraw as alloy_sol_types::SolError>::abi_encoded_size(
12079                        inner,
12080                    )
12081                }
12082                Self::OwnableInvalidOwner(inner) => {
12083                    <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
12084                        inner,
12085                    )
12086                }
12087                Self::OwnableUnauthorizedAccount(inner) => {
12088                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
12089                        inner,
12090                    )
12091                }
12092                Self::OwnershipCannotBeRenounced(inner) => {
12093                    <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_encoded_size(
12094                        inner,
12095                    )
12096                }
12097                Self::PowPrecompileFailed(inner) => {
12098                    <PowPrecompileFailed as alloy_sol_types::SolError>::abi_encoded_size(
12099                        inner,
12100                    )
12101                }
12102                Self::PrematureWithdrawal(inner) => {
12103                    <PrematureWithdrawal as alloy_sol_types::SolError>::abi_encoded_size(
12104                        inner,
12105                    )
12106                }
12107                Self::UUPSUnauthorizedCallContext(inner) => {
12108                    <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encoded_size(
12109                        inner,
12110                    )
12111                }
12112                Self::UUPSUnsupportedProxiableUUID(inner) => {
12113                    <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encoded_size(
12114                        inner,
12115                    )
12116                }
12117                Self::UndelegationAlreadyExists(inner) => {
12118                    <UndelegationAlreadyExists as alloy_sol_types::SolError>::abi_encoded_size(
12119                        inner,
12120                    )
12121                }
12122                Self::ValidatorAlreadyExited(inner) => {
12123                    <ValidatorAlreadyExited as alloy_sol_types::SolError>::abi_encoded_size(
12124                        inner,
12125                    )
12126                }
12127                Self::ValidatorAlreadyRegistered(inner) => {
12128                    <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::abi_encoded_size(
12129                        inner,
12130                    )
12131                }
12132                Self::ValidatorInactive(inner) => {
12133                    <ValidatorInactive as alloy_sol_types::SolError>::abi_encoded_size(
12134                        inner,
12135                    )
12136                }
12137                Self::ValidatorNotExited(inner) => {
12138                    <ValidatorNotExited as alloy_sol_types::SolError>::abi_encoded_size(
12139                        inner,
12140                    )
12141                }
12142                Self::ZeroAddress(inner) => {
12143                    <ZeroAddress as alloy_sol_types::SolError>::abi_encoded_size(inner)
12144                }
12145                Self::ZeroAmount(inner) => {
12146                    <ZeroAmount as alloy_sol_types::SolError>::abi_encoded_size(inner)
12147                }
12148            }
12149        }
12150        #[inline]
12151        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
12152            match self {
12153                Self::AddressEmptyCode(inner) => {
12154                    <AddressEmptyCode as alloy_sol_types::SolError>::abi_encode_raw(
12155                        inner,
12156                        out,
12157                    )
12158                }
12159                Self::BLSSigIsInfinity(inner) => {
12160                    <BLSSigIsInfinity as alloy_sol_types::SolError>::abi_encode_raw(
12161                        inner,
12162                        out,
12163                    )
12164                }
12165                Self::BLSSigVerificationFailed(inner) => {
12166                    <BLSSigVerificationFailed as alloy_sol_types::SolError>::abi_encode_raw(
12167                        inner,
12168                        out,
12169                    )
12170                }
12171                Self::BLSVKIsInfinity(inner) => {
12172                    <BLSVKIsInfinity as alloy_sol_types::SolError>::abi_encode_raw(
12173                        inner,
12174                        out,
12175                    )
12176                }
12177                Self::BN254PairingProdFailed(inner) => {
12178                    <BN254PairingProdFailed as alloy_sol_types::SolError>::abi_encode_raw(
12179                        inner,
12180                        out,
12181                    )
12182                }
12183                Self::BlsKeyAlreadyUsed(inner) => {
12184                    <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::abi_encode_raw(
12185                        inner,
12186                        out,
12187                    )
12188                }
12189                Self::ERC1967InvalidImplementation(inner) => {
12190                    <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encode_raw(
12191                        inner,
12192                        out,
12193                    )
12194                }
12195                Self::ERC1967NonPayable(inner) => {
12196                    <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encode_raw(
12197                        inner,
12198                        out,
12199                    )
12200                }
12201                Self::ExitEscrowPeriodInvalid(inner) => {
12202                    <ExitEscrowPeriodInvalid as alloy_sol_types::SolError>::abi_encode_raw(
12203                        inner,
12204                        out,
12205                    )
12206                }
12207                Self::FailedInnerCall(inner) => {
12208                    <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(
12209                        inner,
12210                        out,
12211                    )
12212                }
12213                Self::InsufficientAllowance(inner) => {
12214                    <InsufficientAllowance as alloy_sol_types::SolError>::abi_encode_raw(
12215                        inner,
12216                        out,
12217                    )
12218                }
12219                Self::InsufficientBalance(inner) => {
12220                    <InsufficientBalance as alloy_sol_types::SolError>::abi_encode_raw(
12221                        inner,
12222                        out,
12223                    )
12224                }
12225                Self::InvalidCommission(inner) => {
12226                    <InvalidCommission as alloy_sol_types::SolError>::abi_encode_raw(
12227                        inner,
12228                        out,
12229                    )
12230                }
12231                Self::InvalidG1(inner) => {
12232                    <InvalidG1 as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
12233                }
12234                Self::InvalidInitialization(inner) => {
12235                    <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(
12236                        inner,
12237                        out,
12238                    )
12239                }
12240                Self::InvalidSchnorrVK(inner) => {
12241                    <InvalidSchnorrVK as alloy_sol_types::SolError>::abi_encode_raw(
12242                        inner,
12243                        out,
12244                    )
12245                }
12246                Self::NotInitializing(inner) => {
12247                    <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(
12248                        inner,
12249                        out,
12250                    )
12251                }
12252                Self::NothingToWithdraw(inner) => {
12253                    <NothingToWithdraw as alloy_sol_types::SolError>::abi_encode_raw(
12254                        inner,
12255                        out,
12256                    )
12257                }
12258                Self::OwnableInvalidOwner(inner) => {
12259                    <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
12260                        inner,
12261                        out,
12262                    )
12263                }
12264                Self::OwnableUnauthorizedAccount(inner) => {
12265                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
12266                        inner,
12267                        out,
12268                    )
12269                }
12270                Self::OwnershipCannotBeRenounced(inner) => {
12271                    <OwnershipCannotBeRenounced as alloy_sol_types::SolError>::abi_encode_raw(
12272                        inner,
12273                        out,
12274                    )
12275                }
12276                Self::PowPrecompileFailed(inner) => {
12277                    <PowPrecompileFailed as alloy_sol_types::SolError>::abi_encode_raw(
12278                        inner,
12279                        out,
12280                    )
12281                }
12282                Self::PrematureWithdrawal(inner) => {
12283                    <PrematureWithdrawal as alloy_sol_types::SolError>::abi_encode_raw(
12284                        inner,
12285                        out,
12286                    )
12287                }
12288                Self::UUPSUnauthorizedCallContext(inner) => {
12289                    <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encode_raw(
12290                        inner,
12291                        out,
12292                    )
12293                }
12294                Self::UUPSUnsupportedProxiableUUID(inner) => {
12295                    <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encode_raw(
12296                        inner,
12297                        out,
12298                    )
12299                }
12300                Self::UndelegationAlreadyExists(inner) => {
12301                    <UndelegationAlreadyExists as alloy_sol_types::SolError>::abi_encode_raw(
12302                        inner,
12303                        out,
12304                    )
12305                }
12306                Self::ValidatorAlreadyExited(inner) => {
12307                    <ValidatorAlreadyExited as alloy_sol_types::SolError>::abi_encode_raw(
12308                        inner,
12309                        out,
12310                    )
12311                }
12312                Self::ValidatorAlreadyRegistered(inner) => {
12313                    <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::abi_encode_raw(
12314                        inner,
12315                        out,
12316                    )
12317                }
12318                Self::ValidatorInactive(inner) => {
12319                    <ValidatorInactive as alloy_sol_types::SolError>::abi_encode_raw(
12320                        inner,
12321                        out,
12322                    )
12323                }
12324                Self::ValidatorNotExited(inner) => {
12325                    <ValidatorNotExited as alloy_sol_types::SolError>::abi_encode_raw(
12326                        inner,
12327                        out,
12328                    )
12329                }
12330                Self::ZeroAddress(inner) => {
12331                    <ZeroAddress as alloy_sol_types::SolError>::abi_encode_raw(
12332                        inner,
12333                        out,
12334                    )
12335                }
12336                Self::ZeroAmount(inner) => {
12337                    <ZeroAmount as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
12338                }
12339            }
12340        }
12341    }
12342    ///Container for all the [`StakeTable`](self) events.
12343    #[derive(Clone)]
12344    #[derive(serde::Serialize, serde::Deserialize)]
12345    #[derive()]
12346    pub enum StakeTableEvents {
12347        #[allow(missing_docs)]
12348        ConsensusKeysUpdated(ConsensusKeysUpdated),
12349        #[allow(missing_docs)]
12350        Delegated(Delegated),
12351        #[allow(missing_docs)]
12352        Initialized(Initialized),
12353        #[allow(missing_docs)]
12354        OwnershipTransferred(OwnershipTransferred),
12355        #[allow(missing_docs)]
12356        Undelegated(Undelegated),
12357        #[allow(missing_docs)]
12358        Upgraded(Upgraded),
12359        #[allow(missing_docs)]
12360        ValidatorExit(ValidatorExit),
12361        #[allow(missing_docs)]
12362        ValidatorRegistered(ValidatorRegistered),
12363        #[allow(missing_docs)]
12364        Withdrawal(Withdrawal),
12365    }
12366    impl StakeTableEvents {
12367        /// All the selectors of this enum.
12368        ///
12369        /// Note that the selectors might not be in the same order as the variants.
12370        /// No guarantees are made about the order of the selectors.
12371        ///
12372        /// Prefer using `SolInterface` methods instead.
12373        pub const SELECTORS: &'static [[u8; 32usize]] = &[
12374            [
12375                77u8, 16u8, 189u8, 4u8, 151u8, 117u8, 199u8, 123u8, 215u8, 242u8, 85u8,
12376                25u8, 90u8, 251u8, 165u8, 8u8, 128u8, 40u8, 236u8, 179u8, 199u8, 194u8,
12377                119u8, 211u8, 147u8, 204u8, 255u8, 121u8, 52u8, 242u8, 249u8, 44u8,
12378            ],
12379            [
12380                127u8, 207u8, 83u8, 44u8, 21u8, 240u8, 166u8, 219u8, 11u8, 214u8, 208u8,
12381                224u8, 56u8, 190u8, 167u8, 29u8, 48u8, 216u8, 8u8, 199u8, 217u8, 140u8,
12382                179u8, 191u8, 114u8, 104u8, 169u8, 91u8, 245u8, 8u8, 27u8, 101u8,
12383            ],
12384            [
12385                128u8, 216u8, 164u8, 161u8, 102u8, 51u8, 40u8, 169u8, 152u8, 212u8, 85u8,
12386                91u8, 162u8, 29u8, 139u8, 186u8, 110u8, 241u8, 87u8, 106u8, 140u8, 94u8,
12387                157u8, 39u8, 249u8, 197u8, 69u8, 241u8, 163u8, 213u8, 43u8, 29u8,
12388            ],
12389            [
12390                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
12391                31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
12392                218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
12393            ],
12394            [
12395                188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
12396                179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8,
12397                12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
12398            ],
12399            [
12400                199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
12401                19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
12402                33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
12403            ],
12404            [
12405                229u8, 84u8, 26u8, 107u8, 97u8, 3u8, 212u8, 250u8, 126u8, 2u8, 30u8,
12406                213u8, 79u8, 173u8, 57u8, 198u8, 111u8, 39u8, 167u8, 107u8, 209u8, 61u8,
12407                55u8, 76u8, 246u8, 36u8, 10u8, 230u8, 189u8, 11u8, 183u8, 43u8,
12408            ],
12409            [
12410                246u8, 232u8, 53u8, 156u8, 87u8, 82u8, 11u8, 70u8, 150u8, 52u8, 115u8,
12411                107u8, 252u8, 59u8, 183u8, 236u8, 92u8, 189u8, 26u8, 11u8, 210u8, 139u8,
12412                16u8, 168u8, 39u8, 87u8, 147u8, 187u8, 115u8, 11u8, 121u8, 127u8,
12413            ],
12414            [
12415                251u8, 36u8, 48u8, 83u8, 84u8, 200u8, 119u8, 98u8, 213u8, 87u8, 72u8,
12416                122u8, 228u8, 165u8, 100u8, 232u8, 208u8, 62u8, 203u8, 185u8, 169u8,
12417                125u8, 216u8, 175u8, 255u8, 142u8, 31u8, 111u8, 202u8, 240u8, 221u8, 22u8,
12418            ],
12419        ];
12420        /// The names of the variants in the same order as `SELECTORS`.
12421        pub const VARIANT_NAMES: &'static [&'static str] = &[
12422            ::core::stringify!(Undelegated),
12423            ::core::stringify!(Withdrawal),
12424            ::core::stringify!(ConsensusKeysUpdated),
12425            ::core::stringify!(OwnershipTransferred),
12426            ::core::stringify!(Upgraded),
12427            ::core::stringify!(Initialized),
12428            ::core::stringify!(Delegated),
12429            ::core::stringify!(ValidatorRegistered),
12430            ::core::stringify!(ValidatorExit),
12431        ];
12432        /// The signatures in the same order as `SELECTORS`.
12433        pub const SIGNATURES: &'static [&'static str] = &[
12434            <Undelegated as alloy_sol_types::SolEvent>::SIGNATURE,
12435            <Withdrawal as alloy_sol_types::SolEvent>::SIGNATURE,
12436            <ConsensusKeysUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
12437            <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
12438            <Upgraded as alloy_sol_types::SolEvent>::SIGNATURE,
12439            <Initialized as alloy_sol_types::SolEvent>::SIGNATURE,
12440            <Delegated as alloy_sol_types::SolEvent>::SIGNATURE,
12441            <ValidatorRegistered as alloy_sol_types::SolEvent>::SIGNATURE,
12442            <ValidatorExit as alloy_sol_types::SolEvent>::SIGNATURE,
12443        ];
12444        /// Returns the signature for the given selector, if known.
12445        #[inline]
12446        pub fn signature_by_selector(
12447            selector: [u8; 32usize],
12448        ) -> ::core::option::Option<&'static str> {
12449            match Self::SELECTORS.binary_search(&selector) {
12450                ::core::result::Result::Ok(idx) => {
12451                    ::core::option::Option::Some(Self::SIGNATURES[idx])
12452                }
12453                ::core::result::Result::Err(_) => ::core::option::Option::None,
12454            }
12455        }
12456        /// Returns the enum variant name for the given selector, if known.
12457        #[inline]
12458        pub fn name_by_selector(
12459            selector: [u8; 32usize],
12460        ) -> ::core::option::Option<&'static str> {
12461            let sig = Self::signature_by_selector(selector)?;
12462            sig.split_once('(').map(|(name, _)| name)
12463        }
12464    }
12465    #[automatically_derived]
12466    impl alloy_sol_types::SolEventInterface for StakeTableEvents {
12467        const NAME: &'static str = "StakeTableEvents";
12468        const COUNT: usize = 9usize;
12469        fn decode_raw_log(
12470            topics: &[alloy_sol_types::Word],
12471            data: &[u8],
12472        ) -> alloy_sol_types::Result<Self> {
12473            match topics.first().copied() {
12474                Some(
12475                    <ConsensusKeysUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
12476                ) => {
12477                    <ConsensusKeysUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
12478                            topics,
12479                            data,
12480                        )
12481                        .map(Self::ConsensusKeysUpdated)
12482                }
12483                Some(<Delegated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
12484                    <Delegated as alloy_sol_types::SolEvent>::decode_raw_log(
12485                            topics,
12486                            data,
12487                        )
12488                        .map(Self::Delegated)
12489                }
12490                Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
12491                    <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
12492                            topics,
12493                            data,
12494                        )
12495                        .map(Self::Initialized)
12496                }
12497                Some(
12498                    <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
12499                ) => {
12500                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
12501                            topics,
12502                            data,
12503                        )
12504                        .map(Self::OwnershipTransferred)
12505                }
12506                Some(<Undelegated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
12507                    <Undelegated as alloy_sol_types::SolEvent>::decode_raw_log(
12508                            topics,
12509                            data,
12510                        )
12511                        .map(Self::Undelegated)
12512                }
12513                Some(<Upgraded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
12514                    <Upgraded as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
12515                        .map(Self::Upgraded)
12516                }
12517                Some(<ValidatorExit as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
12518                    <ValidatorExit as alloy_sol_types::SolEvent>::decode_raw_log(
12519                            topics,
12520                            data,
12521                        )
12522                        .map(Self::ValidatorExit)
12523                }
12524                Some(
12525                    <ValidatorRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
12526                ) => {
12527                    <ValidatorRegistered as alloy_sol_types::SolEvent>::decode_raw_log(
12528                            topics,
12529                            data,
12530                        )
12531                        .map(Self::ValidatorRegistered)
12532                }
12533                Some(<Withdrawal as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
12534                    <Withdrawal as alloy_sol_types::SolEvent>::decode_raw_log(
12535                            topics,
12536                            data,
12537                        )
12538                        .map(Self::Withdrawal)
12539                }
12540                _ => {
12541                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
12542                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
12543                        log: alloy_sol_types::private::Box::new(
12544                            alloy_sol_types::private::LogData::new_unchecked(
12545                                topics.to_vec(),
12546                                data.to_vec().into(),
12547                            ),
12548                        ),
12549                    })
12550                }
12551            }
12552        }
12553    }
12554    #[automatically_derived]
12555    impl alloy_sol_types::private::IntoLogData for StakeTableEvents {
12556        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
12557            match self {
12558                Self::ConsensusKeysUpdated(inner) => {
12559                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
12560                }
12561                Self::Delegated(inner) => {
12562                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
12563                }
12564                Self::Initialized(inner) => {
12565                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
12566                }
12567                Self::OwnershipTransferred(inner) => {
12568                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
12569                }
12570                Self::Undelegated(inner) => {
12571                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
12572                }
12573                Self::Upgraded(inner) => {
12574                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
12575                }
12576                Self::ValidatorExit(inner) => {
12577                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
12578                }
12579                Self::ValidatorRegistered(inner) => {
12580                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
12581                }
12582                Self::Withdrawal(inner) => {
12583                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
12584                }
12585            }
12586        }
12587        fn into_log_data(self) -> alloy_sol_types::private::LogData {
12588            match self {
12589                Self::ConsensusKeysUpdated(inner) => {
12590                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
12591                }
12592                Self::Delegated(inner) => {
12593                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
12594                }
12595                Self::Initialized(inner) => {
12596                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
12597                }
12598                Self::OwnershipTransferred(inner) => {
12599                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
12600                }
12601                Self::Undelegated(inner) => {
12602                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
12603                }
12604                Self::Upgraded(inner) => {
12605                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
12606                }
12607                Self::ValidatorExit(inner) => {
12608                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
12609                }
12610                Self::ValidatorRegistered(inner) => {
12611                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
12612                }
12613                Self::Withdrawal(inner) => {
12614                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
12615                }
12616            }
12617        }
12618    }
12619    use alloy::contract as alloy_contract;
12620    /**Creates a new wrapper around an on-chain [`StakeTable`](self) contract instance.
12621
12622See the [wrapper's documentation](`StakeTableInstance`) for more details.*/
12623    #[inline]
12624    pub const fn new<
12625        P: alloy_contract::private::Provider<N>,
12626        N: alloy_contract::private::Network,
12627    >(
12628        address: alloy_sol_types::private::Address,
12629        __provider: P,
12630    ) -> StakeTableInstance<P, N> {
12631        StakeTableInstance::<P, N>::new(address, __provider)
12632    }
12633    /**Deploys this contract using the given `provider` and constructor arguments, if any.
12634
12635Returns a new instance of the contract, if the deployment was successful.
12636
12637For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
12638    #[inline]
12639    pub fn deploy<
12640        P: alloy_contract::private::Provider<N>,
12641        N: alloy_contract::private::Network,
12642    >(
12643        __provider: P,
12644    ) -> impl ::core::future::Future<
12645        Output = alloy_contract::Result<StakeTableInstance<P, N>>,
12646    > {
12647        StakeTableInstance::<P, N>::deploy(__provider)
12648    }
12649    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
12650and constructor arguments, if any.
12651
12652This is a simple wrapper around creating a `RawCallBuilder` with the data set to
12653the bytecode concatenated with the constructor's ABI-encoded arguments.*/
12654    #[inline]
12655    pub fn deploy_builder<
12656        P: alloy_contract::private::Provider<N>,
12657        N: alloy_contract::private::Network,
12658    >(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
12659        StakeTableInstance::<P, N>::deploy_builder(__provider)
12660    }
12661    /**A [`StakeTable`](self) instance.
12662
12663Contains type-safe methods for interacting with an on-chain instance of the
12664[`StakeTable`](self) contract located at a given `address`, using a given
12665provider `P`.
12666
12667If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
12668documentation on how to provide it), the `deploy` and `deploy_builder` methods can
12669be used to deploy a new instance of the contract.
12670
12671See the [module-level documentation](self) for all the available methods.*/
12672    #[derive(Clone)]
12673    pub struct StakeTableInstance<P, N = alloy_contract::private::Ethereum> {
12674        address: alloy_sol_types::private::Address,
12675        provider: P,
12676        _network: ::core::marker::PhantomData<N>,
12677    }
12678    #[automatically_derived]
12679    impl<P, N> ::core::fmt::Debug for StakeTableInstance<P, N> {
12680        #[inline]
12681        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12682            f.debug_tuple("StakeTableInstance").field(&self.address).finish()
12683        }
12684    }
12685    /// Instantiation and getters/setters.
12686    impl<
12687        P: alloy_contract::private::Provider<N>,
12688        N: alloy_contract::private::Network,
12689    > StakeTableInstance<P, N> {
12690        /**Creates a new wrapper around an on-chain [`StakeTable`](self) contract instance.
12691
12692See the [wrapper's documentation](`StakeTableInstance`) for more details.*/
12693        #[inline]
12694        pub const fn new(
12695            address: alloy_sol_types::private::Address,
12696            __provider: P,
12697        ) -> Self {
12698            Self {
12699                address,
12700                provider: __provider,
12701                _network: ::core::marker::PhantomData,
12702            }
12703        }
12704        /**Deploys this contract using the given `provider` and constructor arguments, if any.
12705
12706Returns a new instance of the contract, if the deployment was successful.
12707
12708For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
12709        #[inline]
12710        pub async fn deploy(
12711            __provider: P,
12712        ) -> alloy_contract::Result<StakeTableInstance<P, N>> {
12713            let call_builder = Self::deploy_builder(__provider);
12714            let contract_address = call_builder.deploy().await?;
12715            Ok(Self::new(contract_address, call_builder.provider))
12716        }
12717        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
12718and constructor arguments, if any.
12719
12720This is a simple wrapper around creating a `RawCallBuilder` with the data set to
12721the bytecode concatenated with the constructor's ABI-encoded arguments.*/
12722        #[inline]
12723        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
12724            alloy_contract::RawCallBuilder::new_raw_deploy(
12725                __provider,
12726                ::core::clone::Clone::clone(&BYTECODE),
12727            )
12728        }
12729        /// Returns a reference to the address.
12730        #[inline]
12731        pub const fn address(&self) -> &alloy_sol_types::private::Address {
12732            &self.address
12733        }
12734        /// Sets the address.
12735        #[inline]
12736        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
12737            self.address = address;
12738        }
12739        /// Sets the address and returns `self`.
12740        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
12741            self.set_address(address);
12742            self
12743        }
12744        /// Returns a reference to the provider.
12745        #[inline]
12746        pub const fn provider(&self) -> &P {
12747            &self.provider
12748        }
12749    }
12750    impl<P: ::core::clone::Clone, N> StakeTableInstance<&P, N> {
12751        /// Clones the provider and returns a new instance with the cloned provider.
12752        #[inline]
12753        pub fn with_cloned_provider(self) -> StakeTableInstance<P, N> {
12754            StakeTableInstance {
12755                address: self.address,
12756                provider: ::core::clone::Clone::clone(&self.provider),
12757                _network: ::core::marker::PhantomData,
12758            }
12759        }
12760    }
12761    /// Function calls.
12762    impl<
12763        P: alloy_contract::private::Provider<N>,
12764        N: alloy_contract::private::Network,
12765    > StakeTableInstance<P, N> {
12766        /// Creates a new call builder using this contract instance's provider and address.
12767        ///
12768        /// Note that the call can be any function call, not just those defined in this
12769        /// contract. Prefer using the other methods for building type-safe contract calls.
12770        pub fn call_builder<C: alloy_sol_types::SolCall>(
12771            &self,
12772            call: &C,
12773        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
12774            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
12775        }
12776        ///Creates a new call builder for the [`UPGRADE_INTERFACE_VERSION`] function.
12777        pub fn UPGRADE_INTERFACE_VERSION(
12778            &self,
12779        ) -> alloy_contract::SolCallBuilder<&P, UPGRADE_INTERFACE_VERSIONCall, N> {
12780            self.call_builder(&UPGRADE_INTERFACE_VERSIONCall)
12781        }
12782        ///Creates a new call builder for the [`_hashBlsKey`] function.
12783        pub fn _hashBlsKey(
12784            &self,
12785            blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
12786        ) -> alloy_contract::SolCallBuilder<&P, _hashBlsKeyCall, N> {
12787            self.call_builder(&_hashBlsKeyCall { blsVK })
12788        }
12789        ///Creates a new call builder for the [`blsKeys`] function.
12790        pub fn blsKeys(
12791            &self,
12792            blsKeyHash: alloy::sol_types::private::FixedBytes<32>,
12793        ) -> alloy_contract::SolCallBuilder<&P, blsKeysCall, N> {
12794            self.call_builder(&blsKeysCall { blsKeyHash })
12795        }
12796        ///Creates a new call builder for the [`claimValidatorExit`] function.
12797        pub fn claimValidatorExit(
12798            &self,
12799            validator: alloy::sol_types::private::Address,
12800        ) -> alloy_contract::SolCallBuilder<&P, claimValidatorExitCall, N> {
12801            self.call_builder(
12802                &claimValidatorExitCall {
12803                    validator,
12804                },
12805            )
12806        }
12807        ///Creates a new call builder for the [`claimWithdrawal`] function.
12808        pub fn claimWithdrawal(
12809            &self,
12810            validator: alloy::sol_types::private::Address,
12811        ) -> alloy_contract::SolCallBuilder<&P, claimWithdrawalCall, N> {
12812            self.call_builder(&claimWithdrawalCall { validator })
12813        }
12814        ///Creates a new call builder for the [`delegate`] function.
12815        pub fn delegate(
12816            &self,
12817            validator: alloy::sol_types::private::Address,
12818            amount: alloy::sol_types::private::primitives::aliases::U256,
12819        ) -> alloy_contract::SolCallBuilder<&P, delegateCall, N> {
12820            self.call_builder(&delegateCall { validator, amount })
12821        }
12822        ///Creates a new call builder for the [`delegations`] function.
12823        pub fn delegations(
12824            &self,
12825            validator: alloy::sol_types::private::Address,
12826            delegator: alloy::sol_types::private::Address,
12827        ) -> alloy_contract::SolCallBuilder<&P, delegationsCall, N> {
12828            self.call_builder(
12829                &delegationsCall {
12830                    validator,
12831                    delegator,
12832                },
12833            )
12834        }
12835        ///Creates a new call builder for the [`deregisterValidator`] function.
12836        pub fn deregisterValidator(
12837            &self,
12838        ) -> alloy_contract::SolCallBuilder<&P, deregisterValidatorCall, N> {
12839            self.call_builder(&deregisterValidatorCall)
12840        }
12841        ///Creates a new call builder for the [`exitEscrowPeriod`] function.
12842        pub fn exitEscrowPeriod(
12843            &self,
12844        ) -> alloy_contract::SolCallBuilder<&P, exitEscrowPeriodCall, N> {
12845            self.call_builder(&exitEscrowPeriodCall)
12846        }
12847        ///Creates a new call builder for the [`getVersion`] function.
12848        pub fn getVersion(
12849            &self,
12850        ) -> alloy_contract::SolCallBuilder<&P, getVersionCall, N> {
12851            self.call_builder(&getVersionCall)
12852        }
12853        ///Creates a new call builder for the [`initialize`] function.
12854        pub fn initialize(
12855            &self,
12856            _tokenAddress: alloy::sol_types::private::Address,
12857            _lightClientAddress: alloy::sol_types::private::Address,
12858            _exitEscrowPeriod: alloy::sol_types::private::primitives::aliases::U256,
12859            _timelock: alloy::sol_types::private::Address,
12860        ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
12861            self.call_builder(
12862                &initializeCall {
12863                    _tokenAddress,
12864                    _lightClientAddress,
12865                    _exitEscrowPeriod,
12866                    _timelock,
12867                },
12868            )
12869        }
12870        ///Creates a new call builder for the [`initializedAtBlock`] function.
12871        pub fn initializedAtBlock(
12872            &self,
12873        ) -> alloy_contract::SolCallBuilder<&P, initializedAtBlockCall, N> {
12874            self.call_builder(&initializedAtBlockCall)
12875        }
12876        ///Creates a new call builder for the [`lightClient`] function.
12877        pub fn lightClient(
12878            &self,
12879        ) -> alloy_contract::SolCallBuilder<&P, lightClientCall, N> {
12880            self.call_builder(&lightClientCall)
12881        }
12882        ///Creates a new call builder for the [`owner`] function.
12883        pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
12884            self.call_builder(&ownerCall)
12885        }
12886        ///Creates a new call builder for the [`proxiableUUID`] function.
12887        pub fn proxiableUUID(
12888            &self,
12889        ) -> alloy_contract::SolCallBuilder<&P, proxiableUUIDCall, N> {
12890            self.call_builder(&proxiableUUIDCall)
12891        }
12892        ///Creates a new call builder for the [`registerValidator`] function.
12893        pub fn registerValidator(
12894            &self,
12895            blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
12896            schnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
12897            blsSig: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
12898            commission: u16,
12899        ) -> alloy_contract::SolCallBuilder<&P, registerValidatorCall, N> {
12900            self.call_builder(
12901                &registerValidatorCall {
12902                    blsVK,
12903                    schnorrVK,
12904                    blsSig,
12905                    commission,
12906                },
12907            )
12908        }
12909        ///Creates a new call builder for the [`renounceOwnership`] function.
12910        pub fn renounceOwnership(
12911            &self,
12912        ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
12913            self.call_builder(&renounceOwnershipCall)
12914        }
12915        ///Creates a new call builder for the [`token`] function.
12916        pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> {
12917            self.call_builder(&tokenCall)
12918        }
12919        ///Creates a new call builder for the [`transferOwnership`] function.
12920        pub fn transferOwnership(
12921            &self,
12922            newOwner: alloy::sol_types::private::Address,
12923        ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
12924            self.call_builder(&transferOwnershipCall { newOwner })
12925        }
12926        ///Creates a new call builder for the [`undelegate`] function.
12927        pub fn undelegate(
12928            &self,
12929            validator: alloy::sol_types::private::Address,
12930            amount: alloy::sol_types::private::primitives::aliases::U256,
12931        ) -> alloy_contract::SolCallBuilder<&P, undelegateCall, N> {
12932            self.call_builder(
12933                &undelegateCall {
12934                    validator,
12935                    amount,
12936                },
12937            )
12938        }
12939        ///Creates a new call builder for the [`undelegations`] function.
12940        pub fn undelegations(
12941            &self,
12942            validator: alloy::sol_types::private::Address,
12943            delegator: alloy::sol_types::private::Address,
12944        ) -> alloy_contract::SolCallBuilder<&P, undelegationsCall, N> {
12945            self.call_builder(
12946                &undelegationsCall {
12947                    validator,
12948                    delegator,
12949                },
12950            )
12951        }
12952        ///Creates a new call builder for the [`updateConsensusKeys`] function.
12953        pub fn updateConsensusKeys(
12954            &self,
12955            newBlsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
12956            newSchnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
12957            newBlsSig: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
12958        ) -> alloy_contract::SolCallBuilder<&P, updateConsensusKeysCall, N> {
12959            self.call_builder(
12960                &updateConsensusKeysCall {
12961                    newBlsVK,
12962                    newSchnorrVK,
12963                    newBlsSig,
12964                },
12965            )
12966        }
12967        ///Creates a new call builder for the [`upgradeToAndCall`] function.
12968        pub fn upgradeToAndCall(
12969            &self,
12970            newImplementation: alloy::sol_types::private::Address,
12971            data: alloy::sol_types::private::Bytes,
12972        ) -> alloy_contract::SolCallBuilder<&P, upgradeToAndCallCall, N> {
12973            self.call_builder(
12974                &upgradeToAndCallCall {
12975                    newImplementation,
12976                    data,
12977                },
12978            )
12979        }
12980        ///Creates a new call builder for the [`validatorExits`] function.
12981        pub fn validatorExits(
12982            &self,
12983            validator: alloy::sol_types::private::Address,
12984        ) -> alloy_contract::SolCallBuilder<&P, validatorExitsCall, N> {
12985            self.call_builder(&validatorExitsCall { validator })
12986        }
12987        ///Creates a new call builder for the [`validators`] function.
12988        pub fn validators(
12989            &self,
12990            account: alloy::sol_types::private::Address,
12991        ) -> alloy_contract::SolCallBuilder<&P, validatorsCall, N> {
12992            self.call_builder(&validatorsCall { account })
12993        }
12994    }
12995    /// Event filters.
12996    impl<
12997        P: alloy_contract::private::Provider<N>,
12998        N: alloy_contract::private::Network,
12999    > StakeTableInstance<P, N> {
13000        /// Creates a new event filter using this contract instance's provider and address.
13001        ///
13002        /// Note that the type can be any event, not just those defined in this contract.
13003        /// Prefer using the other methods for building type-safe event filters.
13004        pub fn event_filter<E: alloy_sol_types::SolEvent>(
13005            &self,
13006        ) -> alloy_contract::Event<&P, E, N> {
13007            alloy_contract::Event::new_sol(&self.provider, &self.address)
13008        }
13009        ///Creates a new event filter for the [`ConsensusKeysUpdated`] event.
13010        pub fn ConsensusKeysUpdated_filter(
13011            &self,
13012        ) -> alloy_contract::Event<&P, ConsensusKeysUpdated, N> {
13013            self.event_filter::<ConsensusKeysUpdated>()
13014        }
13015        ///Creates a new event filter for the [`Delegated`] event.
13016        pub fn Delegated_filter(&self) -> alloy_contract::Event<&P, Delegated, N> {
13017            self.event_filter::<Delegated>()
13018        }
13019        ///Creates a new event filter for the [`Initialized`] event.
13020        pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
13021            self.event_filter::<Initialized>()
13022        }
13023        ///Creates a new event filter for the [`OwnershipTransferred`] event.
13024        pub fn OwnershipTransferred_filter(
13025            &self,
13026        ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
13027            self.event_filter::<OwnershipTransferred>()
13028        }
13029        ///Creates a new event filter for the [`Undelegated`] event.
13030        pub fn Undelegated_filter(&self) -> alloy_contract::Event<&P, Undelegated, N> {
13031            self.event_filter::<Undelegated>()
13032        }
13033        ///Creates a new event filter for the [`Upgraded`] event.
13034        pub fn Upgraded_filter(&self) -> alloy_contract::Event<&P, Upgraded, N> {
13035            self.event_filter::<Upgraded>()
13036        }
13037        ///Creates a new event filter for the [`ValidatorExit`] event.
13038        pub fn ValidatorExit_filter(
13039            &self,
13040        ) -> alloy_contract::Event<&P, ValidatorExit, N> {
13041            self.event_filter::<ValidatorExit>()
13042        }
13043        ///Creates a new event filter for the [`ValidatorRegistered`] event.
13044        pub fn ValidatorRegistered_filter(
13045            &self,
13046        ) -> alloy_contract::Event<&P, ValidatorRegistered, N> {
13047            self.event_filter::<ValidatorRegistered>()
13048        }
13049        ///Creates a new event filter for the [`Withdrawal`] event.
13050        pub fn Withdrawal_filter(&self) -> alloy_contract::Event<&P, Withdrawal, N> {
13051            self.event_filter::<Withdrawal>()
13052        }
13053    }
13054}
hotshot_contract_adapter/bindings/stake_table.rs

hotshot_contract_adapter/bindings/
stake_table.rs
