hotshot_contract_adapter/bindings/
staketable.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 alloy::sol_types as alloy_sol_types;
20
21    use super::*;
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        {
32            #[inline]
33            fn stv_to_tokens(
34                &self,
35            ) -> <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::Token<'_>
36            {
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<256> as alloy_sol_types::SolType>::tokenize(self)
44                    .0
45            }
46            #[inline]
47            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
48                <alloy::sol_types::sol_data::Uint<
49                    256,
50                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
51            }
52            #[inline]
53            fn stv_abi_packed_encoded_size(&self) -> usize {
54                <alloy::sol_types::sol_data::Uint<
55                    256,
56                > as alloy_sol_types::SolType>::abi_encoded_size(self)
57            }
58        }
59        #[automatically_derived]
60        impl BaseField {
61            /// The Solidity type name.
62            pub const NAME: &'static str = stringify!(@ name);
63            /// Convert from the underlying value type.
64            #[inline]
65            pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self {
66                Self(value)
67            }
68            /// Return the underlying value.
69            #[inline]
70            pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 {
71                self.0
72            }
73            /// Return the single encoding of this value, delegating to the
74            /// underlying type.
75            #[inline]
76            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
77                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
78            }
79            /// Return the packed encoding of this value, delegating to the
80            /// underlying type.
81            #[inline]
82            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
83                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
84            }
85        }
86        #[automatically_derived]
87        impl alloy_sol_types::SolType for BaseField {
88            type RustType = alloy::sol_types::private::primitives::aliases::U256;
89            type Token<'a> =
90                <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::Token<'a>;
91            const SOL_NAME: &'static str = Self::NAME;
92            const ENCODED_SIZE: Option<usize> =
93                <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::ENCODED_SIZE;
94            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
95                256,
96            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
97            #[inline]
98            fn valid_token(token: &Self::Token<'_>) -> bool {
99                Self::type_check(token).is_ok()
100            }
101            #[inline]
102            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
103                <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::type_check(
104                    token,
105                )
106            }
107            #[inline]
108            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
109                <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::detokenize(
110                    token,
111                )
112            }
113        }
114        #[automatically_derived]
115        impl alloy_sol_types::EventTopic for BaseField {
116            #[inline]
117            fn topic_preimage_length(rust: &Self::RustType) -> usize {
118                <alloy::sol_types::sol_data::Uint<
119                    256,
120                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
121            }
122            #[inline]
123            fn encode_topic_preimage(
124                rust: &Self::RustType,
125                out: &mut alloy_sol_types::private::Vec<u8>,
126            ) {
127                <alloy::sol_types::sol_data::Uint<
128                    256,
129                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
130            }
131            #[inline]
132            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
133                <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::EventTopic>::encode_topic(
134                    rust,
135                )
136            }
137        }
138    };
139    #[derive(Default, Debug, PartialEq, Eq, Hash)]
140    /**```solidity
141    struct G1Point { BaseField x; BaseField y; }
142    ```*/
143    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
144    #[derive(Clone)]
145    pub struct G1Point {
146        #[allow(missing_docs)]
147        pub x: <BaseField as alloy::sol_types::SolType>::RustType,
148        #[allow(missing_docs)]
149        pub y: <BaseField as alloy::sol_types::SolType>::RustType,
150    }
151    #[allow(
152        non_camel_case_types,
153        non_snake_case,
154        clippy::pub_underscore_fields,
155        clippy::style
156    )]
157    const _: () = {
158        use alloy::sol_types as alloy_sol_types;
159        #[doc(hidden)]
160        type UnderlyingSolTuple<'a> = (BaseField, BaseField);
161        #[doc(hidden)]
162        type UnderlyingRustTuple<'a> = (
163            <BaseField as alloy::sol_types::SolType>::RustType,
164            <BaseField as alloy::sol_types::SolType>::RustType,
165        );
166        #[cfg(test)]
167        #[allow(dead_code, unreachable_patterns)]
168        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
169            match _t {
170                alloy_sol_types::private::AssertTypeEq::<
171                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
172                >(_) => {},
173            }
174        }
175        #[automatically_derived]
176        #[doc(hidden)]
177        impl ::core::convert::From<G1Point> for UnderlyingRustTuple<'_> {
178            fn from(value: G1Point) -> Self {
179                (value.x, value.y)
180            }
181        }
182        #[automatically_derived]
183        #[doc(hidden)]
184        impl ::core::convert::From<UnderlyingRustTuple<'_>> for G1Point {
185            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
186                Self {
187                    x: tuple.0,
188                    y: tuple.1,
189                }
190            }
191        }
192        #[automatically_derived]
193        impl alloy_sol_types::SolValue for G1Point {
194            type SolType = Self;
195        }
196        #[automatically_derived]
197        impl alloy_sol_types::private::SolTypeValue<Self> for G1Point {
198            #[inline]
199            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
200                (
201                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.x),
202                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.y),
203                )
204            }
205            #[inline]
206            fn stv_abi_encoded_size(&self) -> usize {
207                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
208                    return size;
209                }
210                let tuple =
211                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
212                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
213            }
214            #[inline]
215            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
216                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
217            }
218            #[inline]
219            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
220                let tuple =
221                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
222                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
223                    &tuple, out,
224                )
225            }
226            #[inline]
227            fn stv_abi_packed_encoded_size(&self) -> usize {
228                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
229                    return size;
230                }
231                let tuple =
232                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
233                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
234                    &tuple,
235                )
236            }
237        }
238        #[automatically_derived]
239        impl alloy_sol_types::SolType for G1Point {
240            type RustType = Self;
241            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
242            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
243            const ENCODED_SIZE: Option<usize> =
244                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
245            const PACKED_ENCODED_SIZE: Option<usize> =
246                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
247            #[inline]
248            fn valid_token(token: &Self::Token<'_>) -> bool {
249                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
250            }
251            #[inline]
252            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
253                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
254                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
255            }
256        }
257        #[automatically_derived]
258        impl alloy_sol_types::SolStruct for G1Point {
259            const NAME: &'static str = "G1Point";
260            #[inline]
261            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
262                alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 x,uint256 y)")
263            }
264            #[inline]
265            fn eip712_components(
266            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
267            {
268                alloy_sol_types::private::Vec::new()
269            }
270            #[inline]
271            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
272                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
273            }
274            #[inline]
275            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
276                [
277                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.x).0,
278                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.y).0,
279                ]
280                .concat()
281            }
282        }
283        #[automatically_derived]
284        impl alloy_sol_types::EventTopic for G1Point {
285            #[inline]
286            fn topic_preimage_length(rust: &Self::RustType) -> usize {
287                0usize
288                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.x)
289                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.y)
290            }
291            #[inline]
292            fn encode_topic_preimage(
293                rust: &Self::RustType,
294                out: &mut alloy_sol_types::private::Vec<u8>,
295            ) {
296                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
297                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.x, out);
298                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.y, out);
299            }
300            #[inline]
301            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
302                let mut out = alloy_sol_types::private::Vec::new();
303                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
304                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
305            }
306        }
307    };
308    #[derive(Default, Debug, PartialEq, Eq, Hash)]
309    /**```solidity
310    struct G2Point { BaseField x0; BaseField x1; BaseField y0; BaseField y1; }
311    ```*/
312    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
313    #[derive(Clone)]
314    pub struct G2Point {
315        #[allow(missing_docs)]
316        pub x0: <BaseField as alloy::sol_types::SolType>::RustType,
317        #[allow(missing_docs)]
318        pub x1: <BaseField as alloy::sol_types::SolType>::RustType,
319        #[allow(missing_docs)]
320        pub y0: <BaseField as alloy::sol_types::SolType>::RustType,
321        #[allow(missing_docs)]
322        pub y1: <BaseField as alloy::sol_types::SolType>::RustType,
323    }
324    #[allow(
325        non_camel_case_types,
326        non_snake_case,
327        clippy::pub_underscore_fields,
328        clippy::style
329    )]
330    const _: () = {
331        use alloy::sol_types as alloy_sol_types;
332        #[doc(hidden)]
333        type UnderlyingSolTuple<'a> = (BaseField, BaseField, BaseField, BaseField);
334        #[doc(hidden)]
335        type UnderlyingRustTuple<'a> = (
336            <BaseField as alloy::sol_types::SolType>::RustType,
337            <BaseField as alloy::sol_types::SolType>::RustType,
338            <BaseField as alloy::sol_types::SolType>::RustType,
339            <BaseField as alloy::sol_types::SolType>::RustType,
340        );
341        #[cfg(test)]
342        #[allow(dead_code, unreachable_patterns)]
343        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
344            match _t {
345                alloy_sol_types::private::AssertTypeEq::<
346                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
347                >(_) => {},
348            }
349        }
350        #[automatically_derived]
351        #[doc(hidden)]
352        impl ::core::convert::From<G2Point> for UnderlyingRustTuple<'_> {
353            fn from(value: G2Point) -> Self {
354                (value.x0, value.x1, value.y0, value.y1)
355            }
356        }
357        #[automatically_derived]
358        #[doc(hidden)]
359        impl ::core::convert::From<UnderlyingRustTuple<'_>> for G2Point {
360            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
361                Self {
362                    x0: tuple.0,
363                    x1: tuple.1,
364                    y0: tuple.2,
365                    y1: tuple.3,
366                }
367            }
368        }
369        #[automatically_derived]
370        impl alloy_sol_types::SolValue for G2Point {
371            type SolType = Self;
372        }
373        #[automatically_derived]
374        impl alloy_sol_types::private::SolTypeValue<Self> for G2Point {
375            #[inline]
376            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
377                (
378                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.x0),
379                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.x1),
380                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.y0),
381                    <BaseField as alloy_sol_types::SolType>::tokenize(&self.y1),
382                )
383            }
384            #[inline]
385            fn stv_abi_encoded_size(&self) -> usize {
386                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
387                    return size;
388                }
389                let tuple =
390                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
391                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
392            }
393            #[inline]
394            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
395                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
396            }
397            #[inline]
398            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
399                let tuple =
400                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
401                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
402                    &tuple, out,
403                )
404            }
405            #[inline]
406            fn stv_abi_packed_encoded_size(&self) -> usize {
407                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
408                    return size;
409                }
410                let tuple =
411                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
412                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
413                    &tuple,
414                )
415            }
416        }
417        #[automatically_derived]
418        impl alloy_sol_types::SolType for G2Point {
419            type RustType = Self;
420            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
421            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
422            const ENCODED_SIZE: Option<usize> =
423                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
424            const PACKED_ENCODED_SIZE: Option<usize> =
425                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
426            #[inline]
427            fn valid_token(token: &Self::Token<'_>) -> bool {
428                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
429            }
430            #[inline]
431            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
432                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
433                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
434            }
435        }
436        #[automatically_derived]
437        impl alloy_sol_types::SolStruct for G2Point {
438            const NAME: &'static str = "G2Point";
439            #[inline]
440            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
441                alloy_sol_types::private::Cow::Borrowed(
442                    "G2Point(uint256 x0,uint256 x1,uint256 y0,uint256 y1)",
443                )
444            }
445            #[inline]
446            fn eip712_components(
447            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
448            {
449                alloy_sol_types::private::Vec::new()
450            }
451            #[inline]
452            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
453                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
454            }
455            #[inline]
456            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
457                [
458                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.x0).0,
459                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.x1).0,
460                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.y0).0,
461                    <BaseField as alloy_sol_types::SolType>::eip712_data_word(&self.y1).0,
462                ]
463                .concat()
464            }
465        }
466        #[automatically_derived]
467        impl alloy_sol_types::EventTopic for G2Point {
468            #[inline]
469            fn topic_preimage_length(rust: &Self::RustType) -> usize {
470                0usize
471                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.x0)
472                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.x1)
473                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.y0)
474                    + <BaseField as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.y1)
475            }
476            #[inline]
477            fn encode_topic_preimage(
478                rust: &Self::RustType,
479                out: &mut alloy_sol_types::private::Vec<u8>,
480            ) {
481                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
482                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.x0, out);
483                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.x1, out);
484                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.y0, out);
485                <BaseField as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.y1, out);
486            }
487            #[inline]
488            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
489                let mut out = alloy_sol_types::private::Vec::new();
490                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
491                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
492            }
493        }
494    };
495    use alloy::contract as alloy_contract;
496    /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance.
497
498    See the [wrapper's documentation](`BN254Instance`) for more details.*/
499    #[inline]
500    pub const fn new<
501        T: alloy_contract::private::Transport + ::core::clone::Clone,
502        P: alloy_contract::private::Provider<T, N>,
503        N: alloy_contract::private::Network,
504    >(
505        address: alloy_sol_types::private::Address,
506        provider: P,
507    ) -> BN254Instance<T, P, N> {
508        BN254Instance::<T, P, N>::new(address, provider)
509    }
510    /**A [`BN254`](self) instance.
511
512    Contains type-safe methods for interacting with an on-chain instance of the
513    [`BN254`](self) contract located at a given `address`, using a given
514    provider `P`.
515
516    If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
517    documentation on how to provide it), the `deploy` and `deploy_builder` methods can
518    be used to deploy a new instance of the contract.
519
520    See the [module-level documentation](self) for all the available methods.*/
521    #[derive(Clone)]
522    pub struct BN254Instance<T, P, N = alloy_contract::private::Ethereum> {
523        address: alloy_sol_types::private::Address,
524        provider: P,
525        _network_transport: ::core::marker::PhantomData<(N, T)>,
526    }
527    #[automatically_derived]
528    impl<T, P, N> ::core::fmt::Debug for BN254Instance<T, P, N> {
529        #[inline]
530        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
531            f.debug_tuple("BN254Instance").field(&self.address).finish()
532        }
533    }
534    /// Instantiation and getters/setters.
535    #[automatically_derived]
536    impl<
537            T: alloy_contract::private::Transport + ::core::clone::Clone,
538            P: alloy_contract::private::Provider<T, N>,
539            N: alloy_contract::private::Network,
540        > BN254Instance<T, P, N>
541    {
542        /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance.
543
544        See the [wrapper's documentation](`BN254Instance`) for more details.*/
545        #[inline]
546        pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
547            Self {
548                address,
549                provider,
550                _network_transport: ::core::marker::PhantomData,
551            }
552        }
553        /// Returns a reference to the address.
554        #[inline]
555        pub const fn address(&self) -> &alloy_sol_types::private::Address {
556            &self.address
557        }
558        /// Sets the address.
559        #[inline]
560        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
561            self.address = address;
562        }
563        /// Sets the address and returns `self`.
564        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
565            self.set_address(address);
566            self
567        }
568        /// Returns a reference to the provider.
569        #[inline]
570        pub const fn provider(&self) -> &P {
571            &self.provider
572        }
573    }
574    impl<T, P: ::core::clone::Clone, N> BN254Instance<T, &P, N> {
575        /// Clones the provider and returns a new instance with the cloned provider.
576        #[inline]
577        pub fn with_cloned_provider(self) -> BN254Instance<T, P, N> {
578            BN254Instance {
579                address: self.address,
580                provider: ::core::clone::Clone::clone(&self.provider),
581                _network_transport: ::core::marker::PhantomData,
582            }
583        }
584    }
585    /// Function calls.
586    #[automatically_derived]
587    impl<
588            T: alloy_contract::private::Transport + ::core::clone::Clone,
589            P: alloy_contract::private::Provider<T, N>,
590            N: alloy_contract::private::Network,
591        > BN254Instance<T, P, N>
592    {
593        /// Creates a new call builder using this contract instance's provider and address.
594        ///
595        /// Note that the call can be any function call, not just those defined in this
596        /// contract. Prefer using the other methods for building type-safe contract calls.
597        pub fn call_builder<C: alloy_sol_types::SolCall>(
598            &self,
599            call: &C,
600        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
601            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
602        }
603    }
604    /// Event filters.
605    #[automatically_derived]
606    impl<
607            T: alloy_contract::private::Transport + ::core::clone::Clone,
608            P: alloy_contract::private::Provider<T, N>,
609            N: alloy_contract::private::Network,
610        > BN254Instance<T, P, N>
611    {
612        /// Creates a new event filter using this contract instance's provider and address.
613        ///
614        /// Note that the type can be any event, not just those defined in this contract.
615        /// Prefer using the other methods for building type-safe event filters.
616        pub fn event_filter<E: alloy_sol_types::SolEvent>(
617            &self,
618        ) -> alloy_contract::Event<T, &P, E, N> {
619            alloy_contract::Event::new_sol(&self.provider, &self.address)
620        }
621    }
622}
623///Module containing a contract's types and functions.
624/**
625
626```solidity
627library EdOnBN254 {
628    struct EdOnBN254Point { uint256 x; uint256 y; }
629}
630```*/
631#[allow(
632    non_camel_case_types,
633    non_snake_case,
634    clippy::pub_underscore_fields,
635    clippy::style,
636    clippy::empty_structs_with_brackets
637)]
638pub mod EdOnBN254 {
639    use alloy::sol_types as alloy_sol_types;
640
641    use super::*;
642    #[derive(Default, Debug, PartialEq, Eq, Hash)]
643    /**```solidity
644    struct EdOnBN254Point { uint256 x; uint256 y; }
645    ```*/
646    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
647    #[derive(Clone)]
648    pub struct EdOnBN254Point {
649        #[allow(missing_docs)]
650        pub x: alloy::sol_types::private::primitives::aliases::U256,
651        #[allow(missing_docs)]
652        pub y: alloy::sol_types::private::primitives::aliases::U256,
653    }
654    #[allow(
655        non_camel_case_types,
656        non_snake_case,
657        clippy::pub_underscore_fields,
658        clippy::style
659    )]
660    const _: () = {
661        use alloy::sol_types as alloy_sol_types;
662        #[doc(hidden)]
663        type UnderlyingSolTuple<'a> = (
664            alloy::sol_types::sol_data::Uint<256>,
665            alloy::sol_types::sol_data::Uint<256>,
666        );
667        #[doc(hidden)]
668        type UnderlyingRustTuple<'a> = (
669            alloy::sol_types::private::primitives::aliases::U256,
670            alloy::sol_types::private::primitives::aliases::U256,
671        );
672        #[cfg(test)]
673        #[allow(dead_code, unreachable_patterns)]
674        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
675            match _t {
676                alloy_sol_types::private::AssertTypeEq::<
677                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
678                >(_) => {},
679            }
680        }
681        #[automatically_derived]
682        #[doc(hidden)]
683        impl ::core::convert::From<EdOnBN254Point> for UnderlyingRustTuple<'_> {
684            fn from(value: EdOnBN254Point) -> Self {
685                (value.x, value.y)
686            }
687        }
688        #[automatically_derived]
689        #[doc(hidden)]
690        impl ::core::convert::From<UnderlyingRustTuple<'_>> for EdOnBN254Point {
691            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
692                Self {
693                    x: tuple.0,
694                    y: tuple.1,
695                }
696            }
697        }
698        #[automatically_derived]
699        impl alloy_sol_types::SolValue for EdOnBN254Point {
700            type SolType = Self;
701        }
702        #[automatically_derived]
703        impl alloy_sol_types::private::SolTypeValue<Self> for EdOnBN254Point {
704            #[inline]
705            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
706                (
707                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
708                        &self.x,
709                    ),
710                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
711                        &self.y,
712                    ),
713                )
714            }
715            #[inline]
716            fn stv_abi_encoded_size(&self) -> usize {
717                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
718                    return size;
719                }
720                let tuple =
721                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
722                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
723            }
724            #[inline]
725            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
726                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
727            }
728            #[inline]
729            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
730                let tuple =
731                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
732                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
733                    &tuple, out,
734                )
735            }
736            #[inline]
737            fn stv_abi_packed_encoded_size(&self) -> usize {
738                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
739                    return size;
740                }
741                let tuple =
742                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
743                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
744                    &tuple,
745                )
746            }
747        }
748        #[automatically_derived]
749        impl alloy_sol_types::SolType for EdOnBN254Point {
750            type RustType = Self;
751            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
752            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
753            const ENCODED_SIZE: Option<usize> =
754                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
755            const PACKED_ENCODED_SIZE: Option<usize> =
756                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
757            #[inline]
758            fn valid_token(token: &Self::Token<'_>) -> bool {
759                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
760            }
761            #[inline]
762            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
763                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
764                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
765            }
766        }
767        #[automatically_derived]
768        impl alloy_sol_types::SolStruct for EdOnBN254Point {
769            const NAME: &'static str = "EdOnBN254Point";
770            #[inline]
771            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
772                alloy_sol_types::private::Cow::Borrowed("EdOnBN254Point(uint256 x,uint256 y)")
773            }
774            #[inline]
775            fn eip712_components(
776            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
777            {
778                alloy_sol_types::private::Vec::new()
779            }
780            #[inline]
781            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
782                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
783            }
784            #[inline]
785            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
786                [
787                    <alloy::sol_types::sol_data::Uint<
788                        256,
789                    > as alloy_sol_types::SolType>::eip712_data_word(&self.x)
790                        .0,
791                    <alloy::sol_types::sol_data::Uint<
792                        256,
793                    > as alloy_sol_types::SolType>::eip712_data_word(&self.y)
794                        .0,
795                ]
796                    .concat()
797            }
798        }
799        #[automatically_derived]
800        impl alloy_sol_types::EventTopic for EdOnBN254Point {
801            #[inline]
802            fn topic_preimage_length(rust: &Self::RustType) -> usize {
803                0usize
804                    + <alloy::sol_types::sol_data::Uint<
805                        256,
806                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.x)
807                    + <alloy::sol_types::sol_data::Uint<
808                        256,
809                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.y)
810            }
811            #[inline]
812            fn encode_topic_preimage(
813                rust: &Self::RustType,
814                out: &mut alloy_sol_types::private::Vec<u8>,
815            ) {
816                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
817                <alloy::sol_types::sol_data::Uint<
818                    256,
819                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.x, out);
820                <alloy::sol_types::sol_data::Uint<
821                    256,
822                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.y, out);
823            }
824            #[inline]
825            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
826                let mut out = alloy_sol_types::private::Vec::new();
827                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
828                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
829            }
830        }
831    };
832    use alloy::contract as alloy_contract;
833    /**Creates a new wrapper around an on-chain [`EdOnBN254`](self) contract instance.
834
835    See the [wrapper's documentation](`EdOnBN254Instance`) for more details.*/
836    #[inline]
837    pub const fn new<
838        T: alloy_contract::private::Transport + ::core::clone::Clone,
839        P: alloy_contract::private::Provider<T, N>,
840        N: alloy_contract::private::Network,
841    >(
842        address: alloy_sol_types::private::Address,
843        provider: P,
844    ) -> EdOnBN254Instance<T, P, N> {
845        EdOnBN254Instance::<T, P, N>::new(address, provider)
846    }
847    /**A [`EdOnBN254`](self) instance.
848
849    Contains type-safe methods for interacting with an on-chain instance of the
850    [`EdOnBN254`](self) contract located at a given `address`, using a given
851    provider `P`.
852
853    If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
854    documentation on how to provide it), the `deploy` and `deploy_builder` methods can
855    be used to deploy a new instance of the contract.
856
857    See the [module-level documentation](self) for all the available methods.*/
858    #[derive(Clone)]
859    pub struct EdOnBN254Instance<T, P, N = alloy_contract::private::Ethereum> {
860        address: alloy_sol_types::private::Address,
861        provider: P,
862        _network_transport: ::core::marker::PhantomData<(N, T)>,
863    }
864    #[automatically_derived]
865    impl<T, P, N> ::core::fmt::Debug for EdOnBN254Instance<T, P, N> {
866        #[inline]
867        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
868            f.debug_tuple("EdOnBN254Instance")
869                .field(&self.address)
870                .finish()
871        }
872    }
873    /// Instantiation and getters/setters.
874    #[automatically_derived]
875    impl<
876            T: alloy_contract::private::Transport + ::core::clone::Clone,
877            P: alloy_contract::private::Provider<T, N>,
878            N: alloy_contract::private::Network,
879        > EdOnBN254Instance<T, P, N>
880    {
881        /**Creates a new wrapper around an on-chain [`EdOnBN254`](self) contract instance.
882
883        See the [wrapper's documentation](`EdOnBN254Instance`) for more details.*/
884        #[inline]
885        pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
886            Self {
887                address,
888                provider,
889                _network_transport: ::core::marker::PhantomData,
890            }
891        }
892        /// Returns a reference to the address.
893        #[inline]
894        pub const fn address(&self) -> &alloy_sol_types::private::Address {
895            &self.address
896        }
897        /// Sets the address.
898        #[inline]
899        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
900            self.address = address;
901        }
902        /// Sets the address and returns `self`.
903        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
904            self.set_address(address);
905            self
906        }
907        /// Returns a reference to the provider.
908        #[inline]
909        pub const fn provider(&self) -> &P {
910            &self.provider
911        }
912    }
913    impl<T, P: ::core::clone::Clone, N> EdOnBN254Instance<T, &P, N> {
914        /// Clones the provider and returns a new instance with the cloned provider.
915        #[inline]
916        pub fn with_cloned_provider(self) -> EdOnBN254Instance<T, P, N> {
917            EdOnBN254Instance {
918                address: self.address,
919                provider: ::core::clone::Clone::clone(&self.provider),
920                _network_transport: ::core::marker::PhantomData,
921            }
922        }
923    }
924    /// Function calls.
925    #[automatically_derived]
926    impl<
927            T: alloy_contract::private::Transport + ::core::clone::Clone,
928            P: alloy_contract::private::Provider<T, N>,
929            N: alloy_contract::private::Network,
930        > EdOnBN254Instance<T, P, N>
931    {
932        /// Creates a new call builder using this contract instance's provider and address.
933        ///
934        /// Note that the call can be any function call, not just those defined in this
935        /// contract. Prefer using the other methods for building type-safe contract calls.
936        pub fn call_builder<C: alloy_sol_types::SolCall>(
937            &self,
938            call: &C,
939        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
940            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
941        }
942    }
943    /// Event filters.
944    #[automatically_derived]
945    impl<
946            T: alloy_contract::private::Transport + ::core::clone::Clone,
947            P: alloy_contract::private::Provider<T, N>,
948            N: alloy_contract::private::Network,
949        > EdOnBN254Instance<T, P, N>
950    {
951        /// Creates a new event filter using this contract instance's provider and address.
952        ///
953        /// Note that the type can be any event, not just those defined in this contract.
954        /// Prefer using the other methods for building type-safe event filters.
955        pub fn event_filter<E: alloy_sol_types::SolEvent>(
956            &self,
957        ) -> alloy_contract::Event<T, &P, E, N> {
958            alloy_contract::Event::new_sol(&self.provider, &self.address)
959        }
960    }
961}
962/**
963
964Generated by the following Solidity interface...
965```solidity
966library BN254 {
967    type BaseField is uint256;
968    struct G1Point {
969        BaseField x;
970        BaseField y;
971    }
972    struct G2Point {
973        BaseField x0;
974        BaseField x1;
975        BaseField y0;
976        BaseField y1;
977    }
978}
979
980library EdOnBN254 {
981    struct EdOnBN254Point {
982        uint256 x;
983        uint256 y;
984    }
985}
986
987interface StakeTable {
988    type ValidatorStatus is uint8;
989
990    error AddressEmptyCode(address target);
991    error BLSSigVerificationFailed();
992    error BlsKeyAlreadyUsed();
993    error ERC1967InvalidImplementation(address implementation);
994    error ERC1967NonPayable();
995    error FailedInnerCall();
996    error InsufficientAllowance(uint256, uint256);
997    error InsufficientBalance(uint256);
998    error InvalidCommission();
999    error InvalidInitialization();
1000    error InvalidSchnorrVK();
1001    error NotInitializing();
1002    error NothingToWithdraw();
1003    error OwnableInvalidOwner(address owner);
1004    error OwnableUnauthorizedAccount(address account);
1005    error PrematureWithdrawal();
1006    error UUPSUnauthorizedCallContext();
1007    error UUPSUnsupportedProxiableUUID(bytes32 slot);
1008    error UndelegationAlreadyExists();
1009    error ValidatorAlreadyExited();
1010    error ValidatorAlreadyRegistered();
1011    error ValidatorInactive();
1012    error ValidatorNotExited();
1013    error ZeroAddress();
1014    error ZeroAmount();
1015
1016    event ConsensusKeysUpdated(address indexed account, BN254.G2Point blsVK, EdOnBN254.EdOnBN254Point schnorrVK);
1017    event Delegated(address indexed delegator, address indexed validator, uint256 amount);
1018    event Initialized(uint64 version);
1019    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
1020    event Undelegated(address indexed delegator, address indexed validator, uint256 amount);
1021    event Upgrade(address implementation);
1022    event Upgraded(address indexed implementation);
1023    event ValidatorExit(address indexed validator);
1024    event ValidatorRegistered(address indexed account, BN254.G2Point blsVk, EdOnBN254.EdOnBN254Point schnorrVk, uint16 commission);
1025    event Withdrawal(address indexed account, uint256 amount);
1026
1027    constructor();
1028
1029    function UPGRADE_INTERFACE_VERSION() external view returns (string memory);
1030    function _hashBlsKey(BN254.G2Point memory blsVK) external pure returns (bytes32);
1031    function blsKeys(bytes32 blsKeyHash) external view returns (bool used);
1032    function claimValidatorExit(address validator) external;
1033    function claimWithdrawal(address validator) external;
1034    function delegate(address validator, uint256 amount) external;
1035    function delegations(address validator, address delegator) external view returns (uint256 amount);
1036    function deregisterValidator() external;
1037    function exitEscrowPeriod() external view returns (uint256);
1038    function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion);
1039    function initialize(address _tokenAddress, address _lightClientAddress, uint256 _exitEscrowPeriod, address _timelock) external;
1040    function initializedAtBlock() external view returns (uint256);
1041    function lightClient() external view returns (address);
1042    function owner() external view returns (address);
1043    function proxiableUUID() external view returns (bytes32);
1044    function registerValidator(BN254.G2Point memory blsVK, EdOnBN254.EdOnBN254Point memory schnorrVK, BN254.G1Point memory blsSig, uint16 commission) external;
1045    function renounceOwnership() external;
1046    function token() external view returns (address);
1047    function transferOwnership(address newOwner) external;
1048    function undelegate(address validator, uint256 amount) external;
1049    function undelegations(address validator, address delegator) external view returns (uint256 amount, uint256 unlocksAt);
1050    function updateConsensusKeys(BN254.G2Point memory newBlsVK, EdOnBN254.EdOnBN254Point memory newSchnorrVK, BN254.G1Point memory newBlsSig) external;
1051    function upgradeToAndCall(address newImplementation, bytes memory data) external payable;
1052    function validatorExits(address validator) external view returns (uint256 unlocksAt);
1053    function validators(address account) external view returns (uint256 delegatedAmount, ValidatorStatus status);
1054}
1055```
1056
1057...which was generated by the following JSON ABI:
1058```json
1059[
1060  {
1061    "type": "constructor",
1062    "inputs": [],
1063    "stateMutability": "nonpayable"
1064  },
1065  {
1066    "type": "function",
1067    "name": "UPGRADE_INTERFACE_VERSION",
1068    "inputs": [],
1069    "outputs": [
1070      {
1071        "name": "",
1072        "type": "string",
1073        "internalType": "string"
1074      }
1075    ],
1076    "stateMutability": "view"
1077  },
1078  {
1079    "type": "function",
1080    "name": "_hashBlsKey",
1081    "inputs": [
1082      {
1083        "name": "blsVK",
1084        "type": "tuple",
1085        "internalType": "struct BN254.G2Point",
1086        "components": [
1087          {
1088            "name": "x0",
1089            "type": "uint256",
1090            "internalType": "BN254.BaseField"
1091          },
1092          {
1093            "name": "x1",
1094            "type": "uint256",
1095            "internalType": "BN254.BaseField"
1096          },
1097          {
1098            "name": "y0",
1099            "type": "uint256",
1100            "internalType": "BN254.BaseField"
1101          },
1102          {
1103            "name": "y1",
1104            "type": "uint256",
1105            "internalType": "BN254.BaseField"
1106          }
1107        ]
1108      }
1109    ],
1110    "outputs": [
1111      {
1112        "name": "",
1113        "type": "bytes32",
1114        "internalType": "bytes32"
1115      }
1116    ],
1117    "stateMutability": "pure"
1118  },
1119  {
1120    "type": "function",
1121    "name": "blsKeys",
1122    "inputs": [
1123      {
1124        "name": "blsKeyHash",
1125        "type": "bytes32",
1126        "internalType": "bytes32"
1127      }
1128    ],
1129    "outputs": [
1130      {
1131        "name": "used",
1132        "type": "bool",
1133        "internalType": "bool"
1134      }
1135    ],
1136    "stateMutability": "view"
1137  },
1138  {
1139    "type": "function",
1140    "name": "claimValidatorExit",
1141    "inputs": [
1142      {
1143        "name": "validator",
1144        "type": "address",
1145        "internalType": "address"
1146      }
1147    ],
1148    "outputs": [],
1149    "stateMutability": "nonpayable"
1150  },
1151  {
1152    "type": "function",
1153    "name": "claimWithdrawal",
1154    "inputs": [
1155      {
1156        "name": "validator",
1157        "type": "address",
1158        "internalType": "address"
1159      }
1160    ],
1161    "outputs": [],
1162    "stateMutability": "nonpayable"
1163  },
1164  {
1165    "type": "function",
1166    "name": "delegate",
1167    "inputs": [
1168      {
1169        "name": "validator",
1170        "type": "address",
1171        "internalType": "address"
1172      },
1173      {
1174        "name": "amount",
1175        "type": "uint256",
1176        "internalType": "uint256"
1177      }
1178    ],
1179    "outputs": [],
1180    "stateMutability": "nonpayable"
1181  },
1182  {
1183    "type": "function",
1184    "name": "delegations",
1185    "inputs": [
1186      {
1187        "name": "validator",
1188        "type": "address",
1189        "internalType": "address"
1190      },
1191      {
1192        "name": "delegator",
1193        "type": "address",
1194        "internalType": "address"
1195      }
1196    ],
1197    "outputs": [
1198      {
1199        "name": "amount",
1200        "type": "uint256",
1201        "internalType": "uint256"
1202      }
1203    ],
1204    "stateMutability": "view"
1205  },
1206  {
1207    "type": "function",
1208    "name": "deregisterValidator",
1209    "inputs": [],
1210    "outputs": [],
1211    "stateMutability": "nonpayable"
1212  },
1213  {
1214    "type": "function",
1215    "name": "exitEscrowPeriod",
1216    "inputs": [],
1217    "outputs": [
1218      {
1219        "name": "",
1220        "type": "uint256",
1221        "internalType": "uint256"
1222      }
1223    ],
1224    "stateMutability": "view"
1225  },
1226  {
1227    "type": "function",
1228    "name": "getVersion",
1229    "inputs": [],
1230    "outputs": [
1231      {
1232        "name": "majorVersion",
1233        "type": "uint8",
1234        "internalType": "uint8"
1235      },
1236      {
1237        "name": "minorVersion",
1238        "type": "uint8",
1239        "internalType": "uint8"
1240      },
1241      {
1242        "name": "patchVersion",
1243        "type": "uint8",
1244        "internalType": "uint8"
1245      }
1246    ],
1247    "stateMutability": "pure"
1248  },
1249  {
1250    "type": "function",
1251    "name": "initialize",
1252    "inputs": [
1253      {
1254        "name": "_tokenAddress",
1255        "type": "address",
1256        "internalType": "address"
1257      },
1258      {
1259        "name": "_lightClientAddress",
1260        "type": "address",
1261        "internalType": "address"
1262      },
1263      {
1264        "name": "_exitEscrowPeriod",
1265        "type": "uint256",
1266        "internalType": "uint256"
1267      },
1268      {
1269        "name": "_timelock",
1270        "type": "address",
1271        "internalType": "address"
1272      }
1273    ],
1274    "outputs": [],
1275    "stateMutability": "nonpayable"
1276  },
1277  {
1278    "type": "function",
1279    "name": "initializedAtBlock",
1280    "inputs": [],
1281    "outputs": [
1282      {
1283        "name": "",
1284        "type": "uint256",
1285        "internalType": "uint256"
1286      }
1287    ],
1288    "stateMutability": "view"
1289  },
1290  {
1291    "type": "function",
1292    "name": "lightClient",
1293    "inputs": [],
1294    "outputs": [
1295      {
1296        "name": "",
1297        "type": "address",
1298        "internalType": "contract LightClientV2"
1299      }
1300    ],
1301    "stateMutability": "view"
1302  },
1303  {
1304    "type": "function",
1305    "name": "owner",
1306    "inputs": [],
1307    "outputs": [
1308      {
1309        "name": "",
1310        "type": "address",
1311        "internalType": "address"
1312      }
1313    ],
1314    "stateMutability": "view"
1315  },
1316  {
1317    "type": "function",
1318    "name": "proxiableUUID",
1319    "inputs": [],
1320    "outputs": [
1321      {
1322        "name": "",
1323        "type": "bytes32",
1324        "internalType": "bytes32"
1325      }
1326    ],
1327    "stateMutability": "view"
1328  },
1329  {
1330    "type": "function",
1331    "name": "registerValidator",
1332    "inputs": [
1333      {
1334        "name": "blsVK",
1335        "type": "tuple",
1336        "internalType": "struct BN254.G2Point",
1337        "components": [
1338          {
1339            "name": "x0",
1340            "type": "uint256",
1341            "internalType": "BN254.BaseField"
1342          },
1343          {
1344            "name": "x1",
1345            "type": "uint256",
1346            "internalType": "BN254.BaseField"
1347          },
1348          {
1349            "name": "y0",
1350            "type": "uint256",
1351            "internalType": "BN254.BaseField"
1352          },
1353          {
1354            "name": "y1",
1355            "type": "uint256",
1356            "internalType": "BN254.BaseField"
1357          }
1358        ]
1359      },
1360      {
1361        "name": "schnorrVK",
1362        "type": "tuple",
1363        "internalType": "struct EdOnBN254.EdOnBN254Point",
1364        "components": [
1365          {
1366            "name": "x",
1367            "type": "uint256",
1368            "internalType": "uint256"
1369          },
1370          {
1371            "name": "y",
1372            "type": "uint256",
1373            "internalType": "uint256"
1374          }
1375        ]
1376      },
1377      {
1378        "name": "blsSig",
1379        "type": "tuple",
1380        "internalType": "struct BN254.G1Point",
1381        "components": [
1382          {
1383            "name": "x",
1384            "type": "uint256",
1385            "internalType": "BN254.BaseField"
1386          },
1387          {
1388            "name": "y",
1389            "type": "uint256",
1390            "internalType": "BN254.BaseField"
1391          }
1392        ]
1393      },
1394      {
1395        "name": "commission",
1396        "type": "uint16",
1397        "internalType": "uint16"
1398      }
1399    ],
1400    "outputs": [],
1401    "stateMutability": "nonpayable"
1402  },
1403  {
1404    "type": "function",
1405    "name": "renounceOwnership",
1406    "inputs": [],
1407    "outputs": [],
1408    "stateMutability": "nonpayable"
1409  },
1410  {
1411    "type": "function",
1412    "name": "token",
1413    "inputs": [],
1414    "outputs": [
1415      {
1416        "name": "",
1417        "type": "address",
1418        "internalType": "contract ERC20"
1419      }
1420    ],
1421    "stateMutability": "view"
1422  },
1423  {
1424    "type": "function",
1425    "name": "transferOwnership",
1426    "inputs": [
1427      {
1428        "name": "newOwner",
1429        "type": "address",
1430        "internalType": "address"
1431      }
1432    ],
1433    "outputs": [],
1434    "stateMutability": "nonpayable"
1435  },
1436  {
1437    "type": "function",
1438    "name": "undelegate",
1439    "inputs": [
1440      {
1441        "name": "validator",
1442        "type": "address",
1443        "internalType": "address"
1444      },
1445      {
1446        "name": "amount",
1447        "type": "uint256",
1448        "internalType": "uint256"
1449      }
1450    ],
1451    "outputs": [],
1452    "stateMutability": "nonpayable"
1453  },
1454  {
1455    "type": "function",
1456    "name": "undelegations",
1457    "inputs": [
1458      {
1459        "name": "validator",
1460        "type": "address",
1461        "internalType": "address"
1462      },
1463      {
1464        "name": "delegator",
1465        "type": "address",
1466        "internalType": "address"
1467      }
1468    ],
1469    "outputs": [
1470      {
1471        "name": "amount",
1472        "type": "uint256",
1473        "internalType": "uint256"
1474      },
1475      {
1476        "name": "unlocksAt",
1477        "type": "uint256",
1478        "internalType": "uint256"
1479      }
1480    ],
1481    "stateMutability": "view"
1482  },
1483  {
1484    "type": "function",
1485    "name": "updateConsensusKeys",
1486    "inputs": [
1487      {
1488        "name": "newBlsVK",
1489        "type": "tuple",
1490        "internalType": "struct BN254.G2Point",
1491        "components": [
1492          {
1493            "name": "x0",
1494            "type": "uint256",
1495            "internalType": "BN254.BaseField"
1496          },
1497          {
1498            "name": "x1",
1499            "type": "uint256",
1500            "internalType": "BN254.BaseField"
1501          },
1502          {
1503            "name": "y0",
1504            "type": "uint256",
1505            "internalType": "BN254.BaseField"
1506          },
1507          {
1508            "name": "y1",
1509            "type": "uint256",
1510            "internalType": "BN254.BaseField"
1511          }
1512        ]
1513      },
1514      {
1515        "name": "newSchnorrVK",
1516        "type": "tuple",
1517        "internalType": "struct EdOnBN254.EdOnBN254Point",
1518        "components": [
1519          {
1520            "name": "x",
1521            "type": "uint256",
1522            "internalType": "uint256"
1523          },
1524          {
1525            "name": "y",
1526            "type": "uint256",
1527            "internalType": "uint256"
1528          }
1529        ]
1530      },
1531      {
1532        "name": "newBlsSig",
1533        "type": "tuple",
1534        "internalType": "struct BN254.G1Point",
1535        "components": [
1536          {
1537            "name": "x",
1538            "type": "uint256",
1539            "internalType": "BN254.BaseField"
1540          },
1541          {
1542            "name": "y",
1543            "type": "uint256",
1544            "internalType": "BN254.BaseField"
1545          }
1546        ]
1547      }
1548    ],
1549    "outputs": [],
1550    "stateMutability": "nonpayable"
1551  },
1552  {
1553    "type": "function",
1554    "name": "upgradeToAndCall",
1555    "inputs": [
1556      {
1557        "name": "newImplementation",
1558        "type": "address",
1559        "internalType": "address"
1560      },
1561      {
1562        "name": "data",
1563        "type": "bytes",
1564        "internalType": "bytes"
1565      }
1566    ],
1567    "outputs": [],
1568    "stateMutability": "payable"
1569  },
1570  {
1571    "type": "function",
1572    "name": "validatorExits",
1573    "inputs": [
1574      {
1575        "name": "validator",
1576        "type": "address",
1577        "internalType": "address"
1578      }
1579    ],
1580    "outputs": [
1581      {
1582        "name": "unlocksAt",
1583        "type": "uint256",
1584        "internalType": "uint256"
1585      }
1586    ],
1587    "stateMutability": "view"
1588  },
1589  {
1590    "type": "function",
1591    "name": "validators",
1592    "inputs": [
1593      {
1594        "name": "account",
1595        "type": "address",
1596        "internalType": "address"
1597      }
1598    ],
1599    "outputs": [
1600      {
1601        "name": "delegatedAmount",
1602        "type": "uint256",
1603        "internalType": "uint256"
1604      },
1605      {
1606        "name": "status",
1607        "type": "uint8",
1608        "internalType": "enum StakeTable.ValidatorStatus"
1609      }
1610    ],
1611    "stateMutability": "view"
1612  },
1613  {
1614    "type": "event",
1615    "name": "ConsensusKeysUpdated",
1616    "inputs": [
1617      {
1618        "name": "account",
1619        "type": "address",
1620        "indexed": true,
1621        "internalType": "address"
1622      },
1623      {
1624        "name": "blsVK",
1625        "type": "tuple",
1626        "indexed": false,
1627        "internalType": "struct BN254.G2Point",
1628        "components": [
1629          {
1630            "name": "x0",
1631            "type": "uint256",
1632            "internalType": "BN254.BaseField"
1633          },
1634          {
1635            "name": "x1",
1636            "type": "uint256",
1637            "internalType": "BN254.BaseField"
1638          },
1639          {
1640            "name": "y0",
1641            "type": "uint256",
1642            "internalType": "BN254.BaseField"
1643          },
1644          {
1645            "name": "y1",
1646            "type": "uint256",
1647            "internalType": "BN254.BaseField"
1648          }
1649        ]
1650      },
1651      {
1652        "name": "schnorrVK",
1653        "type": "tuple",
1654        "indexed": false,
1655        "internalType": "struct EdOnBN254.EdOnBN254Point",
1656        "components": [
1657          {
1658            "name": "x",
1659            "type": "uint256",
1660            "internalType": "uint256"
1661          },
1662          {
1663            "name": "y",
1664            "type": "uint256",
1665            "internalType": "uint256"
1666          }
1667        ]
1668      }
1669    ],
1670    "anonymous": false
1671  },
1672  {
1673    "type": "event",
1674    "name": "Delegated",
1675    "inputs": [
1676      {
1677        "name": "delegator",
1678        "type": "address",
1679        "indexed": true,
1680        "internalType": "address"
1681      },
1682      {
1683        "name": "validator",
1684        "type": "address",
1685        "indexed": true,
1686        "internalType": "address"
1687      },
1688      {
1689        "name": "amount",
1690        "type": "uint256",
1691        "indexed": false,
1692        "internalType": "uint256"
1693      }
1694    ],
1695    "anonymous": false
1696  },
1697  {
1698    "type": "event",
1699    "name": "Initialized",
1700    "inputs": [
1701      {
1702        "name": "version",
1703        "type": "uint64",
1704        "indexed": false,
1705        "internalType": "uint64"
1706      }
1707    ],
1708    "anonymous": false
1709  },
1710  {
1711    "type": "event",
1712    "name": "OwnershipTransferred",
1713    "inputs": [
1714      {
1715        "name": "previousOwner",
1716        "type": "address",
1717        "indexed": true,
1718        "internalType": "address"
1719      },
1720      {
1721        "name": "newOwner",
1722        "type": "address",
1723        "indexed": true,
1724        "internalType": "address"
1725      }
1726    ],
1727    "anonymous": false
1728  },
1729  {
1730    "type": "event",
1731    "name": "Undelegated",
1732    "inputs": [
1733      {
1734        "name": "delegator",
1735        "type": "address",
1736        "indexed": true,
1737        "internalType": "address"
1738      },
1739      {
1740        "name": "validator",
1741        "type": "address",
1742        "indexed": true,
1743        "internalType": "address"
1744      },
1745      {
1746        "name": "amount",
1747        "type": "uint256",
1748        "indexed": false,
1749        "internalType": "uint256"
1750      }
1751    ],
1752    "anonymous": false
1753  },
1754  {
1755    "type": "event",
1756    "name": "Upgrade",
1757    "inputs": [
1758      {
1759        "name": "implementation",
1760        "type": "address",
1761        "indexed": false,
1762        "internalType": "address"
1763      }
1764    ],
1765    "anonymous": false
1766  },
1767  {
1768    "type": "event",
1769    "name": "Upgraded",
1770    "inputs": [
1771      {
1772        "name": "implementation",
1773        "type": "address",
1774        "indexed": true,
1775        "internalType": "address"
1776      }
1777    ],
1778    "anonymous": false
1779  },
1780  {
1781    "type": "event",
1782    "name": "ValidatorExit",
1783    "inputs": [
1784      {
1785        "name": "validator",
1786        "type": "address",
1787        "indexed": true,
1788        "internalType": "address"
1789      }
1790    ],
1791    "anonymous": false
1792  },
1793  {
1794    "type": "event",
1795    "name": "ValidatorRegistered",
1796    "inputs": [
1797      {
1798        "name": "account",
1799        "type": "address",
1800        "indexed": true,
1801        "internalType": "address"
1802      },
1803      {
1804        "name": "blsVk",
1805        "type": "tuple",
1806        "indexed": false,
1807        "internalType": "struct BN254.G2Point",
1808        "components": [
1809          {
1810            "name": "x0",
1811            "type": "uint256",
1812            "internalType": "BN254.BaseField"
1813          },
1814          {
1815            "name": "x1",
1816            "type": "uint256",
1817            "internalType": "BN254.BaseField"
1818          },
1819          {
1820            "name": "y0",
1821            "type": "uint256",
1822            "internalType": "BN254.BaseField"
1823          },
1824          {
1825            "name": "y1",
1826            "type": "uint256",
1827            "internalType": "BN254.BaseField"
1828          }
1829        ]
1830      },
1831      {
1832        "name": "schnorrVk",
1833        "type": "tuple",
1834        "indexed": false,
1835        "internalType": "struct EdOnBN254.EdOnBN254Point",
1836        "components": [
1837          {
1838            "name": "x",
1839            "type": "uint256",
1840            "internalType": "uint256"
1841          },
1842          {
1843            "name": "y",
1844            "type": "uint256",
1845            "internalType": "uint256"
1846          }
1847        ]
1848      },
1849      {
1850        "name": "commission",
1851        "type": "uint16",
1852        "indexed": false,
1853        "internalType": "uint16"
1854      }
1855    ],
1856    "anonymous": false
1857  },
1858  {
1859    "type": "event",
1860    "name": "Withdrawal",
1861    "inputs": [
1862      {
1863        "name": "account",
1864        "type": "address",
1865        "indexed": true,
1866        "internalType": "address"
1867      },
1868      {
1869        "name": "amount",
1870        "type": "uint256",
1871        "indexed": false,
1872        "internalType": "uint256"
1873      }
1874    ],
1875    "anonymous": false
1876  },
1877  {
1878    "type": "error",
1879    "name": "AddressEmptyCode",
1880    "inputs": [
1881      {
1882        "name": "target",
1883        "type": "address",
1884        "internalType": "address"
1885      }
1886    ]
1887  },
1888  {
1889    "type": "error",
1890    "name": "BLSSigVerificationFailed",
1891    "inputs": []
1892  },
1893  {
1894    "type": "error",
1895    "name": "BlsKeyAlreadyUsed",
1896    "inputs": []
1897  },
1898  {
1899    "type": "error",
1900    "name": "ERC1967InvalidImplementation",
1901    "inputs": [
1902      {
1903        "name": "implementation",
1904        "type": "address",
1905        "internalType": "address"
1906      }
1907    ]
1908  },
1909  {
1910    "type": "error",
1911    "name": "ERC1967NonPayable",
1912    "inputs": []
1913  },
1914  {
1915    "type": "error",
1916    "name": "FailedInnerCall",
1917    "inputs": []
1918  },
1919  {
1920    "type": "error",
1921    "name": "InsufficientAllowance",
1922    "inputs": [
1923      {
1924        "name": "",
1925        "type": "uint256",
1926        "internalType": "uint256"
1927      },
1928      {
1929        "name": "",
1930        "type": "uint256",
1931        "internalType": "uint256"
1932      }
1933    ]
1934  },
1935  {
1936    "type": "error",
1937    "name": "InsufficientBalance",
1938    "inputs": [
1939      {
1940        "name": "",
1941        "type": "uint256",
1942        "internalType": "uint256"
1943      }
1944    ]
1945  },
1946  {
1947    "type": "error",
1948    "name": "InvalidCommission",
1949    "inputs": []
1950  },
1951  {
1952    "type": "error",
1953    "name": "InvalidInitialization",
1954    "inputs": []
1955  },
1956  {
1957    "type": "error",
1958    "name": "InvalidSchnorrVK",
1959    "inputs": []
1960  },
1961  {
1962    "type": "error",
1963    "name": "NotInitializing",
1964    "inputs": []
1965  },
1966  {
1967    "type": "error",
1968    "name": "NothingToWithdraw",
1969    "inputs": []
1970  },
1971  {
1972    "type": "error",
1973    "name": "OwnableInvalidOwner",
1974    "inputs": [
1975      {
1976        "name": "owner",
1977        "type": "address",
1978        "internalType": "address"
1979      }
1980    ]
1981  },
1982  {
1983    "type": "error",
1984    "name": "OwnableUnauthorizedAccount",
1985    "inputs": [
1986      {
1987        "name": "account",
1988        "type": "address",
1989        "internalType": "address"
1990      }
1991    ]
1992  },
1993  {
1994    "type": "error",
1995    "name": "PrematureWithdrawal",
1996    "inputs": []
1997  },
1998  {
1999    "type": "error",
2000    "name": "UUPSUnauthorizedCallContext",
2001    "inputs": []
2002  },
2003  {
2004    "type": "error",
2005    "name": "UUPSUnsupportedProxiableUUID",
2006    "inputs": [
2007      {
2008        "name": "slot",
2009        "type": "bytes32",
2010        "internalType": "bytes32"
2011      }
2012    ]
2013  },
2014  {
2015    "type": "error",
2016    "name": "UndelegationAlreadyExists",
2017    "inputs": []
2018  },
2019  {
2020    "type": "error",
2021    "name": "ValidatorAlreadyExited",
2022    "inputs": []
2023  },
2024  {
2025    "type": "error",
2026    "name": "ValidatorAlreadyRegistered",
2027    "inputs": []
2028  },
2029  {
2030    "type": "error",
2031    "name": "ValidatorInactive",
2032    "inputs": []
2033  },
2034  {
2035    "type": "error",
2036    "name": "ValidatorNotExited",
2037    "inputs": []
2038  },
2039  {
2040    "type": "error",
2041    "name": "ZeroAddress",
2042    "inputs": []
2043  },
2044  {
2045    "type": "error",
2046    "name": "ZeroAmount",
2047    "inputs": []
2048  }
2049]
2050```*/
2051#[allow(
2052    non_camel_case_types,
2053    non_snake_case,
2054    clippy::pub_underscore_fields,
2055    clippy::style,
2056    clippy::empty_structs_with_brackets
2057)]
2058pub mod StakeTable {
2059    use alloy::sol_types as alloy_sol_types;
2060
2061    use super::*;
2062    /// The creation / init bytecode of the contract.
2063    ///
2064    /// ```text
2065    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
2066    /// ```
2067    #[rustfmt::skip]
2068    #[allow(clippy::all)]
2069    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
2070        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*\xEBa\x01\x01_9_\x81\x81a\x12\xDA\x01R\x81\x81a\x13\x03\x01Ra\x14\x86\x01Ra*\xEB_\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#\xE9V[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%\x0FV[a\x06\xD4V[4\x80\x15a\x01\xE0W__\xFD[Pa\x01\x84a\x01\xEF6`\x04a%mV[a\x08gV[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#\xE9V[a\t\x88V[a\x01\x84a\x02C6`\x04a%\x86V[a\x0B\x89V[4\x80\x15a\x02SW__\xFD[Pa\x02\x08a\x0B\xA8V[4\x80\x15a\x02gW__\xFD[Pa\x01\x84a\x02v6`\x04a&+V[a\x0B\xC3V[4\x80\x15a\x02\x86W__\xFD[Pa\x01\x84a\x0C\x8CV[4\x80\x15a\x02\x9AW__\xFD[Pa\x01\x84a\r\x0EV[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&oV[a\r!V[4\x80\x15a\x03\x1DW__\xFD[Pa\x02\x08`\x08T\x81V[4\x80\x15a\x032W__\xFD[Pa\x03da\x03A6`\x04a&\x89V[`\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%mV[a\r{V[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&\xBAV[4\x80\x15a\x03\xE0W__\xFD[Pa\x04\x03a\x03\xEF6`\x04a&\xEFV[`\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%mV[`\x05` R_\x90\x81R`@\x90 T\x81V[4\x80\x15a\x04hW__\xFD[Pa\x01\x84a\x04w6`\x04a'\x06V[a\x0E\x8BV[4\x80\x15a\x04\x87W__\xFD[Pa\x02\x08a\x04\x966`\x04a&\x89V[`\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%mV[a\x0F\xB7V[4\x80\x15a\x04\xDCW__\xFD[Pa\x05\x06a\x04\xEB6`\x04a%mV[`\x03` R_\x90\x81R`@\x90 \x80T`\x01\x90\x91\x01T`\xFF\x16\x82V[`@Qa\x01\xAD\x92\x91\x90a'dV[4\x80\x15a\x05\x1FW__\xFD[P`\x02Ta\x02\xDB\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x05<\x82a\x0F\xF4V[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'\x94V[\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[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\x03` R`@\x81 \x80T\x85\x92\x90a\x06)\x90\x84\x90a'\xBFV[\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\x06d\x90\x84\x90a'\xBFV[\x90\x91UPP`\x02Ta\x06\x81\x90`\x01`\x01`\xA0\x1B\x03\x16\x830\x86a\x10CV[\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\xC6\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[3a\x06\xDE\x81a\x10\xE7V[a\x06\xE7\x84a\x114V[a\x06\xF0\x85a\x11oV[`@\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\x11\xABV[a'\x10\x83a\xFF\xFF\x16\x11\x15a\x07IW`@Qc\xDC\x81\xDB\x85`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x04_a\x07W\x89a\r!V[\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\x9EWa\x07\x9Ea'PV[\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\xE4Wa\x07\xE4a'PV[\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\xA1W`@Qcy)\x8AS`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80B\x10\x15a\x08\xC2W`@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\nW`@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\t?\x91\x16\x84\x83a\x12@V[\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\tz\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2PPPPV[a\t\x91\x82a\x0F\xF4V[3_\x82\x90\x03a\t\xB3W`@Qc\x1F* \x05`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x03` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\t\xE4Wa\t\xE4a'PV[\x03a\n\x02W`@Qc\xEA\xB4\xA9c`\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\nEW`@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\n\x8EW`@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\n\xC4\x90\x84\x90a'\xD2V[\x92PP\x81\x90UP`@Q\x80`@\x01`@R\x80\x84\x81R` \x01`\x08TBa\n\xEA\x91\x90a'\xBFV[\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\x0B=\x90\x84\x90a'\xD2V[\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\xC6\x91\x81R` \x01\x90V[a\x0B\x91a\x12\xCFV[a\x0B\x9A\x82a\x13sV[a\x0B\xA4\x82\x82a\x13\xBAV[PPV[_a\x0B\xB1a\x14{V[P_Q` a*\xBF_9_Q\x90_R\x90V[3a\x0B\xCD\x81a\x0F\xF4V[a\x0B\xD6\x83a\x114V[a\x0B\xDF\x84a\x11oV[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x83\x16` \x82\x01R_\x91\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90Pa\x0C\x11\x81\x84\x87a\x11\xABV[`\x01`\x04_a\x0C\x1F\x88a\r!V[\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\x0C}\x92\x91\x90a'\xE5V[`@Q\x80\x91\x03\x90\xA2PPPPPV[3a\x0C\x96\x81a\x0F\xF4V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x03` R`@\x90 `\x01\x01\x80T`\xFF\x19\x16`\x02\x17\x90U`\x08Ta\x0C\xC8\x90Ba'\xBFV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x81\x81R`\x05` R`@\x80\x82 \x93\x90\x93U\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\r\x16a\x14\xC4V[a\r\x1F_a\x15\x1FV[V[_\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\xC0W`@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\x0E\x08W`@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\x0EC\x91\x16\x83\x83a\x12@V[\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\x0E~\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\xD0WP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x0E\xECWP0;\x15[\x90P\x81\x15\x80\x15a\x0E\xFAWP\x80\x15[\x15a\x0F\x18W`@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\x0FBW\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x0FK\x86a\x15\x8FV[a\x0FSa\x15\xA0V[a\x0F[a\x15\xA8V[a\x0Ff\x89\x89\x89a\x16\xAEV[\x83\x15a\x0F\xACW\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\xBFa\x14\xC4V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x0F\xE8W`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x05\xF9V[a\x0F\xF1\x81a\x15\x1FV[PV[`\x01`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x03` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x10%Wa\x10%a'PV[\x14a\x0F\xF1W`@QcP\x8Ay?`\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\x9CWP\x83;\x15=\x17\x15[\x80a\x10\xE0W`@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\x16Wa\x11\x16a'PV[\x14a\x0F\xF1W`@Qc\x13.~\xFB`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\x11Q\x82\x82a\x171V[\x15a\x0B\xA4W`@Qc\x06\xCFC\x8F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04_a\x11{\x83a\r!V[\x81R` \x81\x01\x91\x90\x91R`@\x01_ T`\xFF\x16\x15a\x0F\xF1W`@Qb\xDA\x8AW`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x11\xB4\x82a\x17TV[_`@Q\x80``\x01`@R\x80`$\x81R` \x01a*{`$\x919\x90P_\x84\x82`@Q` \x01a\x11\xE4\x92\x91\x90a(6V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P_a\x11\xFF\x82a\x17\xEAV[\x90Pa\x12\x1C\x81\x85a\x12\x0F\x88a\x18\xD7V[a\x12\x17a\x19NV[a\x1A\x1BV[a\x128W`@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\x12\x8AWP\x82;\x15=\x17\x15[\x80a\x12\xC9W`@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\x13UWP\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\x13I_Q` a*\xBF_9_Q\x90_RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\r\x1FW`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x13{a\x14\xC4V[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01`@Q\x80\x91\x03\x90\xA1PV[\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\x14WP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x14\x11\x91\x81\x01\x90a'\x94V[`\x01[a\x14<W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x05\xF9V[_Q` a*\xBF_9_Q\x90_R\x81\x14a\x14lW`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x05\xF9V[a\x14v\x83\x83a\x1A\xF9V[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\r\x1FW`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3a\x14\xF6\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\r\x1FW`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x05\xF9V[\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[a\x15\x97a\x1BNV[a\x0F\xF1\x81a\x1B\x97V[a\r\x1Fa\x1BNV[\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\x15\xEDWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x16\tWP0;\x15[\x90P\x81\x15\x80\x15a\x16\x17WP\x80\x15[\x15a\x165W`@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\xE0W\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\xD5W`@Qc\xD9.#=`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x16\xFCW`@Qc\xD9.#=`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x80T`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`\x01`\x01`\xA0\x1B\x03\x19\x91\x82\x16\x17\x90\x91U`\x01\x80T\x93\x90\x94\x16\x92\x16\x91\x90\x91\x17\x90\x91U`\x08UV[\x80Q\x82Q_\x91\x14\x80\x15a\x17KWP\x81` \x01Q\x83` \x01Q\x14[\x90P[\x92\x91PPV[\x80Q` \x82\x01Q_\x91_Q` a*\x9F_9_Q\x90_R\x91\x15\x90\x15\x16\x15a\x17zWPPPV[\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\x14vW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FBn254: invalid G1 point\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05\xF9V[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R_a\x18\x07\x83a\x1B\x9FV[\x90P_Q` a*\x9F_9_Q\x90_R`\x03_\x82\x84\x85\t\x90P\x82\x80a\x18.Wa\x18.a(RV[\x84\x82\t\x90P\x82\x80a\x18AWa\x18Aa(RV[\x82\x82\x08\x90P__a\x18Q\x83a\x1D\xA8V[\x92P\x90P[\x80a\x18\xBAW\x84\x80a\x18iWa\x18ia(RV[`\x01\x87\x08\x95P\x84\x80a\x18}Wa\x18}a(RV[\x86\x87\t\x92P\x84\x80a\x18\x90Wa\x18\x90a(RV[\x86\x84\t\x92P\x84\x80a\x18\xA3Wa\x18\xA3a(RV[\x84\x84\x08\x92Pa\x18\xB1\x83a\x1D\xA8V[\x92P\x90Pa\x18VV[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\x18\xFEWP\x90V[`@Q\x80`@\x01`@R\x80\x83_\x01Q\x81R` \x01_Q` a*\x9F_9_Q\x90_R\x84` \x01Qa\x19/\x91\x90a(fV[a\x19F\x90_Q` a*\x9F_9_Q\x90_Ra'\xD2V[\x90R\x92\x91PPV[a\x19u`@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\x1A\xEDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FBn254: Pairing check failed!\0\0\0\0`D\x82\x01R`d\x01a\x05\xF9V[P\x15\x15\x95\x94PPPPPV[a\x1B\x02\x82a\x1E\x9FV[`@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\x1BFWa\x14v\x82\x82a\x1F\x02V[a\x0B\xA4a\x1FtV[\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\r\x1FW`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0F\xBFa\x1BNV[__a\x1B\xAA\x83a\x1F\x93V[\x80Q\x90\x91P`0\x81\x14a\x1B\xBFWa\x1B\xBFa(\x85V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xD9Wa\x1B\xD9a$\x11V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1C\x03W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_[\x82\x81\x10\x15a\x1CrW\x83`\x01a\x1C\x1D\x83\x86a'\xD2V[a\x1C'\x91\x90a'\xD2V[\x81Q\x81\x10a\x1C7Wa\x1C7a(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x82\x82\x81Q\x81\x10a\x1CTWa\x1CTa(\x99V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a\x1C\x08V[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\x1D\x02W\x83\x81a\x1C\xAE\x85\x88a'\xD2V[a\x1C\xB8\x91\x90a'\xBFV[\x81Q\x81\x10a\x1C\xC8Wa\x1C\xC8a(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B`\xF8\x1C\x82\x82\x81Q\x81\x10a\x1C\xE8Wa\x1C\xE8a(\x99V[`\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a\x1C\x9AV[P_a\x1D\r\x82a\"\xDFV[\x90Pa\x01\0_Q` a*\x9F_9_Q\x90_R_a\x1D+\x86\x89a'\xD2V[\x90P_[\x81\x81\x10\x15a\x1D\x98W_\x88`\x01a\x1DE\x84\x86a'\xD2V[a\x1DO\x91\x90a'\xD2V[\x81Q\x81\x10a\x1D_Wa\x1D_a(\x99V[\x01` \x01Q`\xF8\x1C\x90P\x83\x80a\x1DwWa\x1Dwa(RV[\x85\x87\t\x95P\x83\x80a\x1D\x8AWa\x1D\x8Aa(RV[\x81\x87\x08\x95PP`\x01\x01a\x1D/V[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*\x9F_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\x1EeW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7Fpow precompile call failed!\0\0\0\0\0`D\x82\x01R`d\x01a\x05\xF9V[\x80`\x01\x84\x90\x1B\x11\x15a\x1E~Wa\x1E{\x83\x82a'\xD2V[\x92P[\x80\x80a\x1E\x8CWa\x1E\x8Ca(RV[\x83\x84\t\x96\x90\x96\x14\x96\x91\x95P\x90\x93PPPPV[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x1E\xD4W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x05\xF9V[_Q` a*\xBF_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\x1E\x91\x90a(\xADV[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x1FVW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x1F[V[``\x91P[P\x91P\x91Pa\x1Fk\x85\x83\x83a#FV[\x95\x94PPPPPV[4\x15a\r\x1FW`@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\xD3\x92\x91\x90a(6V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P\x80\x84`\xF8\x1B`@Q` \x01a\x1F\xFA\x92\x91\x90a(\xB8V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P\x80`@Q` \x01a \x1C\x91\x90a(\xE2V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90R\x91Pa\x01\x01`\xF0\x1B\x90a F\x90\x83\x90\x83\x90` \x01a(\xFAV[`@\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 \xB6Wa \xB6a$\x11V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a \xE0W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_\x82`@Q` \x01a \xF7\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x90P_[\x81Q\x81\x10\x15a!aW\x81\x81\x81Q\x81\x10a!&Wa!&a(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x83\x82\x81Q\x81\x10a!CWa!Ca(\x99V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a!\x0BV[P_\x84`@Q` \x01a!v\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\"\x08W_\x83\x82\x81Q\x81\x10a!\xAFWa!\xAFa(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x83\x83\x81Q\x81\x10a!\xCCWa!\xCCa(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x18\x90P\x88\x81`@Q` \x01a!\xED\x92\x91\x90a)\x1EV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x98PP`\x01\x01a!\x94V[P\x86\x88\x87`@Q` \x01a\"\x1E\x93\x92\x91\x90a)BV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x96P\x86\x80Q\x90` \x01 \x93P\x83`@Q` \x01a\"L\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x91P_[a\"m\x8A`\xFF\x8D\x16a'\xD2V[\x81\x10\x15a\"\xCEW\x82\x81\x81Q\x81\x10a\"\x86Wa\"\x86a(\x99V[\x01` \x01Q`\x01`\x01`\xF8\x1B\x03\x19\x16\x84a\"\xA0\x83\x8Da'\xBFV[\x81Q\x81\x10a\"\xB0Wa\"\xB0a(\x99V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a\"`V[P\x91\x9B\x9APPPPPPPPPPPV[_\x80\x80[\x83Q\x81\x10\x15a#?W\x83\x81\x81Q\x81\x10a\"\xFEWa\"\xFEa(\x99V[` \x02` \x01\x01Q`\xFF\x16\x81`\x08a#\x16\x91\x90a)uV[a#!\x90`\x02a*oV[a#+\x91\x90a)uV[a#5\x90\x83a'\xBFV[\x91P`\x01\x01a\"\xE3V[P\x92\x91PPV[``\x82a#[Wa#V\x82a#\xA5V[a#\x9EV[\x81Q\x15\x80\x15a#rWP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a#\x9BW`@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#\xB5W\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#\xE4W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a#\xFAW__\xFD[a$\x03\x83a#\xCEV[\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$HWa$Ha$\x11V[`@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$wWa$wa$\x11V[`@R\x91\x90PV[_`\x80\x82\x84\x03\x12\x15a$\x8FW__\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a$\xB2Wa$\xB2a$\x11V[`@\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$\xF0W__\xFD[a$\xF8a$%V[\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[____a\x01 \x85\x87\x03\x12\x15a%#W__\xFD[a%-\x86\x86a$\x7FV[\x93Pa%<\x86`\x80\x87\x01a$\xE0V[\x92Pa%K\x86`\xC0\x87\x01a$\xE0V[\x91Pa\x01\0\x85\x015a\xFF\xFF\x81\x16\x81\x14a%bW__\xFD[\x93\x96\x92\x95P\x90\x93PPV[_` \x82\x84\x03\x12\x15a%}W__\xFD[a\x17K\x82a#\xCEV[__`@\x83\x85\x03\x12\x15a%\x97W__\xFD[a%\xA0\x83a#\xCEV[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%\xBBW__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a%\xCBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%\xE5Wa%\xE5a$\x11V[a%\xF8`\x1F\x82\x01`\x1F\x19\x16` \x01a$NV[\x81\x81R\x86` \x83\x85\x01\x01\x11\x15a&\x0CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92\x90PV[___a\x01\0\x84\x86\x03\x12\x15a&>W__\xFD[a&H\x85\x85a$\x7FV[\x92Pa&W\x85`\x80\x86\x01a$\xE0V[\x91Pa&f\x85`\xC0\x86\x01a$\xE0V[\x90P\x92P\x92P\x92V[_`\x80\x82\x84\x03\x12\x15a&\x7FW__\xFD[a\x17K\x83\x83a$\x7FV[__`@\x83\x85\x03\x12\x15a&\x9AW__\xFD[a&\xA3\x83a#\xCEV[\x91Pa&\xB1` \x84\x01a#\xCEV[\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&\xFFW__\xFD[P5\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a'\x19W__\xFD[a'\"\x85a#\xCEV[\x93Pa'0` \x86\x01a#\xCEV[\x92P`@\x85\x015\x91Pa'E``\x86\x01a#\xCEV[\x90P\x92\x95\x91\x94P\x92PV[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x82\x81R`@\x81\x01`\x03\x83\x10a'\x87WcNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x82` \x83\x01R\x93\x92PPPV[_` \x82\x84\x03\x12\x15a'\xA4W__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x17NWa\x17Na'\xABV[\x81\x81\x03\x81\x81\x11\x15a\x17NWa\x17Na'\xABV[\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#\x9EV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a(Ja(D\x83\x86a(\x1FV[\x84a(\x1FV[\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a(\x80WcNH{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\x17K\x82\x84a(\x1FV[_a(\xC3\x82\x85a(\x1FV[_\x81R`\x01`\x01`\xF8\x1B\x03\x19\x93\x90\x93\x16`\x01\x84\x01RPP`\x02\x01\x91\x90PV[_a(\xED\x82\x84a(\x1FV[_\x81R`\x01\x01\x93\x92PPPV[_a)\x05\x82\x85a(\x1FV[`\x01`\x01`\xF0\x1B\x03\x19\x93\x90\x93\x16\x83RPP`\x02\x01\x91\x90PV[_a))\x82\x85a(\x1FV[`\x01`\x01`\xF8\x1B\x03\x19\x93\x90\x93\x16\x83RPP`\x01\x01\x91\x90PV[_a)M\x82\x86a(\x1FV[`\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\x17NWa\x17Na'\xABV[`\x01\x81[`\x01\x84\x11\x15a)\xC7W\x80\x85\x04\x81\x11\x15a)\xABWa)\xABa'\xABV[`\x01\x84\x16\x15a)\xB9W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a)\x90V[\x93P\x93\x91PPV[_\x82a)\xDDWP`\x01a\x17NV[\x81a)\xE9WP_a\x17NV[\x81`\x01\x81\x14a)\xFFW`\x02\x81\x14a*\tWa*%V[`\x01\x91PPa\x17NV[`\xFF\x84\x11\x15a*\x1AWa*\x1Aa'\xABV[PP`\x01\x82\x1Ba\x17NV[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a*HWP\x81\x81\na\x17NV[a*T_\x19\x84\x84a)\x8CV[\x80_\x19\x04\x82\x11\x15a*gWa*ga'\xABV[\x02\x93\x92PPPV[_a\x17K\x83\x83a)\xCFV\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\x1C\0\n",
2071    );
2072    /// The runtime bytecode of the contract, as deployed on the network.
2073    ///
2074    /// ```text
2075    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
2076    /// ```
2077    #[rustfmt::skip]
2078    #[allow(clippy::all)]
2079    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
2080        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#\xE9V[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%\x0FV[a\x06\xD4V[4\x80\x15a\x01\xE0W__\xFD[Pa\x01\x84a\x01\xEF6`\x04a%mV[a\x08gV[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#\xE9V[a\t\x88V[a\x01\x84a\x02C6`\x04a%\x86V[a\x0B\x89V[4\x80\x15a\x02SW__\xFD[Pa\x02\x08a\x0B\xA8V[4\x80\x15a\x02gW__\xFD[Pa\x01\x84a\x02v6`\x04a&+V[a\x0B\xC3V[4\x80\x15a\x02\x86W__\xFD[Pa\x01\x84a\x0C\x8CV[4\x80\x15a\x02\x9AW__\xFD[Pa\x01\x84a\r\x0EV[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&oV[a\r!V[4\x80\x15a\x03\x1DW__\xFD[Pa\x02\x08`\x08T\x81V[4\x80\x15a\x032W__\xFD[Pa\x03da\x03A6`\x04a&\x89V[`\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%mV[a\r{V[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&\xBAV[4\x80\x15a\x03\xE0W__\xFD[Pa\x04\x03a\x03\xEF6`\x04a&\xEFV[`\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%mV[`\x05` R_\x90\x81R`@\x90 T\x81V[4\x80\x15a\x04hW__\xFD[Pa\x01\x84a\x04w6`\x04a'\x06V[a\x0E\x8BV[4\x80\x15a\x04\x87W__\xFD[Pa\x02\x08a\x04\x966`\x04a&\x89V[`\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%mV[a\x0F\xB7V[4\x80\x15a\x04\xDCW__\xFD[Pa\x05\x06a\x04\xEB6`\x04a%mV[`\x03` R_\x90\x81R`@\x90 \x80T`\x01\x90\x91\x01T`\xFF\x16\x82V[`@Qa\x01\xAD\x92\x91\x90a'dV[4\x80\x15a\x05\x1FW__\xFD[P`\x02Ta\x02\xDB\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[a\x05<\x82a\x0F\xF4V[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'\x94V[\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[`\x01`\x01`\xA0\x1B\x03\x84\x16_\x90\x81R`\x03` R`@\x81 \x80T\x85\x92\x90a\x06)\x90\x84\x90a'\xBFV[\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\x06d\x90\x84\x90a'\xBFV[\x90\x91UPP`\x02Ta\x06\x81\x90`\x01`\x01`\xA0\x1B\x03\x16\x830\x86a\x10CV[\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\xC6\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[3a\x06\xDE\x81a\x10\xE7V[a\x06\xE7\x84a\x114V[a\x06\xF0\x85a\x11oV[`@\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\x11\xABV[a'\x10\x83a\xFF\xFF\x16\x11\x15a\x07IW`@Qc\xDC\x81\xDB\x85`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x04_a\x07W\x89a\r!V[\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\x9EWa\x07\x9Ea'PV[\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\xE4Wa\x07\xE4a'PV[\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\xA1W`@Qcy)\x8AS`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80B\x10\x15a\x08\xC2W`@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\nW`@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\t?\x91\x16\x84\x83a\x12@V[\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\tz\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2PPPPV[a\t\x91\x82a\x0F\xF4V[3_\x82\x90\x03a\t\xB3W`@Qc\x1F* \x05`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x03` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\t\xE4Wa\t\xE4a'PV[\x03a\n\x02W`@Qc\xEA\xB4\xA9c`\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\nEW`@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\n\x8EW`@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\n\xC4\x90\x84\x90a'\xD2V[\x92PP\x81\x90UP`@Q\x80`@\x01`@R\x80\x84\x81R` \x01`\x08TBa\n\xEA\x91\x90a'\xBFV[\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\x0B=\x90\x84\x90a'\xD2V[\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\xC6\x91\x81R` \x01\x90V[a\x0B\x91a\x12\xCFV[a\x0B\x9A\x82a\x13sV[a\x0B\xA4\x82\x82a\x13\xBAV[PPV[_a\x0B\xB1a\x14{V[P_Q` a*\xBF_9_Q\x90_R\x90V[3a\x0B\xCD\x81a\x0F\xF4V[a\x0B\xD6\x83a\x114V[a\x0B\xDF\x84a\x11oV[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x83\x16` \x82\x01R_\x91\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90Pa\x0C\x11\x81\x84\x87a\x11\xABV[`\x01`\x04_a\x0C\x1F\x88a\r!V[\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\x0C}\x92\x91\x90a'\xE5V[`@Q\x80\x91\x03\x90\xA2PPPPPV[3a\x0C\x96\x81a\x0F\xF4V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x03` R`@\x90 `\x01\x01\x80T`\xFF\x19\x16`\x02\x17\x90U`\x08Ta\x0C\xC8\x90Ba'\xBFV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x81\x81R`\x05` R`@\x80\x82 \x93\x90\x93U\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\r\x16a\x14\xC4V[a\r\x1F_a\x15\x1FV[V[_\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\xC0W`@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\x0E\x08W`@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\x0EC\x91\x16\x83\x83a\x12@V[\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\x0E~\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\xD0WP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x0E\xECWP0;\x15[\x90P\x81\x15\x80\x15a\x0E\xFAWP\x80\x15[\x15a\x0F\x18W`@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\x0FBW\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x0FK\x86a\x15\x8FV[a\x0FSa\x15\xA0V[a\x0F[a\x15\xA8V[a\x0Ff\x89\x89\x89a\x16\xAEV[\x83\x15a\x0F\xACW\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\xBFa\x14\xC4V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x0F\xE8W`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01a\x05\xF9V[a\x0F\xF1\x81a\x15\x1FV[PV[`\x01`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x03` R`@\x90 `\x01\x01T`\xFF\x16`\x02\x81\x11\x15a\x10%Wa\x10%a'PV[\x14a\x0F\xF1W`@QcP\x8Ay?`\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\x9CWP\x83;\x15=\x17\x15[\x80a\x10\xE0W`@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\x16Wa\x11\x16a'PV[\x14a\x0F\xF1W`@Qc\x13.~\xFB`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\x11Q\x82\x82a\x171V[\x15a\x0B\xA4W`@Qc\x06\xCFC\x8F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04_a\x11{\x83a\r!V[\x81R` \x81\x01\x91\x90\x91R`@\x01_ T`\xFF\x16\x15a\x0F\xF1W`@Qb\xDA\x8AW`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x11\xB4\x82a\x17TV[_`@Q\x80``\x01`@R\x80`$\x81R` \x01a*{`$\x919\x90P_\x84\x82`@Q` \x01a\x11\xE4\x92\x91\x90a(6V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P_a\x11\xFF\x82a\x17\xEAV[\x90Pa\x12\x1C\x81\x85a\x12\x0F\x88a\x18\xD7V[a\x12\x17a\x19NV[a\x1A\x1BV[a\x128W`@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\x12\x8AWP\x82;\x15=\x17\x15[\x80a\x12\xC9W`@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\x13UWP\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\x13I_Q` a*\xBF_9_Q\x90_RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\r\x1FW`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x13{a\x14\xC4V[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01`@Q\x80\x91\x03\x90\xA1PV[\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\x14WP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x14\x11\x91\x81\x01\x90a'\x94V[`\x01[a\x14<W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x05\xF9V[_Q` a*\xBF_9_Q\x90_R\x81\x14a\x14lW`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x05\xF9V[a\x14v\x83\x83a\x1A\xF9V[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\r\x1FW`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3a\x14\xF6\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\r\x1FW`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x05\xF9V[\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[a\x15\x97a\x1BNV[a\x0F\xF1\x81a\x1B\x97V[a\r\x1Fa\x1BNV[\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\x15\xEDWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x16\tWP0;\x15[\x90P\x81\x15\x80\x15a\x16\x17WP\x80\x15[\x15a\x165W`@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\xE0W\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\xD5W`@Qc\xD9.#=`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x16\xFCW`@Qc\xD9.#=`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x80T`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`\x01`\x01`\xA0\x1B\x03\x19\x91\x82\x16\x17\x90\x91U`\x01\x80T\x93\x90\x94\x16\x92\x16\x91\x90\x91\x17\x90\x91U`\x08UV[\x80Q\x82Q_\x91\x14\x80\x15a\x17KWP\x81` \x01Q\x83` \x01Q\x14[\x90P[\x92\x91PPV[\x80Q` \x82\x01Q_\x91_Q` a*\x9F_9_Q\x90_R\x91\x15\x90\x15\x16\x15a\x17zWPPPV[\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\x14vW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FBn254: invalid G1 point\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05\xF9V[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R_a\x18\x07\x83a\x1B\x9FV[\x90P_Q` a*\x9F_9_Q\x90_R`\x03_\x82\x84\x85\t\x90P\x82\x80a\x18.Wa\x18.a(RV[\x84\x82\t\x90P\x82\x80a\x18AWa\x18Aa(RV[\x82\x82\x08\x90P__a\x18Q\x83a\x1D\xA8V[\x92P\x90P[\x80a\x18\xBAW\x84\x80a\x18iWa\x18ia(RV[`\x01\x87\x08\x95P\x84\x80a\x18}Wa\x18}a(RV[\x86\x87\t\x92P\x84\x80a\x18\x90Wa\x18\x90a(RV[\x86\x84\t\x92P\x84\x80a\x18\xA3Wa\x18\xA3a(RV[\x84\x84\x08\x92Pa\x18\xB1\x83a\x1D\xA8V[\x92P\x90Pa\x18VV[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\x18\xFEWP\x90V[`@Q\x80`@\x01`@R\x80\x83_\x01Q\x81R` \x01_Q` a*\x9F_9_Q\x90_R\x84` \x01Qa\x19/\x91\x90a(fV[a\x19F\x90_Q` a*\x9F_9_Q\x90_Ra'\xD2V[\x90R\x92\x91PPV[a\x19u`@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\x1A\xEDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FBn254: Pairing check failed!\0\0\0\0`D\x82\x01R`d\x01a\x05\xF9V[P\x15\x15\x95\x94PPPPPV[a\x1B\x02\x82a\x1E\x9FV[`@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\x1BFWa\x14v\x82\x82a\x1F\x02V[a\x0B\xA4a\x1FtV[\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\r\x1FW`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0F\xBFa\x1BNV[__a\x1B\xAA\x83a\x1F\x93V[\x80Q\x90\x91P`0\x81\x14a\x1B\xBFWa\x1B\xBFa(\x85V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xD9Wa\x1B\xD9a$\x11V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1C\x03W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_[\x82\x81\x10\x15a\x1CrW\x83`\x01a\x1C\x1D\x83\x86a'\xD2V[a\x1C'\x91\x90a'\xD2V[\x81Q\x81\x10a\x1C7Wa\x1C7a(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x82\x82\x81Q\x81\x10a\x1CTWa\x1CTa(\x99V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a\x1C\x08V[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\x1D\x02W\x83\x81a\x1C\xAE\x85\x88a'\xD2V[a\x1C\xB8\x91\x90a'\xBFV[\x81Q\x81\x10a\x1C\xC8Wa\x1C\xC8a(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B`\xF8\x1C\x82\x82\x81Q\x81\x10a\x1C\xE8Wa\x1C\xE8a(\x99V[`\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a\x1C\x9AV[P_a\x1D\r\x82a\"\xDFV[\x90Pa\x01\0_Q` a*\x9F_9_Q\x90_R_a\x1D+\x86\x89a'\xD2V[\x90P_[\x81\x81\x10\x15a\x1D\x98W_\x88`\x01a\x1DE\x84\x86a'\xD2V[a\x1DO\x91\x90a'\xD2V[\x81Q\x81\x10a\x1D_Wa\x1D_a(\x99V[\x01` \x01Q`\xF8\x1C\x90P\x83\x80a\x1DwWa\x1Dwa(RV[\x85\x87\t\x95P\x83\x80a\x1D\x8AWa\x1D\x8Aa(RV[\x81\x87\x08\x95PP`\x01\x01a\x1D/V[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*\x9F_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\x1EeW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7Fpow precompile call failed!\0\0\0\0\0`D\x82\x01R`d\x01a\x05\xF9V[\x80`\x01\x84\x90\x1B\x11\x15a\x1E~Wa\x1E{\x83\x82a'\xD2V[\x92P[\x80\x80a\x1E\x8CWa\x1E\x8Ca(RV[\x83\x84\t\x96\x90\x96\x14\x96\x91\x95P\x90\x93PPPPV[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x1E\xD4W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x05\xF9V[_Q` a*\xBF_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\x1E\x91\x90a(\xADV[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x1FVW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x1F[V[``\x91P[P\x91P\x91Pa\x1Fk\x85\x83\x83a#FV[\x95\x94PPPPPV[4\x15a\r\x1FW`@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\xD3\x92\x91\x90a(6V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P\x80\x84`\xF8\x1B`@Q` \x01a\x1F\xFA\x92\x91\x90a(\xB8V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P\x80`@Q` \x01a \x1C\x91\x90a(\xE2V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90R\x91Pa\x01\x01`\xF0\x1B\x90a F\x90\x83\x90\x83\x90` \x01a(\xFAV[`@\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 \xB6Wa \xB6a$\x11V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a \xE0W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P_\x82`@Q` \x01a \xF7\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x90P_[\x81Q\x81\x10\x15a!aW\x81\x81\x81Q\x81\x10a!&Wa!&a(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x83\x82\x81Q\x81\x10a!CWa!Ca(\x99V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a!\x0BV[P_\x84`@Q` \x01a!v\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\"\x08W_\x83\x82\x81Q\x81\x10a!\xAFWa!\xAFa(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x83\x83\x81Q\x81\x10a!\xCCWa!\xCCa(\x99V[` \x01\x01Q`\xF8\x1C`\xF8\x1B\x18\x90P\x88\x81`@Q` \x01a!\xED\x92\x91\x90a)\x1EV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x98PP`\x01\x01a!\x94V[P\x86\x88\x87`@Q` \x01a\"\x1E\x93\x92\x91\x90a)BV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x96P\x86\x80Q\x90` \x01 \x93P\x83`@Q` \x01a\"L\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x91P_[a\"m\x8A`\xFF\x8D\x16a'\xD2V[\x81\x10\x15a\"\xCEW\x82\x81\x81Q\x81\x10a\"\x86Wa\"\x86a(\x99V[\x01` \x01Q`\x01`\x01`\xF8\x1B\x03\x19\x16\x84a\"\xA0\x83\x8Da'\xBFV[\x81Q\x81\x10a\"\xB0Wa\"\xB0a(\x99V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SP`\x01\x01a\"`V[P\x91\x9B\x9APPPPPPPPPPPV[_\x80\x80[\x83Q\x81\x10\x15a#?W\x83\x81\x81Q\x81\x10a\"\xFEWa\"\xFEa(\x99V[` \x02` \x01\x01Q`\xFF\x16\x81`\x08a#\x16\x91\x90a)uV[a#!\x90`\x02a*oV[a#+\x91\x90a)uV[a#5\x90\x83a'\xBFV[\x91P`\x01\x01a\"\xE3V[P\x92\x91PPV[``\x82a#[Wa#V\x82a#\xA5V[a#\x9EV[\x81Q\x15\x80\x15a#rWP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a#\x9BW`@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#\xB5W\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#\xE4W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a#\xFAW__\xFD[a$\x03\x83a#\xCEV[\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$HWa$Ha$\x11V[`@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$wWa$wa$\x11V[`@R\x91\x90PV[_`\x80\x82\x84\x03\x12\x15a$\x8FW__\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a$\xB2Wa$\xB2a$\x11V[`@\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$\xF0W__\xFD[a$\xF8a$%V[\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[____a\x01 \x85\x87\x03\x12\x15a%#W__\xFD[a%-\x86\x86a$\x7FV[\x93Pa%<\x86`\x80\x87\x01a$\xE0V[\x92Pa%K\x86`\xC0\x87\x01a$\xE0V[\x91Pa\x01\0\x85\x015a\xFF\xFF\x81\x16\x81\x14a%bW__\xFD[\x93\x96\x92\x95P\x90\x93PPV[_` \x82\x84\x03\x12\x15a%}W__\xFD[a\x17K\x82a#\xCEV[__`@\x83\x85\x03\x12\x15a%\x97W__\xFD[a%\xA0\x83a#\xCEV[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%\xBBW__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a%\xCBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%\xE5Wa%\xE5a$\x11V[a%\xF8`\x1F\x82\x01`\x1F\x19\x16` \x01a$NV[\x81\x81R\x86` \x83\x85\x01\x01\x11\x15a&\x0CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92\x90PV[___a\x01\0\x84\x86\x03\x12\x15a&>W__\xFD[a&H\x85\x85a$\x7FV[\x92Pa&W\x85`\x80\x86\x01a$\xE0V[\x91Pa&f\x85`\xC0\x86\x01a$\xE0V[\x90P\x92P\x92P\x92V[_`\x80\x82\x84\x03\x12\x15a&\x7FW__\xFD[a\x17K\x83\x83a$\x7FV[__`@\x83\x85\x03\x12\x15a&\x9AW__\xFD[a&\xA3\x83a#\xCEV[\x91Pa&\xB1` \x84\x01a#\xCEV[\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&\xFFW__\xFD[P5\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a'\x19W__\xFD[a'\"\x85a#\xCEV[\x93Pa'0` \x86\x01a#\xCEV[\x92P`@\x85\x015\x91Pa'E``\x86\x01a#\xCEV[\x90P\x92\x95\x91\x94P\x92PV[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x82\x81R`@\x81\x01`\x03\x83\x10a'\x87WcNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x82` \x83\x01R\x93\x92PPPV[_` \x82\x84\x03\x12\x15a'\xA4W__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x17NWa\x17Na'\xABV[\x81\x81\x03\x81\x81\x11\x15a\x17NWa\x17Na'\xABV[\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#\x9EV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a(Ja(D\x83\x86a(\x1FV[\x84a(\x1FV[\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a(\x80WcNH{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\x17K\x82\x84a(\x1FV[_a(\xC3\x82\x85a(\x1FV[_\x81R`\x01`\x01`\xF8\x1B\x03\x19\x93\x90\x93\x16`\x01\x84\x01RPP`\x02\x01\x91\x90PV[_a(\xED\x82\x84a(\x1FV[_\x81R`\x01\x01\x93\x92PPPV[_a)\x05\x82\x85a(\x1FV[`\x01`\x01`\xF0\x1B\x03\x19\x93\x90\x93\x16\x83RPP`\x02\x01\x91\x90PV[_a))\x82\x85a(\x1FV[`\x01`\x01`\xF8\x1B\x03\x19\x93\x90\x93\x16\x83RPP`\x01\x01\x91\x90PV[_a)M\x82\x86a(\x1FV[`\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\x17NWa\x17Na'\xABV[`\x01\x81[`\x01\x84\x11\x15a)\xC7W\x80\x85\x04\x81\x11\x15a)\xABWa)\xABa'\xABV[`\x01\x84\x16\x15a)\xB9W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a)\x90V[\x93P\x93\x91PPV[_\x82a)\xDDWP`\x01a\x17NV[\x81a)\xE9WP_a\x17NV[\x81`\x01\x81\x14a)\xFFW`\x02\x81\x14a*\tWa*%V[`\x01\x91PPa\x17NV[`\xFF\x84\x11\x15a*\x1AWa*\x1Aa'\xABV[PP`\x01\x82\x1Ba\x17NV[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a*HWP\x81\x81\na\x17NV[a*T_\x19\x84\x84a)\x8CV[\x80_\x19\x04\x82\x11\x15a*gWa*ga'\xABV[\x02\x93\x92PPPV[_a\x17K\x83\x83a)\xCFV\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\x1C\0\n",
2081    );
2082    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2083    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2084    #[derive(Clone)]
2085    pub struct ValidatorStatus(u8);
2086    const _: () = {
2087        use alloy::sol_types as alloy_sol_types;
2088        #[automatically_derived]
2089        impl alloy_sol_types::private::SolTypeValue<ValidatorStatus> for u8 {
2090            #[inline]
2091            fn stv_to_tokens(
2092                &self,
2093            ) -> <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
2094            {
2095                alloy_sol_types::private::SolTypeValue::<
2096                    alloy::sol_types::sol_data::Uint<8>,
2097                >::stv_to_tokens(self)
2098            }
2099            #[inline]
2100            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2101                <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
2102            }
2103            #[inline]
2104            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2105                <alloy::sol_types::sol_data::Uint<
2106                    8,
2107                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
2108            }
2109            #[inline]
2110            fn stv_abi_packed_encoded_size(&self) -> usize {
2111                <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
2112                    self,
2113                )
2114            }
2115        }
2116        #[automatically_derived]
2117        impl ValidatorStatus {
2118            /// The Solidity type name.
2119            pub const NAME: &'static str = stringify!(@ name);
2120            /// Convert from the underlying value type.
2121            #[inline]
2122            pub const fn from(value: u8) -> Self {
2123                Self(value)
2124            }
2125            /// Return the underlying value.
2126            #[inline]
2127            pub const fn into(self) -> u8 {
2128                self.0
2129            }
2130            /// Return the single encoding of this value, delegating to the
2131            /// underlying type.
2132            #[inline]
2133            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
2134                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
2135            }
2136            /// Return the packed encoding of this value, delegating to the
2137            /// underlying type.
2138            #[inline]
2139            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
2140                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
2141            }
2142        }
2143        #[automatically_derived]
2144        impl alloy_sol_types::SolType for ValidatorStatus {
2145            type RustType = u8;
2146            type Token<'a> =
2147                <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
2148            const SOL_NAME: &'static str = Self::NAME;
2149            const ENCODED_SIZE: Option<usize> =
2150                <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
2151            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
2152                8,
2153            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2154            #[inline]
2155            fn valid_token(token: &Self::Token<'_>) -> bool {
2156                Self::type_check(token).is_ok()
2157            }
2158            #[inline]
2159            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
2160                <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
2161            }
2162            #[inline]
2163            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2164                <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
2165            }
2166        }
2167        #[automatically_derived]
2168        impl alloy_sol_types::EventTopic for ValidatorStatus {
2169            #[inline]
2170            fn topic_preimage_length(rust: &Self::RustType) -> usize {
2171                <alloy::sol_types::sol_data::Uint<
2172                    8,
2173                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
2174            }
2175            #[inline]
2176            fn encode_topic_preimage(
2177                rust: &Self::RustType,
2178                out: &mut alloy_sol_types::private::Vec<u8>,
2179            ) {
2180                <alloy::sol_types::sol_data::Uint<
2181                    8,
2182                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
2183            }
2184            #[inline]
2185            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
2186                <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
2187                    rust,
2188                )
2189            }
2190        }
2191    };
2192    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2193    /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`.
2194    ```solidity
2195    error AddressEmptyCode(address target);
2196    ```*/
2197    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2198    #[derive(Clone)]
2199    pub struct AddressEmptyCode {
2200        #[allow(missing_docs)]
2201        pub target: alloy::sol_types::private::Address,
2202    }
2203    #[allow(
2204        non_camel_case_types,
2205        non_snake_case,
2206        clippy::pub_underscore_fields,
2207        clippy::style
2208    )]
2209    const _: () = {
2210        use alloy::sol_types as alloy_sol_types;
2211        #[doc(hidden)]
2212        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2213        #[doc(hidden)]
2214        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2215        #[cfg(test)]
2216        #[allow(dead_code, unreachable_patterns)]
2217        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2218            match _t {
2219                alloy_sol_types::private::AssertTypeEq::<
2220                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2221                >(_) => {},
2222            }
2223        }
2224        #[automatically_derived]
2225        #[doc(hidden)]
2226        impl ::core::convert::From<AddressEmptyCode> for UnderlyingRustTuple<'_> {
2227            fn from(value: AddressEmptyCode) -> Self {
2228                (value.target,)
2229            }
2230        }
2231        #[automatically_derived]
2232        #[doc(hidden)]
2233        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressEmptyCode {
2234            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2235                Self { target: tuple.0 }
2236            }
2237        }
2238        #[automatically_derived]
2239        impl alloy_sol_types::SolError for AddressEmptyCode {
2240            type Parameters<'a> = UnderlyingSolTuple<'a>;
2241            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2242            const SIGNATURE: &'static str = "AddressEmptyCode(address)";
2243            const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8];
2244            #[inline]
2245            fn new<'a>(
2246                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2247            ) -> Self {
2248                tuple.into()
2249            }
2250            #[inline]
2251            fn tokenize(&self) -> Self::Token<'_> {
2252                (
2253                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2254                        &self.target,
2255                    ),
2256                )
2257            }
2258        }
2259    };
2260    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2261    /**Custom error with signature `BLSSigVerificationFailed()` and selector `0x0ced3e50`.
2262    ```solidity
2263    error BLSSigVerificationFailed();
2264    ```*/
2265    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2266    #[derive(Clone)]
2267    pub struct BLSSigVerificationFailed {}
2268    #[allow(
2269        non_camel_case_types,
2270        non_snake_case,
2271        clippy::pub_underscore_fields,
2272        clippy::style
2273    )]
2274    const _: () = {
2275        use alloy::sol_types as alloy_sol_types;
2276        #[doc(hidden)]
2277        type UnderlyingSolTuple<'a> = ();
2278        #[doc(hidden)]
2279        type UnderlyingRustTuple<'a> = ();
2280        #[cfg(test)]
2281        #[allow(dead_code, unreachable_patterns)]
2282        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2283            match _t {
2284                alloy_sol_types::private::AssertTypeEq::<
2285                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2286                >(_) => {},
2287            }
2288        }
2289        #[automatically_derived]
2290        #[doc(hidden)]
2291        impl ::core::convert::From<BLSSigVerificationFailed> for UnderlyingRustTuple<'_> {
2292            fn from(value: BLSSigVerificationFailed) -> Self {
2293                ()
2294            }
2295        }
2296        #[automatically_derived]
2297        #[doc(hidden)]
2298        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BLSSigVerificationFailed {
2299            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2300                Self {}
2301            }
2302        }
2303        #[automatically_derived]
2304        impl alloy_sol_types::SolError for BLSSigVerificationFailed {
2305            type Parameters<'a> = UnderlyingSolTuple<'a>;
2306            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2307            const SIGNATURE: &'static str = "BLSSigVerificationFailed()";
2308            const SELECTOR: [u8; 4] = [12u8, 237u8, 62u8, 80u8];
2309            #[inline]
2310            fn new<'a>(
2311                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2312            ) -> Self {
2313                tuple.into()
2314            }
2315            #[inline]
2316            fn tokenize(&self) -> Self::Token<'_> {
2317                ()
2318            }
2319        }
2320    };
2321    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2322    /**Custom error with signature `BlsKeyAlreadyUsed()` and selector `0x01b514ae`.
2323    ```solidity
2324    error BlsKeyAlreadyUsed();
2325    ```*/
2326    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2327    #[derive(Clone)]
2328    pub struct BlsKeyAlreadyUsed {}
2329    #[allow(
2330        non_camel_case_types,
2331        non_snake_case,
2332        clippy::pub_underscore_fields,
2333        clippy::style
2334    )]
2335    const _: () = {
2336        use alloy::sol_types as alloy_sol_types;
2337        #[doc(hidden)]
2338        type UnderlyingSolTuple<'a> = ();
2339        #[doc(hidden)]
2340        type UnderlyingRustTuple<'a> = ();
2341        #[cfg(test)]
2342        #[allow(dead_code, unreachable_patterns)]
2343        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2344            match _t {
2345                alloy_sol_types::private::AssertTypeEq::<
2346                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2347                >(_) => {},
2348            }
2349        }
2350        #[automatically_derived]
2351        #[doc(hidden)]
2352        impl ::core::convert::From<BlsKeyAlreadyUsed> for UnderlyingRustTuple<'_> {
2353            fn from(value: BlsKeyAlreadyUsed) -> Self {
2354                ()
2355            }
2356        }
2357        #[automatically_derived]
2358        #[doc(hidden)]
2359        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BlsKeyAlreadyUsed {
2360            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2361                Self {}
2362            }
2363        }
2364        #[automatically_derived]
2365        impl alloy_sol_types::SolError for BlsKeyAlreadyUsed {
2366            type Parameters<'a> = UnderlyingSolTuple<'a>;
2367            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2368            const SIGNATURE: &'static str = "BlsKeyAlreadyUsed()";
2369            const SELECTOR: [u8; 4] = [1u8, 181u8, 20u8, 174u8];
2370            #[inline]
2371            fn new<'a>(
2372                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2373            ) -> Self {
2374                tuple.into()
2375            }
2376            #[inline]
2377            fn tokenize(&self) -> Self::Token<'_> {
2378                ()
2379            }
2380        }
2381    };
2382    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2383    /**Custom error with signature `ERC1967InvalidImplementation(address)` and selector `0x4c9c8ce3`.
2384    ```solidity
2385    error ERC1967InvalidImplementation(address implementation);
2386    ```*/
2387    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2388    #[derive(Clone)]
2389    pub struct ERC1967InvalidImplementation {
2390        #[allow(missing_docs)]
2391        pub implementation: alloy::sol_types::private::Address,
2392    }
2393    #[allow(
2394        non_camel_case_types,
2395        non_snake_case,
2396        clippy::pub_underscore_fields,
2397        clippy::style
2398    )]
2399    const _: () = {
2400        use alloy::sol_types as alloy_sol_types;
2401        #[doc(hidden)]
2402        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2403        #[doc(hidden)]
2404        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2405        #[cfg(test)]
2406        #[allow(dead_code, unreachable_patterns)]
2407        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2408            match _t {
2409                alloy_sol_types::private::AssertTypeEq::<
2410                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2411                >(_) => {},
2412            }
2413        }
2414        #[automatically_derived]
2415        #[doc(hidden)]
2416        impl ::core::convert::From<ERC1967InvalidImplementation> for UnderlyingRustTuple<'_> {
2417            fn from(value: ERC1967InvalidImplementation) -> Self {
2418                (value.implementation,)
2419            }
2420        }
2421        #[automatically_derived]
2422        #[doc(hidden)]
2423        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1967InvalidImplementation {
2424            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2425                Self {
2426                    implementation: tuple.0,
2427                }
2428            }
2429        }
2430        #[automatically_derived]
2431        impl alloy_sol_types::SolError for ERC1967InvalidImplementation {
2432            type Parameters<'a> = UnderlyingSolTuple<'a>;
2433            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2434            const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)";
2435            const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8];
2436            #[inline]
2437            fn new<'a>(
2438                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2439            ) -> Self {
2440                tuple.into()
2441            }
2442            #[inline]
2443            fn tokenize(&self) -> Self::Token<'_> {
2444                (
2445                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2446                        &self.implementation,
2447                    ),
2448                )
2449            }
2450        }
2451    };
2452    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2453    /**Custom error with signature `ERC1967NonPayable()` and selector `0xb398979f`.
2454    ```solidity
2455    error ERC1967NonPayable();
2456    ```*/
2457    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2458    #[derive(Clone)]
2459    pub struct ERC1967NonPayable {}
2460    #[allow(
2461        non_camel_case_types,
2462        non_snake_case,
2463        clippy::pub_underscore_fields,
2464        clippy::style
2465    )]
2466    const _: () = {
2467        use alloy::sol_types as alloy_sol_types;
2468        #[doc(hidden)]
2469        type UnderlyingSolTuple<'a> = ();
2470        #[doc(hidden)]
2471        type UnderlyingRustTuple<'a> = ();
2472        #[cfg(test)]
2473        #[allow(dead_code, unreachable_patterns)]
2474        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2475            match _t {
2476                alloy_sol_types::private::AssertTypeEq::<
2477                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2478                >(_) => {},
2479            }
2480        }
2481        #[automatically_derived]
2482        #[doc(hidden)]
2483        impl ::core::convert::From<ERC1967NonPayable> for UnderlyingRustTuple<'_> {
2484            fn from(value: ERC1967NonPayable) -> Self {
2485                ()
2486            }
2487        }
2488        #[automatically_derived]
2489        #[doc(hidden)]
2490        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1967NonPayable {
2491            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2492                Self {}
2493            }
2494        }
2495        #[automatically_derived]
2496        impl alloy_sol_types::SolError for ERC1967NonPayable {
2497            type Parameters<'a> = UnderlyingSolTuple<'a>;
2498            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2499            const SIGNATURE: &'static str = "ERC1967NonPayable()";
2500            const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8];
2501            #[inline]
2502            fn new<'a>(
2503                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2504            ) -> Self {
2505                tuple.into()
2506            }
2507            #[inline]
2508            fn tokenize(&self) -> Self::Token<'_> {
2509                ()
2510            }
2511        }
2512    };
2513    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2514    /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`.
2515    ```solidity
2516    error FailedInnerCall();
2517    ```*/
2518    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2519    #[derive(Clone)]
2520    pub struct FailedInnerCall {}
2521    #[allow(
2522        non_camel_case_types,
2523        non_snake_case,
2524        clippy::pub_underscore_fields,
2525        clippy::style
2526    )]
2527    const _: () = {
2528        use alloy::sol_types as alloy_sol_types;
2529        #[doc(hidden)]
2530        type UnderlyingSolTuple<'a> = ();
2531        #[doc(hidden)]
2532        type UnderlyingRustTuple<'a> = ();
2533        #[cfg(test)]
2534        #[allow(dead_code, unreachable_patterns)]
2535        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2536            match _t {
2537                alloy_sol_types::private::AssertTypeEq::<
2538                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2539                >(_) => {},
2540            }
2541        }
2542        #[automatically_derived]
2543        #[doc(hidden)]
2544        impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
2545            fn from(value: FailedInnerCall) -> Self {
2546                ()
2547            }
2548        }
2549        #[automatically_derived]
2550        #[doc(hidden)]
2551        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
2552            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2553                Self {}
2554            }
2555        }
2556        #[automatically_derived]
2557        impl alloy_sol_types::SolError for FailedInnerCall {
2558            type Parameters<'a> = UnderlyingSolTuple<'a>;
2559            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2560            const SIGNATURE: &'static str = "FailedInnerCall()";
2561            const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
2562            #[inline]
2563            fn new<'a>(
2564                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2565            ) -> Self {
2566                tuple.into()
2567            }
2568            #[inline]
2569            fn tokenize(&self) -> Self::Token<'_> {
2570                ()
2571            }
2572        }
2573    };
2574    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2575    /**Custom error with signature `InsufficientAllowance(uint256,uint256)` and selector `0x2a1b2dd8`.
2576    ```solidity
2577    error InsufficientAllowance(uint256, uint256);
2578    ```*/
2579    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2580    #[derive(Clone)]
2581    pub struct InsufficientAllowance {
2582        #[allow(missing_docs)]
2583        pub _0: alloy::sol_types::private::primitives::aliases::U256,
2584        #[allow(missing_docs)]
2585        pub _1: alloy::sol_types::private::primitives::aliases::U256,
2586    }
2587    #[allow(
2588        non_camel_case_types,
2589        non_snake_case,
2590        clippy::pub_underscore_fields,
2591        clippy::style
2592    )]
2593    const _: () = {
2594        use alloy::sol_types as alloy_sol_types;
2595        #[doc(hidden)]
2596        type UnderlyingSolTuple<'a> = (
2597            alloy::sol_types::sol_data::Uint<256>,
2598            alloy::sol_types::sol_data::Uint<256>,
2599        );
2600        #[doc(hidden)]
2601        type UnderlyingRustTuple<'a> = (
2602            alloy::sol_types::private::primitives::aliases::U256,
2603            alloy::sol_types::private::primitives::aliases::U256,
2604        );
2605        #[cfg(test)]
2606        #[allow(dead_code, unreachable_patterns)]
2607        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2608            match _t {
2609                alloy_sol_types::private::AssertTypeEq::<
2610                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2611                >(_) => {},
2612            }
2613        }
2614        #[automatically_derived]
2615        #[doc(hidden)]
2616        impl ::core::convert::From<InsufficientAllowance> for UnderlyingRustTuple<'_> {
2617            fn from(value: InsufficientAllowance) -> Self {
2618                (value._0, value._1)
2619            }
2620        }
2621        #[automatically_derived]
2622        #[doc(hidden)]
2623        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientAllowance {
2624            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2625                Self {
2626                    _0: tuple.0,
2627                    _1: tuple.1,
2628                }
2629            }
2630        }
2631        #[automatically_derived]
2632        impl alloy_sol_types::SolError for InsufficientAllowance {
2633            type Parameters<'a> = UnderlyingSolTuple<'a>;
2634            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2635            const SIGNATURE: &'static str = "InsufficientAllowance(uint256,uint256)";
2636            const SELECTOR: [u8; 4] = [42u8, 27u8, 45u8, 216u8];
2637            #[inline]
2638            fn new<'a>(
2639                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2640            ) -> Self {
2641                tuple.into()
2642            }
2643            #[inline]
2644            fn tokenize(&self) -> Self::Token<'_> {
2645                (
2646                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
2647                        &self._0,
2648                    ),
2649                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
2650                        &self._1,
2651                    ),
2652                )
2653            }
2654        }
2655    };
2656    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2657    /**Custom error with signature `InsufficientBalance(uint256)` and selector `0x92665351`.
2658    ```solidity
2659    error InsufficientBalance(uint256);
2660    ```*/
2661    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2662    #[derive(Clone)]
2663    pub struct InsufficientBalance {
2664        #[allow(missing_docs)]
2665        pub _0: alloy::sol_types::private::primitives::aliases::U256,
2666    }
2667    #[allow(
2668        non_camel_case_types,
2669        non_snake_case,
2670        clippy::pub_underscore_fields,
2671        clippy::style
2672    )]
2673    const _: () = {
2674        use alloy::sol_types as alloy_sol_types;
2675        #[doc(hidden)]
2676        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2677        #[doc(hidden)]
2678        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
2679        #[cfg(test)]
2680        #[allow(dead_code, unreachable_patterns)]
2681        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2682            match _t {
2683                alloy_sol_types::private::AssertTypeEq::<
2684                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2685                >(_) => {},
2686            }
2687        }
2688        #[automatically_derived]
2689        #[doc(hidden)]
2690        impl ::core::convert::From<InsufficientBalance> for UnderlyingRustTuple<'_> {
2691            fn from(value: InsufficientBalance) -> Self {
2692                (value._0,)
2693            }
2694        }
2695        #[automatically_derived]
2696        #[doc(hidden)]
2697        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientBalance {
2698            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2699                Self { _0: tuple.0 }
2700            }
2701        }
2702        #[automatically_derived]
2703        impl alloy_sol_types::SolError for InsufficientBalance {
2704            type Parameters<'a> = UnderlyingSolTuple<'a>;
2705            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2706            const SIGNATURE: &'static str = "InsufficientBalance(uint256)";
2707            const SELECTOR: [u8; 4] = [146u8, 102u8, 83u8, 81u8];
2708            #[inline]
2709            fn new<'a>(
2710                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2711            ) -> Self {
2712                tuple.into()
2713            }
2714            #[inline]
2715            fn tokenize(&self) -> Self::Token<'_> {
2716                (
2717                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
2718                        &self._0,
2719                    ),
2720                )
2721            }
2722        }
2723    };
2724    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2725    /**Custom error with signature `InvalidCommission()` and selector `0xdc81db85`.
2726    ```solidity
2727    error InvalidCommission();
2728    ```*/
2729    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2730    #[derive(Clone)]
2731    pub struct InvalidCommission {}
2732    #[allow(
2733        non_camel_case_types,
2734        non_snake_case,
2735        clippy::pub_underscore_fields,
2736        clippy::style
2737    )]
2738    const _: () = {
2739        use alloy::sol_types as alloy_sol_types;
2740        #[doc(hidden)]
2741        type UnderlyingSolTuple<'a> = ();
2742        #[doc(hidden)]
2743        type UnderlyingRustTuple<'a> = ();
2744        #[cfg(test)]
2745        #[allow(dead_code, unreachable_patterns)]
2746        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2747            match _t {
2748                alloy_sol_types::private::AssertTypeEq::<
2749                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2750                >(_) => {},
2751            }
2752        }
2753        #[automatically_derived]
2754        #[doc(hidden)]
2755        impl ::core::convert::From<InvalidCommission> for UnderlyingRustTuple<'_> {
2756            fn from(value: InvalidCommission) -> Self {
2757                ()
2758            }
2759        }
2760        #[automatically_derived]
2761        #[doc(hidden)]
2762        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidCommission {
2763            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2764                Self {}
2765            }
2766        }
2767        #[automatically_derived]
2768        impl alloy_sol_types::SolError for InvalidCommission {
2769            type Parameters<'a> = UnderlyingSolTuple<'a>;
2770            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2771            const SIGNATURE: &'static str = "InvalidCommission()";
2772            const SELECTOR: [u8; 4] = [220u8, 129u8, 219u8, 133u8];
2773            #[inline]
2774            fn new<'a>(
2775                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2776            ) -> Self {
2777                tuple.into()
2778            }
2779            #[inline]
2780            fn tokenize(&self) -> Self::Token<'_> {
2781                ()
2782            }
2783        }
2784    };
2785    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2786    /**Custom error with signature `InvalidInitialization()` and selector `0xf92ee8a9`.
2787    ```solidity
2788    error InvalidInitialization();
2789    ```*/
2790    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2791    #[derive(Clone)]
2792    pub struct InvalidInitialization {}
2793    #[allow(
2794        non_camel_case_types,
2795        non_snake_case,
2796        clippy::pub_underscore_fields,
2797        clippy::style
2798    )]
2799    const _: () = {
2800        use alloy::sol_types as alloy_sol_types;
2801        #[doc(hidden)]
2802        type UnderlyingSolTuple<'a> = ();
2803        #[doc(hidden)]
2804        type UnderlyingRustTuple<'a> = ();
2805        #[cfg(test)]
2806        #[allow(dead_code, unreachable_patterns)]
2807        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2808            match _t {
2809                alloy_sol_types::private::AssertTypeEq::<
2810                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2811                >(_) => {},
2812            }
2813        }
2814        #[automatically_derived]
2815        #[doc(hidden)]
2816        impl ::core::convert::From<InvalidInitialization> for UnderlyingRustTuple<'_> {
2817            fn from(value: InvalidInitialization) -> Self {
2818                ()
2819            }
2820        }
2821        #[automatically_derived]
2822        #[doc(hidden)]
2823        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInitialization {
2824            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2825                Self {}
2826            }
2827        }
2828        #[automatically_derived]
2829        impl alloy_sol_types::SolError for InvalidInitialization {
2830            type Parameters<'a> = UnderlyingSolTuple<'a>;
2831            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2832            const SIGNATURE: &'static str = "InvalidInitialization()";
2833            const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8];
2834            #[inline]
2835            fn new<'a>(
2836                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2837            ) -> Self {
2838                tuple.into()
2839            }
2840            #[inline]
2841            fn tokenize(&self) -> Self::Token<'_> {
2842                ()
2843            }
2844        }
2845    };
2846    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2847    /**Custom error with signature `InvalidSchnorrVK()` and selector `0x06cf438f`.
2848    ```solidity
2849    error InvalidSchnorrVK();
2850    ```*/
2851    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2852    #[derive(Clone)]
2853    pub struct InvalidSchnorrVK {}
2854    #[allow(
2855        non_camel_case_types,
2856        non_snake_case,
2857        clippy::pub_underscore_fields,
2858        clippy::style
2859    )]
2860    const _: () = {
2861        use alloy::sol_types as alloy_sol_types;
2862        #[doc(hidden)]
2863        type UnderlyingSolTuple<'a> = ();
2864        #[doc(hidden)]
2865        type UnderlyingRustTuple<'a> = ();
2866        #[cfg(test)]
2867        #[allow(dead_code, unreachable_patterns)]
2868        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2869            match _t {
2870                alloy_sol_types::private::AssertTypeEq::<
2871                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2872                >(_) => {},
2873            }
2874        }
2875        #[automatically_derived]
2876        #[doc(hidden)]
2877        impl ::core::convert::From<InvalidSchnorrVK> for UnderlyingRustTuple<'_> {
2878            fn from(value: InvalidSchnorrVK) -> Self {
2879                ()
2880            }
2881        }
2882        #[automatically_derived]
2883        #[doc(hidden)]
2884        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSchnorrVK {
2885            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2886                Self {}
2887            }
2888        }
2889        #[automatically_derived]
2890        impl alloy_sol_types::SolError for InvalidSchnorrVK {
2891            type Parameters<'a> = UnderlyingSolTuple<'a>;
2892            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2893            const SIGNATURE: &'static str = "InvalidSchnorrVK()";
2894            const SELECTOR: [u8; 4] = [6u8, 207u8, 67u8, 143u8];
2895            #[inline]
2896            fn new<'a>(
2897                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2898            ) -> Self {
2899                tuple.into()
2900            }
2901            #[inline]
2902            fn tokenize(&self) -> Self::Token<'_> {
2903                ()
2904            }
2905        }
2906    };
2907    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2908    /**Custom error with signature `NotInitializing()` and selector `0xd7e6bcf8`.
2909    ```solidity
2910    error NotInitializing();
2911    ```*/
2912    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2913    #[derive(Clone)]
2914    pub struct NotInitializing {}
2915    #[allow(
2916        non_camel_case_types,
2917        non_snake_case,
2918        clippy::pub_underscore_fields,
2919        clippy::style
2920    )]
2921    const _: () = {
2922        use alloy::sol_types as alloy_sol_types;
2923        #[doc(hidden)]
2924        type UnderlyingSolTuple<'a> = ();
2925        #[doc(hidden)]
2926        type UnderlyingRustTuple<'a> = ();
2927        #[cfg(test)]
2928        #[allow(dead_code, unreachable_patterns)]
2929        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2930            match _t {
2931                alloy_sol_types::private::AssertTypeEq::<
2932                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2933                >(_) => {},
2934            }
2935        }
2936        #[automatically_derived]
2937        #[doc(hidden)]
2938        impl ::core::convert::From<NotInitializing> for UnderlyingRustTuple<'_> {
2939            fn from(value: NotInitializing) -> Self {
2940                ()
2941            }
2942        }
2943        #[automatically_derived]
2944        #[doc(hidden)]
2945        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotInitializing {
2946            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2947                Self {}
2948            }
2949        }
2950        #[automatically_derived]
2951        impl alloy_sol_types::SolError for NotInitializing {
2952            type Parameters<'a> = UnderlyingSolTuple<'a>;
2953            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2954            const SIGNATURE: &'static str = "NotInitializing()";
2955            const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8];
2956            #[inline]
2957            fn new<'a>(
2958                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2959            ) -> Self {
2960                tuple.into()
2961            }
2962            #[inline]
2963            fn tokenize(&self) -> Self::Token<'_> {
2964                ()
2965            }
2966        }
2967    };
2968    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2969    /**Custom error with signature `NothingToWithdraw()` and selector `0xd0d04f60`.
2970    ```solidity
2971    error NothingToWithdraw();
2972    ```*/
2973    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2974    #[derive(Clone)]
2975    pub struct NothingToWithdraw {}
2976    #[allow(
2977        non_camel_case_types,
2978        non_snake_case,
2979        clippy::pub_underscore_fields,
2980        clippy::style
2981    )]
2982    const _: () = {
2983        use alloy::sol_types as alloy_sol_types;
2984        #[doc(hidden)]
2985        type UnderlyingSolTuple<'a> = ();
2986        #[doc(hidden)]
2987        type UnderlyingRustTuple<'a> = ();
2988        #[cfg(test)]
2989        #[allow(dead_code, unreachable_patterns)]
2990        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2991            match _t {
2992                alloy_sol_types::private::AssertTypeEq::<
2993                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2994                >(_) => {},
2995            }
2996        }
2997        #[automatically_derived]
2998        #[doc(hidden)]
2999        impl ::core::convert::From<NothingToWithdraw> for UnderlyingRustTuple<'_> {
3000            fn from(value: NothingToWithdraw) -> Self {
3001                ()
3002            }
3003        }
3004        #[automatically_derived]
3005        #[doc(hidden)]
3006        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NothingToWithdraw {
3007            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3008                Self {}
3009            }
3010        }
3011        #[automatically_derived]
3012        impl alloy_sol_types::SolError for NothingToWithdraw {
3013            type Parameters<'a> = UnderlyingSolTuple<'a>;
3014            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3015            const SIGNATURE: &'static str = "NothingToWithdraw()";
3016            const SELECTOR: [u8; 4] = [208u8, 208u8, 79u8, 96u8];
3017            #[inline]
3018            fn new<'a>(
3019                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3020            ) -> Self {
3021                tuple.into()
3022            }
3023            #[inline]
3024            fn tokenize(&self) -> Self::Token<'_> {
3025                ()
3026            }
3027        }
3028    };
3029    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3030    /**Custom error with signature `OwnableInvalidOwner(address)` and selector `0x1e4fbdf7`.
3031    ```solidity
3032    error OwnableInvalidOwner(address owner);
3033    ```*/
3034    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3035    #[derive(Clone)]
3036    pub struct OwnableInvalidOwner {
3037        #[allow(missing_docs)]
3038        pub owner: alloy::sol_types::private::Address,
3039    }
3040    #[allow(
3041        non_camel_case_types,
3042        non_snake_case,
3043        clippy::pub_underscore_fields,
3044        clippy::style
3045    )]
3046    const _: () = {
3047        use alloy::sol_types as alloy_sol_types;
3048        #[doc(hidden)]
3049        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3050        #[doc(hidden)]
3051        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3052        #[cfg(test)]
3053        #[allow(dead_code, unreachable_patterns)]
3054        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3055            match _t {
3056                alloy_sol_types::private::AssertTypeEq::<
3057                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3058                >(_) => {},
3059            }
3060        }
3061        #[automatically_derived]
3062        #[doc(hidden)]
3063        impl ::core::convert::From<OwnableInvalidOwner> for UnderlyingRustTuple<'_> {
3064            fn from(value: OwnableInvalidOwner) -> Self {
3065                (value.owner,)
3066            }
3067        }
3068        #[automatically_derived]
3069        #[doc(hidden)]
3070        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableInvalidOwner {
3071            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3072                Self { owner: tuple.0 }
3073            }
3074        }
3075        #[automatically_derived]
3076        impl alloy_sol_types::SolError for OwnableInvalidOwner {
3077            type Parameters<'a> = UnderlyingSolTuple<'a>;
3078            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3079            const SIGNATURE: &'static str = "OwnableInvalidOwner(address)";
3080            const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8];
3081            #[inline]
3082            fn new<'a>(
3083                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3084            ) -> Self {
3085                tuple.into()
3086            }
3087            #[inline]
3088            fn tokenize(&self) -> Self::Token<'_> {
3089                (
3090                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3091                        &self.owner,
3092                    ),
3093                )
3094            }
3095        }
3096    };
3097    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3098    /**Custom error with signature `OwnableUnauthorizedAccount(address)` and selector `0x118cdaa7`.
3099    ```solidity
3100    error OwnableUnauthorizedAccount(address account);
3101    ```*/
3102    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3103    #[derive(Clone)]
3104    pub struct OwnableUnauthorizedAccount {
3105        #[allow(missing_docs)]
3106        pub account: alloy::sol_types::private::Address,
3107    }
3108    #[allow(
3109        non_camel_case_types,
3110        non_snake_case,
3111        clippy::pub_underscore_fields,
3112        clippy::style
3113    )]
3114    const _: () = {
3115        use alloy::sol_types as alloy_sol_types;
3116        #[doc(hidden)]
3117        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3118        #[doc(hidden)]
3119        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3120        #[cfg(test)]
3121        #[allow(dead_code, unreachable_patterns)]
3122        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3123            match _t {
3124                alloy_sol_types::private::AssertTypeEq::<
3125                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3126                >(_) => {},
3127            }
3128        }
3129        #[automatically_derived]
3130        #[doc(hidden)]
3131        impl ::core::convert::From<OwnableUnauthorizedAccount> for UnderlyingRustTuple<'_> {
3132            fn from(value: OwnableUnauthorizedAccount) -> Self {
3133                (value.account,)
3134            }
3135        }
3136        #[automatically_derived]
3137        #[doc(hidden)]
3138        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableUnauthorizedAccount {
3139            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3140                Self { account: tuple.0 }
3141            }
3142        }
3143        #[automatically_derived]
3144        impl alloy_sol_types::SolError for OwnableUnauthorizedAccount {
3145            type Parameters<'a> = UnderlyingSolTuple<'a>;
3146            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3147            const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)";
3148            const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8];
3149            #[inline]
3150            fn new<'a>(
3151                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3152            ) -> Self {
3153                tuple.into()
3154            }
3155            #[inline]
3156            fn tokenize(&self) -> Self::Token<'_> {
3157                (
3158                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3159                        &self.account,
3160                    ),
3161                )
3162            }
3163        }
3164    };
3165    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3166    /**Custom error with signature `PrematureWithdrawal()` and selector `0x5a774357`.
3167    ```solidity
3168    error PrematureWithdrawal();
3169    ```*/
3170    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3171    #[derive(Clone)]
3172    pub struct PrematureWithdrawal {}
3173    #[allow(
3174        non_camel_case_types,
3175        non_snake_case,
3176        clippy::pub_underscore_fields,
3177        clippy::style
3178    )]
3179    const _: () = {
3180        use alloy::sol_types as alloy_sol_types;
3181        #[doc(hidden)]
3182        type UnderlyingSolTuple<'a> = ();
3183        #[doc(hidden)]
3184        type UnderlyingRustTuple<'a> = ();
3185        #[cfg(test)]
3186        #[allow(dead_code, unreachable_patterns)]
3187        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3188            match _t {
3189                alloy_sol_types::private::AssertTypeEq::<
3190                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3191                >(_) => {},
3192            }
3193        }
3194        #[automatically_derived]
3195        #[doc(hidden)]
3196        impl ::core::convert::From<PrematureWithdrawal> for UnderlyingRustTuple<'_> {
3197            fn from(value: PrematureWithdrawal) -> Self {
3198                ()
3199            }
3200        }
3201        #[automatically_derived]
3202        #[doc(hidden)]
3203        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PrematureWithdrawal {
3204            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3205                Self {}
3206            }
3207        }
3208        #[automatically_derived]
3209        impl alloy_sol_types::SolError for PrematureWithdrawal {
3210            type Parameters<'a> = UnderlyingSolTuple<'a>;
3211            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3212            const SIGNATURE: &'static str = "PrematureWithdrawal()";
3213            const SELECTOR: [u8; 4] = [90u8, 119u8, 67u8, 87u8];
3214            #[inline]
3215            fn new<'a>(
3216                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3217            ) -> Self {
3218                tuple.into()
3219            }
3220            #[inline]
3221            fn tokenize(&self) -> Self::Token<'_> {
3222                ()
3223            }
3224        }
3225    };
3226    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3227    /**Custom error with signature `UUPSUnauthorizedCallContext()` and selector `0xe07c8dba`.
3228    ```solidity
3229    error UUPSUnauthorizedCallContext();
3230    ```*/
3231    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3232    #[derive(Clone)]
3233    pub struct UUPSUnauthorizedCallContext {}
3234    #[allow(
3235        non_camel_case_types,
3236        non_snake_case,
3237        clippy::pub_underscore_fields,
3238        clippy::style
3239    )]
3240    const _: () = {
3241        use alloy::sol_types as alloy_sol_types;
3242        #[doc(hidden)]
3243        type UnderlyingSolTuple<'a> = ();
3244        #[doc(hidden)]
3245        type UnderlyingRustTuple<'a> = ();
3246        #[cfg(test)]
3247        #[allow(dead_code, unreachable_patterns)]
3248        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3249            match _t {
3250                alloy_sol_types::private::AssertTypeEq::<
3251                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3252                >(_) => {},
3253            }
3254        }
3255        #[automatically_derived]
3256        #[doc(hidden)]
3257        impl ::core::convert::From<UUPSUnauthorizedCallContext> for UnderlyingRustTuple<'_> {
3258            fn from(value: UUPSUnauthorizedCallContext) -> Self {
3259                ()
3260            }
3261        }
3262        #[automatically_derived]
3263        #[doc(hidden)]
3264        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UUPSUnauthorizedCallContext {
3265            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3266                Self {}
3267            }
3268        }
3269        #[automatically_derived]
3270        impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext {
3271            type Parameters<'a> = UnderlyingSolTuple<'a>;
3272            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3273            const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()";
3274            const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8];
3275            #[inline]
3276            fn new<'a>(
3277                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3278            ) -> Self {
3279                tuple.into()
3280            }
3281            #[inline]
3282            fn tokenize(&self) -> Self::Token<'_> {
3283                ()
3284            }
3285        }
3286    };
3287    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3288    /**Custom error with signature `UUPSUnsupportedProxiableUUID(bytes32)` and selector `0xaa1d49a4`.
3289    ```solidity
3290    error UUPSUnsupportedProxiableUUID(bytes32 slot);
3291    ```*/
3292    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3293    #[derive(Clone)]
3294    pub struct UUPSUnsupportedProxiableUUID {
3295        #[allow(missing_docs)]
3296        pub slot: alloy::sol_types::private::FixedBytes<32>,
3297    }
3298    #[allow(
3299        non_camel_case_types,
3300        non_snake_case,
3301        clippy::pub_underscore_fields,
3302        clippy::style
3303    )]
3304    const _: () = {
3305        use alloy::sol_types as alloy_sol_types;
3306        #[doc(hidden)]
3307        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3308        #[doc(hidden)]
3309        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3310        #[cfg(test)]
3311        #[allow(dead_code, unreachable_patterns)]
3312        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3313            match _t {
3314                alloy_sol_types::private::AssertTypeEq::<
3315                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3316                >(_) => {},
3317            }
3318        }
3319        #[automatically_derived]
3320        #[doc(hidden)]
3321        impl ::core::convert::From<UUPSUnsupportedProxiableUUID> for UnderlyingRustTuple<'_> {
3322            fn from(value: UUPSUnsupportedProxiableUUID) -> Self {
3323                (value.slot,)
3324            }
3325        }
3326        #[automatically_derived]
3327        #[doc(hidden)]
3328        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UUPSUnsupportedProxiableUUID {
3329            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3330                Self { slot: tuple.0 }
3331            }
3332        }
3333        #[automatically_derived]
3334        impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID {
3335            type Parameters<'a> = UnderlyingSolTuple<'a>;
3336            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3337            const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)";
3338            const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8];
3339            #[inline]
3340            fn new<'a>(
3341                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3342            ) -> Self {
3343                tuple.into()
3344            }
3345            #[inline]
3346            fn tokenize(&self) -> Self::Token<'_> {
3347                (
3348                    <alloy::sol_types::sol_data::FixedBytes<
3349                        32,
3350                    > as alloy_sol_types::SolType>::tokenize(&self.slot),
3351                )
3352            }
3353        }
3354    };
3355    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3356    /**Custom error with signature `UndelegationAlreadyExists()` and selector `0xd423a4f1`.
3357    ```solidity
3358    error UndelegationAlreadyExists();
3359    ```*/
3360    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3361    #[derive(Clone)]
3362    pub struct UndelegationAlreadyExists {}
3363    #[allow(
3364        non_camel_case_types,
3365        non_snake_case,
3366        clippy::pub_underscore_fields,
3367        clippy::style
3368    )]
3369    const _: () = {
3370        use alloy::sol_types as alloy_sol_types;
3371        #[doc(hidden)]
3372        type UnderlyingSolTuple<'a> = ();
3373        #[doc(hidden)]
3374        type UnderlyingRustTuple<'a> = ();
3375        #[cfg(test)]
3376        #[allow(dead_code, unreachable_patterns)]
3377        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3378            match _t {
3379                alloy_sol_types::private::AssertTypeEq::<
3380                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3381                >(_) => {},
3382            }
3383        }
3384        #[automatically_derived]
3385        #[doc(hidden)]
3386        impl ::core::convert::From<UndelegationAlreadyExists> for UnderlyingRustTuple<'_> {
3387            fn from(value: UndelegationAlreadyExists) -> Self {
3388                ()
3389            }
3390        }
3391        #[automatically_derived]
3392        #[doc(hidden)]
3393        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UndelegationAlreadyExists {
3394            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3395                Self {}
3396            }
3397        }
3398        #[automatically_derived]
3399        impl alloy_sol_types::SolError for UndelegationAlreadyExists {
3400            type Parameters<'a> = UnderlyingSolTuple<'a>;
3401            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3402            const SIGNATURE: &'static str = "UndelegationAlreadyExists()";
3403            const SELECTOR: [u8; 4] = [212u8, 35u8, 164u8, 241u8];
3404            #[inline]
3405            fn new<'a>(
3406                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3407            ) -> Self {
3408                tuple.into()
3409            }
3410            #[inline]
3411            fn tokenize(&self) -> Self::Token<'_> {
3412                ()
3413            }
3414        }
3415    };
3416    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3417    /**Custom error with signature `ValidatorAlreadyExited()` and selector `0xeab4a963`.
3418    ```solidity
3419    error ValidatorAlreadyExited();
3420    ```*/
3421    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3422    #[derive(Clone)]
3423    pub struct ValidatorAlreadyExited {}
3424    #[allow(
3425        non_camel_case_types,
3426        non_snake_case,
3427        clippy::pub_underscore_fields,
3428        clippy::style
3429    )]
3430    const _: () = {
3431        use alloy::sol_types as alloy_sol_types;
3432        #[doc(hidden)]
3433        type UnderlyingSolTuple<'a> = ();
3434        #[doc(hidden)]
3435        type UnderlyingRustTuple<'a> = ();
3436        #[cfg(test)]
3437        #[allow(dead_code, unreachable_patterns)]
3438        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3439            match _t {
3440                alloy_sol_types::private::AssertTypeEq::<
3441                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3442                >(_) => {},
3443            }
3444        }
3445        #[automatically_derived]
3446        #[doc(hidden)]
3447        impl ::core::convert::From<ValidatorAlreadyExited> for UnderlyingRustTuple<'_> {
3448            fn from(value: ValidatorAlreadyExited) -> Self {
3449                ()
3450            }
3451        }
3452        #[automatically_derived]
3453        #[doc(hidden)]
3454        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ValidatorAlreadyExited {
3455            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3456                Self {}
3457            }
3458        }
3459        #[automatically_derived]
3460        impl alloy_sol_types::SolError for ValidatorAlreadyExited {
3461            type Parameters<'a> = UnderlyingSolTuple<'a>;
3462            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3463            const SIGNATURE: &'static str = "ValidatorAlreadyExited()";
3464            const SELECTOR: [u8; 4] = [234u8, 180u8, 169u8, 99u8];
3465            #[inline]
3466            fn new<'a>(
3467                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3468            ) -> Self {
3469                tuple.into()
3470            }
3471            #[inline]
3472            fn tokenize(&self) -> Self::Token<'_> {
3473                ()
3474            }
3475        }
3476    };
3477    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3478    /**Custom error with signature `ValidatorAlreadyRegistered()` and selector `0x9973f7d8`.
3479    ```solidity
3480    error ValidatorAlreadyRegistered();
3481    ```*/
3482    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3483    #[derive(Clone)]
3484    pub struct ValidatorAlreadyRegistered {}
3485    #[allow(
3486        non_camel_case_types,
3487        non_snake_case,
3488        clippy::pub_underscore_fields,
3489        clippy::style
3490    )]
3491    const _: () = {
3492        use alloy::sol_types as alloy_sol_types;
3493        #[doc(hidden)]
3494        type UnderlyingSolTuple<'a> = ();
3495        #[doc(hidden)]
3496        type UnderlyingRustTuple<'a> = ();
3497        #[cfg(test)]
3498        #[allow(dead_code, unreachable_patterns)]
3499        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3500            match _t {
3501                alloy_sol_types::private::AssertTypeEq::<
3502                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3503                >(_) => {},
3504            }
3505        }
3506        #[automatically_derived]
3507        #[doc(hidden)]
3508        impl ::core::convert::From<ValidatorAlreadyRegistered> for UnderlyingRustTuple<'_> {
3509            fn from(value: ValidatorAlreadyRegistered) -> Self {
3510                ()
3511            }
3512        }
3513        #[automatically_derived]
3514        #[doc(hidden)]
3515        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ValidatorAlreadyRegistered {
3516            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3517                Self {}
3518            }
3519        }
3520        #[automatically_derived]
3521        impl alloy_sol_types::SolError for ValidatorAlreadyRegistered {
3522            type Parameters<'a> = UnderlyingSolTuple<'a>;
3523            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3524            const SIGNATURE: &'static str = "ValidatorAlreadyRegistered()";
3525            const SELECTOR: [u8; 4] = [153u8, 115u8, 247u8, 216u8];
3526            #[inline]
3527            fn new<'a>(
3528                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3529            ) -> Self {
3530                tuple.into()
3531            }
3532            #[inline]
3533            fn tokenize(&self) -> Self::Token<'_> {
3534                ()
3535            }
3536        }
3537    };
3538    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3539    /**Custom error with signature `ValidatorInactive()` and selector `0x508a793f`.
3540    ```solidity
3541    error ValidatorInactive();
3542    ```*/
3543    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3544    #[derive(Clone)]
3545    pub struct ValidatorInactive {}
3546    #[allow(
3547        non_camel_case_types,
3548        non_snake_case,
3549        clippy::pub_underscore_fields,
3550        clippy::style
3551    )]
3552    const _: () = {
3553        use alloy::sol_types as alloy_sol_types;
3554        #[doc(hidden)]
3555        type UnderlyingSolTuple<'a> = ();
3556        #[doc(hidden)]
3557        type UnderlyingRustTuple<'a> = ();
3558        #[cfg(test)]
3559        #[allow(dead_code, unreachable_patterns)]
3560        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3561            match _t {
3562                alloy_sol_types::private::AssertTypeEq::<
3563                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3564                >(_) => {},
3565            }
3566        }
3567        #[automatically_derived]
3568        #[doc(hidden)]
3569        impl ::core::convert::From<ValidatorInactive> for UnderlyingRustTuple<'_> {
3570            fn from(value: ValidatorInactive) -> Self {
3571                ()
3572            }
3573        }
3574        #[automatically_derived]
3575        #[doc(hidden)]
3576        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ValidatorInactive {
3577            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3578                Self {}
3579            }
3580        }
3581        #[automatically_derived]
3582        impl alloy_sol_types::SolError for ValidatorInactive {
3583            type Parameters<'a> = UnderlyingSolTuple<'a>;
3584            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3585            const SIGNATURE: &'static str = "ValidatorInactive()";
3586            const SELECTOR: [u8; 4] = [80u8, 138u8, 121u8, 63u8];
3587            #[inline]
3588            fn new<'a>(
3589                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3590            ) -> Self {
3591                tuple.into()
3592            }
3593            #[inline]
3594            fn tokenize(&self) -> Self::Token<'_> {
3595                ()
3596            }
3597        }
3598    };
3599    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3600    /**Custom error with signature `ValidatorNotExited()` and selector `0xf25314a6`.
3601    ```solidity
3602    error ValidatorNotExited();
3603    ```*/
3604    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3605    #[derive(Clone)]
3606    pub struct ValidatorNotExited {}
3607    #[allow(
3608        non_camel_case_types,
3609        non_snake_case,
3610        clippy::pub_underscore_fields,
3611        clippy::style
3612    )]
3613    const _: () = {
3614        use alloy::sol_types as alloy_sol_types;
3615        #[doc(hidden)]
3616        type UnderlyingSolTuple<'a> = ();
3617        #[doc(hidden)]
3618        type UnderlyingRustTuple<'a> = ();
3619        #[cfg(test)]
3620        #[allow(dead_code, unreachable_patterns)]
3621        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3622            match _t {
3623                alloy_sol_types::private::AssertTypeEq::<
3624                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3625                >(_) => {},
3626            }
3627        }
3628        #[automatically_derived]
3629        #[doc(hidden)]
3630        impl ::core::convert::From<ValidatorNotExited> for UnderlyingRustTuple<'_> {
3631            fn from(value: ValidatorNotExited) -> Self {
3632                ()
3633            }
3634        }
3635        #[automatically_derived]
3636        #[doc(hidden)]
3637        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ValidatorNotExited {
3638            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3639                Self {}
3640            }
3641        }
3642        #[automatically_derived]
3643        impl alloy_sol_types::SolError for ValidatorNotExited {
3644            type Parameters<'a> = UnderlyingSolTuple<'a>;
3645            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3646            const SIGNATURE: &'static str = "ValidatorNotExited()";
3647            const SELECTOR: [u8; 4] = [242u8, 83u8, 20u8, 166u8];
3648            #[inline]
3649            fn new<'a>(
3650                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3651            ) -> Self {
3652                tuple.into()
3653            }
3654            #[inline]
3655            fn tokenize(&self) -> Self::Token<'_> {
3656                ()
3657            }
3658        }
3659    };
3660    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3661    /**Custom error with signature `ZeroAddress()` and selector `0xd92e233d`.
3662    ```solidity
3663    error ZeroAddress();
3664    ```*/
3665    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3666    #[derive(Clone)]
3667    pub struct ZeroAddress {}
3668    #[allow(
3669        non_camel_case_types,
3670        non_snake_case,
3671        clippy::pub_underscore_fields,
3672        clippy::style
3673    )]
3674    const _: () = {
3675        use alloy::sol_types as alloy_sol_types;
3676        #[doc(hidden)]
3677        type UnderlyingSolTuple<'a> = ();
3678        #[doc(hidden)]
3679        type UnderlyingRustTuple<'a> = ();
3680        #[cfg(test)]
3681        #[allow(dead_code, unreachable_patterns)]
3682        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3683            match _t {
3684                alloy_sol_types::private::AssertTypeEq::<
3685                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3686                >(_) => {},
3687            }
3688        }
3689        #[automatically_derived]
3690        #[doc(hidden)]
3691        impl ::core::convert::From<ZeroAddress> for UnderlyingRustTuple<'_> {
3692            fn from(value: ZeroAddress) -> Self {
3693                ()
3694            }
3695        }
3696        #[automatically_derived]
3697        #[doc(hidden)]
3698        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ZeroAddress {
3699            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3700                Self {}
3701            }
3702        }
3703        #[automatically_derived]
3704        impl alloy_sol_types::SolError for ZeroAddress {
3705            type Parameters<'a> = UnderlyingSolTuple<'a>;
3706            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3707            const SIGNATURE: &'static str = "ZeroAddress()";
3708            const SELECTOR: [u8; 4] = [217u8, 46u8, 35u8, 61u8];
3709            #[inline]
3710            fn new<'a>(
3711                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3712            ) -> Self {
3713                tuple.into()
3714            }
3715            #[inline]
3716            fn tokenize(&self) -> Self::Token<'_> {
3717                ()
3718            }
3719        }
3720    };
3721    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3722    /**Custom error with signature `ZeroAmount()` and selector `0x1f2a2005`.
3723    ```solidity
3724    error ZeroAmount();
3725    ```*/
3726    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3727    #[derive(Clone)]
3728    pub struct ZeroAmount {}
3729    #[allow(
3730        non_camel_case_types,
3731        non_snake_case,
3732        clippy::pub_underscore_fields,
3733        clippy::style
3734    )]
3735    const _: () = {
3736        use alloy::sol_types as alloy_sol_types;
3737        #[doc(hidden)]
3738        type UnderlyingSolTuple<'a> = ();
3739        #[doc(hidden)]
3740        type UnderlyingRustTuple<'a> = ();
3741        #[cfg(test)]
3742        #[allow(dead_code, unreachable_patterns)]
3743        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3744            match _t {
3745                alloy_sol_types::private::AssertTypeEq::<
3746                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3747                >(_) => {},
3748            }
3749        }
3750        #[automatically_derived]
3751        #[doc(hidden)]
3752        impl ::core::convert::From<ZeroAmount> for UnderlyingRustTuple<'_> {
3753            fn from(value: ZeroAmount) -> Self {
3754                ()
3755            }
3756        }
3757        #[automatically_derived]
3758        #[doc(hidden)]
3759        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ZeroAmount {
3760            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3761                Self {}
3762            }
3763        }
3764        #[automatically_derived]
3765        impl alloy_sol_types::SolError for ZeroAmount {
3766            type Parameters<'a> = UnderlyingSolTuple<'a>;
3767            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3768            const SIGNATURE: &'static str = "ZeroAmount()";
3769            const SELECTOR: [u8; 4] = [31u8, 42u8, 32u8, 5u8];
3770            #[inline]
3771            fn new<'a>(
3772                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3773            ) -> Self {
3774                tuple.into()
3775            }
3776            #[inline]
3777            fn tokenize(&self) -> Self::Token<'_> {
3778                ()
3779            }
3780        }
3781    };
3782    #[derive()]
3783    /**Event with signature `ConsensusKeysUpdated(address,(uint256,uint256,uint256,uint256),(uint256,uint256))` and selector `0x80d8a4a1663328a998d4555ba21d8bba6ef1576a8c5e9d27f9c545f1a3d52b1d`.
3784    ```solidity
3785    event ConsensusKeysUpdated(address indexed account, BN254.G2Point blsVK, EdOnBN254.EdOnBN254Point schnorrVK);
3786    ```*/
3787    #[allow(
3788        non_camel_case_types,
3789        non_snake_case,
3790        clippy::pub_underscore_fields,
3791        clippy::style
3792    )]
3793    #[derive(Clone)]
3794    pub struct ConsensusKeysUpdated {
3795        #[allow(missing_docs)]
3796        pub account: alloy::sol_types::private::Address,
3797        #[allow(missing_docs)]
3798        pub blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
3799        #[allow(missing_docs)]
3800        pub schnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
3801    }
3802    #[allow(
3803        non_camel_case_types,
3804        non_snake_case,
3805        clippy::pub_underscore_fields,
3806        clippy::style
3807    )]
3808    const _: () = {
3809        use alloy::sol_types as alloy_sol_types;
3810        #[automatically_derived]
3811        impl alloy_sol_types::SolEvent for ConsensusKeysUpdated {
3812            type DataTuple<'a> = (BN254::G2Point, EdOnBN254::EdOnBN254Point);
3813            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3814            type TopicList = (
3815                alloy_sol_types::sol_data::FixedBytes<32>,
3816                alloy::sol_types::sol_data::Address,
3817            );
3818            const SIGNATURE: &'static str =
3819                "ConsensusKeysUpdated(address,(uint256,uint256,uint256,uint256),(uint256,uint256))";
3820            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
3821                alloy_sol_types::private::B256::new([
3822                    128u8, 216u8, 164u8, 161u8, 102u8, 51u8, 40u8, 169u8, 152u8, 212u8, 85u8, 91u8,
3823                    162u8, 29u8, 139u8, 186u8, 110u8, 241u8, 87u8, 106u8, 140u8, 94u8, 157u8, 39u8,
3824                    249u8, 197u8, 69u8, 241u8, 163u8, 213u8, 43u8, 29u8,
3825                ]);
3826            const ANONYMOUS: bool = false;
3827            #[allow(unused_variables)]
3828            #[inline]
3829            fn new(
3830                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3831                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3832            ) -> Self {
3833                Self {
3834                    account: topics.1,
3835                    blsVK: data.0,
3836                    schnorrVK: data.1,
3837                }
3838            }
3839            #[inline]
3840            fn check_signature(
3841                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3842            ) -> alloy_sol_types::Result<()> {
3843                if topics.0 != Self::SIGNATURE_HASH {
3844                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
3845                        Self::SIGNATURE,
3846                        topics.0,
3847                        Self::SIGNATURE_HASH,
3848                    ));
3849                }
3850                Ok(())
3851            }
3852            #[inline]
3853            fn tokenize_body(&self) -> Self::DataToken<'_> {
3854                (
3855                    <BN254::G2Point as alloy_sol_types::SolType>::tokenize(&self.blsVK),
3856                    <EdOnBN254::EdOnBN254Point as alloy_sol_types::SolType>::tokenize(
3857                        &self.schnorrVK,
3858                    ),
3859                )
3860            }
3861            #[inline]
3862            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3863                (Self::SIGNATURE_HASH.into(), self.account.clone())
3864            }
3865            #[inline]
3866            fn encode_topics_raw(
3867                &self,
3868                out: &mut [alloy_sol_types::abi::token::WordToken],
3869            ) -> alloy_sol_types::Result<()> {
3870                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3871                    return Err(alloy_sol_types::Error::Overrun);
3872                }
3873                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
3874                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
3875                    &self.account,
3876                );
3877                Ok(())
3878            }
3879        }
3880        #[automatically_derived]
3881        impl alloy_sol_types::private::IntoLogData for ConsensusKeysUpdated {
3882            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3883                From::from(self)
3884            }
3885            fn into_log_data(self) -> alloy_sol_types::private::LogData {
3886                From::from(&self)
3887            }
3888        }
3889        #[automatically_derived]
3890        impl From<&ConsensusKeysUpdated> for alloy_sol_types::private::LogData {
3891            #[inline]
3892            fn from(this: &ConsensusKeysUpdated) -> alloy_sol_types::private::LogData {
3893                alloy_sol_types::SolEvent::encode_log_data(this)
3894            }
3895        }
3896    };
3897    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3898    /**Event with signature `Delegated(address,address,uint256)` and selector `0xe5541a6b6103d4fa7e021ed54fad39c66f27a76bd13d374cf6240ae6bd0bb72b`.
3899    ```solidity
3900    event Delegated(address indexed delegator, address indexed validator, uint256 amount);
3901    ```*/
3902    #[allow(
3903        non_camel_case_types,
3904        non_snake_case,
3905        clippy::pub_underscore_fields,
3906        clippy::style
3907    )]
3908    #[derive(Clone)]
3909    pub struct Delegated {
3910        #[allow(missing_docs)]
3911        pub delegator: alloy::sol_types::private::Address,
3912        #[allow(missing_docs)]
3913        pub validator: alloy::sol_types::private::Address,
3914        #[allow(missing_docs)]
3915        pub amount: alloy::sol_types::private::primitives::aliases::U256,
3916    }
3917    #[allow(
3918        non_camel_case_types,
3919        non_snake_case,
3920        clippy::pub_underscore_fields,
3921        clippy::style
3922    )]
3923    const _: () = {
3924        use alloy::sol_types as alloy_sol_types;
3925        #[automatically_derived]
3926        impl alloy_sol_types::SolEvent for Delegated {
3927            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3928            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3929            type TopicList = (
3930                alloy_sol_types::sol_data::FixedBytes<32>,
3931                alloy::sol_types::sol_data::Address,
3932                alloy::sol_types::sol_data::Address,
3933            );
3934            const SIGNATURE: &'static str = "Delegated(address,address,uint256)";
3935            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
3936                alloy_sol_types::private::B256::new([
3937                    229u8, 84u8, 26u8, 107u8, 97u8, 3u8, 212u8, 250u8, 126u8, 2u8, 30u8, 213u8,
3938                    79u8, 173u8, 57u8, 198u8, 111u8, 39u8, 167u8, 107u8, 209u8, 61u8, 55u8, 76u8,
3939                    246u8, 36u8, 10u8, 230u8, 189u8, 11u8, 183u8, 43u8,
3940                ]);
3941            const ANONYMOUS: bool = false;
3942            #[allow(unused_variables)]
3943            #[inline]
3944            fn new(
3945                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3946                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3947            ) -> Self {
3948                Self {
3949                    delegator: topics.1,
3950                    validator: topics.2,
3951                    amount: data.0,
3952                }
3953            }
3954            #[inline]
3955            fn check_signature(
3956                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3957            ) -> alloy_sol_types::Result<()> {
3958                if topics.0 != Self::SIGNATURE_HASH {
3959                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
3960                        Self::SIGNATURE,
3961                        topics.0,
3962                        Self::SIGNATURE_HASH,
3963                    ));
3964                }
3965                Ok(())
3966            }
3967            #[inline]
3968            fn tokenize_body(&self) -> Self::DataToken<'_> {
3969                (
3970                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
3971                        &self.amount,
3972                    ),
3973                )
3974            }
3975            #[inline]
3976            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3977                (
3978                    Self::SIGNATURE_HASH.into(),
3979                    self.delegator.clone(),
3980                    self.validator.clone(),
3981                )
3982            }
3983            #[inline]
3984            fn encode_topics_raw(
3985                &self,
3986                out: &mut [alloy_sol_types::abi::token::WordToken],
3987            ) -> alloy_sol_types::Result<()> {
3988                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3989                    return Err(alloy_sol_types::Error::Overrun);
3990                }
3991                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
3992                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
3993                    &self.delegator,
3994                );
3995                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
3996                    &self.validator,
3997                );
3998                Ok(())
3999            }
4000        }
4001        #[automatically_derived]
4002        impl alloy_sol_types::private::IntoLogData for Delegated {
4003            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4004                From::from(self)
4005            }
4006            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4007                From::from(&self)
4008            }
4009        }
4010        #[automatically_derived]
4011        impl From<&Delegated> for alloy_sol_types::private::LogData {
4012            #[inline]
4013            fn from(this: &Delegated) -> alloy_sol_types::private::LogData {
4014                alloy_sol_types::SolEvent::encode_log_data(this)
4015            }
4016        }
4017    };
4018    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4019    /**Event with signature `Initialized(uint64)` and selector `0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2`.
4020    ```solidity
4021    event Initialized(uint64 version);
4022    ```*/
4023    #[allow(
4024        non_camel_case_types,
4025        non_snake_case,
4026        clippy::pub_underscore_fields,
4027        clippy::style
4028    )]
4029    #[derive(Clone)]
4030    pub struct Initialized {
4031        #[allow(missing_docs)]
4032        pub version: u64,
4033    }
4034    #[allow(
4035        non_camel_case_types,
4036        non_snake_case,
4037        clippy::pub_underscore_fields,
4038        clippy::style
4039    )]
4040    const _: () = {
4041        use alloy::sol_types as alloy_sol_types;
4042        #[automatically_derived]
4043        impl alloy_sol_types::SolEvent for Initialized {
4044            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
4045            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4046            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
4047            const SIGNATURE: &'static str = "Initialized(uint64)";
4048            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
4049                alloy_sol_types::private::B256::new([
4050                    199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8,
4051                    244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8,
4052                    209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
4053                ]);
4054            const ANONYMOUS: bool = false;
4055            #[allow(unused_variables)]
4056            #[inline]
4057            fn new(
4058                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4059                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4060            ) -> Self {
4061                Self { version: data.0 }
4062            }
4063            #[inline]
4064            fn check_signature(
4065                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4066            ) -> alloy_sol_types::Result<()> {
4067                if topics.0 != Self::SIGNATURE_HASH {
4068                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
4069                        Self::SIGNATURE,
4070                        topics.0,
4071                        Self::SIGNATURE_HASH,
4072                    ));
4073                }
4074                Ok(())
4075            }
4076            #[inline]
4077            fn tokenize_body(&self) -> Self::DataToken<'_> {
4078                (
4079                    <alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
4080                        &self.version,
4081                    ),
4082                )
4083            }
4084            #[inline]
4085            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4086                (Self::SIGNATURE_HASH.into(),)
4087            }
4088            #[inline]
4089            fn encode_topics_raw(
4090                &self,
4091                out: &mut [alloy_sol_types::abi::token::WordToken],
4092            ) -> alloy_sol_types::Result<()> {
4093                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4094                    return Err(alloy_sol_types::Error::Overrun);
4095                }
4096                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
4097                Ok(())
4098            }
4099        }
4100        #[automatically_derived]
4101        impl alloy_sol_types::private::IntoLogData for Initialized {
4102            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4103                From::from(self)
4104            }
4105            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4106                From::from(&self)
4107            }
4108        }
4109        #[automatically_derived]
4110        impl From<&Initialized> for alloy_sol_types::private::LogData {
4111            #[inline]
4112            fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
4113                alloy_sol_types::SolEvent::encode_log_data(this)
4114            }
4115        }
4116    };
4117    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4118    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
4119    ```solidity
4120    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
4121    ```*/
4122    #[allow(
4123        non_camel_case_types,
4124        non_snake_case,
4125        clippy::pub_underscore_fields,
4126        clippy::style
4127    )]
4128    #[derive(Clone)]
4129    pub struct OwnershipTransferred {
4130        #[allow(missing_docs)]
4131        pub previousOwner: alloy::sol_types::private::Address,
4132        #[allow(missing_docs)]
4133        pub newOwner: alloy::sol_types::private::Address,
4134    }
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        #[automatically_derived]
4144        impl alloy_sol_types::SolEvent for OwnershipTransferred {
4145            type DataTuple<'a> = ();
4146            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4147            type TopicList = (
4148                alloy_sol_types::sol_data::FixedBytes<32>,
4149                alloy::sol_types::sol_data::Address,
4150                alloy::sol_types::sol_data::Address,
4151            );
4152            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
4153            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
4154                alloy_sol_types::private::B256::new([
4155                    139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8,
4156                    208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8,
4157                    175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
4158                ]);
4159            const ANONYMOUS: bool = false;
4160            #[allow(unused_variables)]
4161            #[inline]
4162            fn new(
4163                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4164                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4165            ) -> Self {
4166                Self {
4167                    previousOwner: topics.1,
4168                    newOwner: topics.2,
4169                }
4170            }
4171            #[inline]
4172            fn check_signature(
4173                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4174            ) -> alloy_sol_types::Result<()> {
4175                if topics.0 != Self::SIGNATURE_HASH {
4176                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
4177                        Self::SIGNATURE,
4178                        topics.0,
4179                        Self::SIGNATURE_HASH,
4180                    ));
4181                }
4182                Ok(())
4183            }
4184            #[inline]
4185            fn tokenize_body(&self) -> Self::DataToken<'_> {
4186                ()
4187            }
4188            #[inline]
4189            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4190                (
4191                    Self::SIGNATURE_HASH.into(),
4192                    self.previousOwner.clone(),
4193                    self.newOwner.clone(),
4194                )
4195            }
4196            #[inline]
4197            fn encode_topics_raw(
4198                &self,
4199                out: &mut [alloy_sol_types::abi::token::WordToken],
4200            ) -> alloy_sol_types::Result<()> {
4201                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4202                    return Err(alloy_sol_types::Error::Overrun);
4203                }
4204                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
4205                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4206                    &self.previousOwner,
4207                );
4208                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4209                    &self.newOwner,
4210                );
4211                Ok(())
4212            }
4213        }
4214        #[automatically_derived]
4215        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
4216            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4217                From::from(self)
4218            }
4219            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4220                From::from(&self)
4221            }
4222        }
4223        #[automatically_derived]
4224        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
4225            #[inline]
4226            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
4227                alloy_sol_types::SolEvent::encode_log_data(this)
4228            }
4229        }
4230    };
4231    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4232    /**Event with signature `Undelegated(address,address,uint256)` and selector `0x4d10bd049775c77bd7f255195afba5088028ecb3c7c277d393ccff7934f2f92c`.
4233    ```solidity
4234    event Undelegated(address indexed delegator, address indexed validator, uint256 amount);
4235    ```*/
4236    #[allow(
4237        non_camel_case_types,
4238        non_snake_case,
4239        clippy::pub_underscore_fields,
4240        clippy::style
4241    )]
4242    #[derive(Clone)]
4243    pub struct Undelegated {
4244        #[allow(missing_docs)]
4245        pub delegator: alloy::sol_types::private::Address,
4246        #[allow(missing_docs)]
4247        pub validator: alloy::sol_types::private::Address,
4248        #[allow(missing_docs)]
4249        pub amount: alloy::sol_types::private::primitives::aliases::U256,
4250    }
4251    #[allow(
4252        non_camel_case_types,
4253        non_snake_case,
4254        clippy::pub_underscore_fields,
4255        clippy::style
4256    )]
4257    const _: () = {
4258        use alloy::sol_types as alloy_sol_types;
4259        #[automatically_derived]
4260        impl alloy_sol_types::SolEvent for Undelegated {
4261            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4262            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4263            type TopicList = (
4264                alloy_sol_types::sol_data::FixedBytes<32>,
4265                alloy::sol_types::sol_data::Address,
4266                alloy::sol_types::sol_data::Address,
4267            );
4268            const SIGNATURE: &'static str = "Undelegated(address,address,uint256)";
4269            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
4270                alloy_sol_types::private::B256::new([
4271                    77u8, 16u8, 189u8, 4u8, 151u8, 117u8, 199u8, 123u8, 215u8, 242u8, 85u8, 25u8,
4272                    90u8, 251u8, 165u8, 8u8, 128u8, 40u8, 236u8, 179u8, 199u8, 194u8, 119u8, 211u8,
4273                    147u8, 204u8, 255u8, 121u8, 52u8, 242u8, 249u8, 44u8,
4274                ]);
4275            const ANONYMOUS: bool = false;
4276            #[allow(unused_variables)]
4277            #[inline]
4278            fn new(
4279                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4280                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4281            ) -> Self {
4282                Self {
4283                    delegator: topics.1,
4284                    validator: topics.2,
4285                    amount: data.0,
4286                }
4287            }
4288            #[inline]
4289            fn check_signature(
4290                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4291            ) -> alloy_sol_types::Result<()> {
4292                if topics.0 != Self::SIGNATURE_HASH {
4293                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
4294                        Self::SIGNATURE,
4295                        topics.0,
4296                        Self::SIGNATURE_HASH,
4297                    ));
4298                }
4299                Ok(())
4300            }
4301            #[inline]
4302            fn tokenize_body(&self) -> Self::DataToken<'_> {
4303                (
4304                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
4305                        &self.amount,
4306                    ),
4307                )
4308            }
4309            #[inline]
4310            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4311                (
4312                    Self::SIGNATURE_HASH.into(),
4313                    self.delegator.clone(),
4314                    self.validator.clone(),
4315                )
4316            }
4317            #[inline]
4318            fn encode_topics_raw(
4319                &self,
4320                out: &mut [alloy_sol_types::abi::token::WordToken],
4321            ) -> alloy_sol_types::Result<()> {
4322                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4323                    return Err(alloy_sol_types::Error::Overrun);
4324                }
4325                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
4326                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4327                    &self.delegator,
4328                );
4329                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4330                    &self.validator,
4331                );
4332                Ok(())
4333            }
4334        }
4335        #[automatically_derived]
4336        impl alloy_sol_types::private::IntoLogData for Undelegated {
4337            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4338                From::from(self)
4339            }
4340            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4341                From::from(&self)
4342            }
4343        }
4344        #[automatically_derived]
4345        impl From<&Undelegated> for alloy_sol_types::private::LogData {
4346            #[inline]
4347            fn from(this: &Undelegated) -> alloy_sol_types::private::LogData {
4348                alloy_sol_types::SolEvent::encode_log_data(this)
4349            }
4350        }
4351    };
4352    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4353    /**Event with signature `Upgrade(address)` and selector `0xf78721226efe9a1bb678189a16d1554928b9f2192e2cb93eeda83b79fa40007d`.
4354    ```solidity
4355    event Upgrade(address implementation);
4356    ```*/
4357    #[allow(
4358        non_camel_case_types,
4359        non_snake_case,
4360        clippy::pub_underscore_fields,
4361        clippy::style
4362    )]
4363    #[derive(Clone)]
4364    pub struct Upgrade {
4365        #[allow(missing_docs)]
4366        pub implementation: alloy::sol_types::private::Address,
4367    }
4368    #[allow(
4369        non_camel_case_types,
4370        non_snake_case,
4371        clippy::pub_underscore_fields,
4372        clippy::style
4373    )]
4374    const _: () = {
4375        use alloy::sol_types as alloy_sol_types;
4376        #[automatically_derived]
4377        impl alloy_sol_types::SolEvent for Upgrade {
4378            type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
4379            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4380            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
4381            const SIGNATURE: &'static str = "Upgrade(address)";
4382            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
4383                alloy_sol_types::private::B256::new([
4384                    247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8,
4385                    22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8,
4386                    237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
4387                ]);
4388            const ANONYMOUS: bool = false;
4389            #[allow(unused_variables)]
4390            #[inline]
4391            fn new(
4392                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4393                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4394            ) -> Self {
4395                Self {
4396                    implementation: data.0,
4397                }
4398            }
4399            #[inline]
4400            fn check_signature(
4401                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4402            ) -> alloy_sol_types::Result<()> {
4403                if topics.0 != Self::SIGNATURE_HASH {
4404                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
4405                        Self::SIGNATURE,
4406                        topics.0,
4407                        Self::SIGNATURE_HASH,
4408                    ));
4409                }
4410                Ok(())
4411            }
4412            #[inline]
4413            fn tokenize_body(&self) -> Self::DataToken<'_> {
4414                (
4415                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4416                        &self.implementation,
4417                    ),
4418                )
4419            }
4420            #[inline]
4421            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4422                (Self::SIGNATURE_HASH.into(),)
4423            }
4424            #[inline]
4425            fn encode_topics_raw(
4426                &self,
4427                out: &mut [alloy_sol_types::abi::token::WordToken],
4428            ) -> alloy_sol_types::Result<()> {
4429                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4430                    return Err(alloy_sol_types::Error::Overrun);
4431                }
4432                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
4433                Ok(())
4434            }
4435        }
4436        #[automatically_derived]
4437        impl alloy_sol_types::private::IntoLogData for Upgrade {
4438            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4439                From::from(self)
4440            }
4441            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4442                From::from(&self)
4443            }
4444        }
4445        #[automatically_derived]
4446        impl From<&Upgrade> for alloy_sol_types::private::LogData {
4447            #[inline]
4448            fn from(this: &Upgrade) -> alloy_sol_types::private::LogData {
4449                alloy_sol_types::SolEvent::encode_log_data(this)
4450            }
4451        }
4452    };
4453    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4454    /**Event with signature `Upgraded(address)` and selector `0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b`.
4455    ```solidity
4456    event Upgraded(address indexed implementation);
4457    ```*/
4458    #[allow(
4459        non_camel_case_types,
4460        non_snake_case,
4461        clippy::pub_underscore_fields,
4462        clippy::style
4463    )]
4464    #[derive(Clone)]
4465    pub struct Upgraded {
4466        #[allow(missing_docs)]
4467        pub implementation: alloy::sol_types::private::Address,
4468    }
4469    #[allow(
4470        non_camel_case_types,
4471        non_snake_case,
4472        clippy::pub_underscore_fields,
4473        clippy::style
4474    )]
4475    const _: () = {
4476        use alloy::sol_types as alloy_sol_types;
4477        #[automatically_derived]
4478        impl alloy_sol_types::SolEvent for Upgraded {
4479            type DataTuple<'a> = ();
4480            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4481            type TopicList = (
4482                alloy_sol_types::sol_data::FixedBytes<32>,
4483                alloy::sol_types::sol_data::Address,
4484            );
4485            const SIGNATURE: &'static str = "Upgraded(address)";
4486            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
4487                alloy_sol_types::private::B256::new([
4488                    188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8,
4489                    179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8,
4490                    192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
4491                ]);
4492            const ANONYMOUS: bool = false;
4493            #[allow(unused_variables)]
4494            #[inline]
4495            fn new(
4496                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4497                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4498            ) -> Self {
4499                Self {
4500                    implementation: topics.1,
4501                }
4502            }
4503            #[inline]
4504            fn check_signature(
4505                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4506            ) -> alloy_sol_types::Result<()> {
4507                if topics.0 != Self::SIGNATURE_HASH {
4508                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
4509                        Self::SIGNATURE,
4510                        topics.0,
4511                        Self::SIGNATURE_HASH,
4512                    ));
4513                }
4514                Ok(())
4515            }
4516            #[inline]
4517            fn tokenize_body(&self) -> Self::DataToken<'_> {
4518                ()
4519            }
4520            #[inline]
4521            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4522                (Self::SIGNATURE_HASH.into(), self.implementation.clone())
4523            }
4524            #[inline]
4525            fn encode_topics_raw(
4526                &self,
4527                out: &mut [alloy_sol_types::abi::token::WordToken],
4528            ) -> alloy_sol_types::Result<()> {
4529                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4530                    return Err(alloy_sol_types::Error::Overrun);
4531                }
4532                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
4533                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4534                    &self.implementation,
4535                );
4536                Ok(())
4537            }
4538        }
4539        #[automatically_derived]
4540        impl alloy_sol_types::private::IntoLogData for Upgraded {
4541            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4542                From::from(self)
4543            }
4544            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4545                From::from(&self)
4546            }
4547        }
4548        #[automatically_derived]
4549        impl From<&Upgraded> for alloy_sol_types::private::LogData {
4550            #[inline]
4551            fn from(this: &Upgraded) -> alloy_sol_types::private::LogData {
4552                alloy_sol_types::SolEvent::encode_log_data(this)
4553            }
4554        }
4555    };
4556    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4557    /**Event with signature `ValidatorExit(address)` and selector `0xfb24305354c87762d557487ae4a564e8d03ecbb9a97dd8afff8e1f6fcaf0dd16`.
4558    ```solidity
4559    event ValidatorExit(address indexed validator);
4560    ```*/
4561    #[allow(
4562        non_camel_case_types,
4563        non_snake_case,
4564        clippy::pub_underscore_fields,
4565        clippy::style
4566    )]
4567    #[derive(Clone)]
4568    pub struct ValidatorExit {
4569        #[allow(missing_docs)]
4570        pub validator: alloy::sol_types::private::Address,
4571    }
4572    #[allow(
4573        non_camel_case_types,
4574        non_snake_case,
4575        clippy::pub_underscore_fields,
4576        clippy::style
4577    )]
4578    const _: () = {
4579        use alloy::sol_types as alloy_sol_types;
4580        #[automatically_derived]
4581        impl alloy_sol_types::SolEvent for ValidatorExit {
4582            type DataTuple<'a> = ();
4583            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4584            type TopicList = (
4585                alloy_sol_types::sol_data::FixedBytes<32>,
4586                alloy::sol_types::sol_data::Address,
4587            );
4588            const SIGNATURE: &'static str = "ValidatorExit(address)";
4589            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
4590                alloy_sol_types::private::B256::new([
4591                    251u8, 36u8, 48u8, 83u8, 84u8, 200u8, 119u8, 98u8, 213u8, 87u8, 72u8, 122u8,
4592                    228u8, 165u8, 100u8, 232u8, 208u8, 62u8, 203u8, 185u8, 169u8, 125u8, 216u8,
4593                    175u8, 255u8, 142u8, 31u8, 111u8, 202u8, 240u8, 221u8, 22u8,
4594                ]);
4595            const ANONYMOUS: bool = false;
4596            #[allow(unused_variables)]
4597            #[inline]
4598            fn new(
4599                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4600                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4601            ) -> Self {
4602                Self {
4603                    validator: topics.1,
4604                }
4605            }
4606            #[inline]
4607            fn check_signature(
4608                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4609            ) -> alloy_sol_types::Result<()> {
4610                if topics.0 != Self::SIGNATURE_HASH {
4611                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
4612                        Self::SIGNATURE,
4613                        topics.0,
4614                        Self::SIGNATURE_HASH,
4615                    ));
4616                }
4617                Ok(())
4618            }
4619            #[inline]
4620            fn tokenize_body(&self) -> Self::DataToken<'_> {
4621                ()
4622            }
4623            #[inline]
4624            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4625                (Self::SIGNATURE_HASH.into(), self.validator.clone())
4626            }
4627            #[inline]
4628            fn encode_topics_raw(
4629                &self,
4630                out: &mut [alloy_sol_types::abi::token::WordToken],
4631            ) -> alloy_sol_types::Result<()> {
4632                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4633                    return Err(alloy_sol_types::Error::Overrun);
4634                }
4635                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
4636                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4637                    &self.validator,
4638                );
4639                Ok(())
4640            }
4641        }
4642        #[automatically_derived]
4643        impl alloy_sol_types::private::IntoLogData for ValidatorExit {
4644            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4645                From::from(self)
4646            }
4647            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4648                From::from(&self)
4649            }
4650        }
4651        #[automatically_derived]
4652        impl From<&ValidatorExit> for alloy_sol_types::private::LogData {
4653            #[inline]
4654            fn from(this: &ValidatorExit) -> alloy_sol_types::private::LogData {
4655                alloy_sol_types::SolEvent::encode_log_data(this)
4656            }
4657        }
4658    };
4659    #[derive()]
4660    /**Event with signature `ValidatorRegistered(address,(uint256,uint256,uint256,uint256),(uint256,uint256),uint16)` and selector `0xf6e8359c57520b469634736bfc3bb7ec5cbd1a0bd28b10a8275793bb730b797f`.
4661    ```solidity
4662    event ValidatorRegistered(address indexed account, BN254.G2Point blsVk, EdOnBN254.EdOnBN254Point schnorrVk, uint16 commission);
4663    ```*/
4664    #[allow(
4665        non_camel_case_types,
4666        non_snake_case,
4667        clippy::pub_underscore_fields,
4668        clippy::style
4669    )]
4670    #[derive(Clone)]
4671    pub struct ValidatorRegistered {
4672        #[allow(missing_docs)]
4673        pub account: alloy::sol_types::private::Address,
4674        #[allow(missing_docs)]
4675        pub blsVk: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
4676        #[allow(missing_docs)]
4677        pub schnorrVk: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
4678        #[allow(missing_docs)]
4679        pub commission: u16,
4680    }
4681    #[allow(
4682        non_camel_case_types,
4683        non_snake_case,
4684        clippy::pub_underscore_fields,
4685        clippy::style
4686    )]
4687    const _: () = {
4688        use alloy::sol_types as alloy_sol_types;
4689        #[automatically_derived]
4690        impl alloy_sol_types::SolEvent for ValidatorRegistered {
4691            type DataTuple<'a> = (
4692                BN254::G2Point,
4693                EdOnBN254::EdOnBN254Point,
4694                alloy::sol_types::sol_data::Uint<16>,
4695            );
4696            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4697            type TopicList = (
4698                alloy_sol_types::sol_data::FixedBytes<32>,
4699                alloy::sol_types::sol_data::Address,
4700            );
4701            const SIGNATURE: &'static str = "ValidatorRegistered(address,(uint256,uint256,uint256,uint256),(uint256,uint256),uint16)";
4702            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
4703                alloy_sol_types::private::B256::new([
4704                    246u8, 232u8, 53u8, 156u8, 87u8, 82u8, 11u8, 70u8, 150u8, 52u8, 115u8, 107u8,
4705                    252u8, 59u8, 183u8, 236u8, 92u8, 189u8, 26u8, 11u8, 210u8, 139u8, 16u8, 168u8,
4706                    39u8, 87u8, 147u8, 187u8, 115u8, 11u8, 121u8, 127u8,
4707                ]);
4708            const ANONYMOUS: bool = false;
4709            #[allow(unused_variables)]
4710            #[inline]
4711            fn new(
4712                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4713                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4714            ) -> Self {
4715                Self {
4716                    account: topics.1,
4717                    blsVk: data.0,
4718                    schnorrVk: data.1,
4719                    commission: data.2,
4720                }
4721            }
4722            #[inline]
4723            fn check_signature(
4724                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4725            ) -> alloy_sol_types::Result<()> {
4726                if topics.0 != Self::SIGNATURE_HASH {
4727                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
4728                        Self::SIGNATURE,
4729                        topics.0,
4730                        Self::SIGNATURE_HASH,
4731                    ));
4732                }
4733                Ok(())
4734            }
4735            #[inline]
4736            fn tokenize_body(&self) -> Self::DataToken<'_> {
4737                (
4738                    <BN254::G2Point as alloy_sol_types::SolType>::tokenize(&self.blsVk),
4739                    <EdOnBN254::EdOnBN254Point as alloy_sol_types::SolType>::tokenize(
4740                        &self.schnorrVk,
4741                    ),
4742                    <alloy::sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
4743                        &self.commission,
4744                    ),
4745                )
4746            }
4747            #[inline]
4748            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4749                (Self::SIGNATURE_HASH.into(), self.account.clone())
4750            }
4751            #[inline]
4752            fn encode_topics_raw(
4753                &self,
4754                out: &mut [alloy_sol_types::abi::token::WordToken],
4755            ) -> alloy_sol_types::Result<()> {
4756                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4757                    return Err(alloy_sol_types::Error::Overrun);
4758                }
4759                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
4760                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4761                    &self.account,
4762                );
4763                Ok(())
4764            }
4765        }
4766        #[automatically_derived]
4767        impl alloy_sol_types::private::IntoLogData for ValidatorRegistered {
4768            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4769                From::from(self)
4770            }
4771            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4772                From::from(&self)
4773            }
4774        }
4775        #[automatically_derived]
4776        impl From<&ValidatorRegistered> for alloy_sol_types::private::LogData {
4777            #[inline]
4778            fn from(this: &ValidatorRegistered) -> alloy_sol_types::private::LogData {
4779                alloy_sol_types::SolEvent::encode_log_data(this)
4780            }
4781        }
4782    };
4783    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4784    /**Event with signature `Withdrawal(address,uint256)` and selector `0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65`.
4785    ```solidity
4786    event Withdrawal(address indexed account, uint256 amount);
4787    ```*/
4788    #[allow(
4789        non_camel_case_types,
4790        non_snake_case,
4791        clippy::pub_underscore_fields,
4792        clippy::style
4793    )]
4794    #[derive(Clone)]
4795    pub struct Withdrawal {
4796        #[allow(missing_docs)]
4797        pub account: alloy::sol_types::private::Address,
4798        #[allow(missing_docs)]
4799        pub amount: alloy::sol_types::private::primitives::aliases::U256,
4800    }
4801    #[allow(
4802        non_camel_case_types,
4803        non_snake_case,
4804        clippy::pub_underscore_fields,
4805        clippy::style
4806    )]
4807    const _: () = {
4808        use alloy::sol_types as alloy_sol_types;
4809        #[automatically_derived]
4810        impl alloy_sol_types::SolEvent for Withdrawal {
4811            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4812            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4813            type TopicList = (
4814                alloy_sol_types::sol_data::FixedBytes<32>,
4815                alloy::sol_types::sol_data::Address,
4816            );
4817            const SIGNATURE: &'static str = "Withdrawal(address,uint256)";
4818            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
4819                alloy_sol_types::private::B256::new([
4820                    127u8, 207u8, 83u8, 44u8, 21u8, 240u8, 166u8, 219u8, 11u8, 214u8, 208u8, 224u8,
4821                    56u8, 190u8, 167u8, 29u8, 48u8, 216u8, 8u8, 199u8, 217u8, 140u8, 179u8, 191u8,
4822                    114u8, 104u8, 169u8, 91u8, 245u8, 8u8, 27u8, 101u8,
4823                ]);
4824            const ANONYMOUS: bool = false;
4825            #[allow(unused_variables)]
4826            #[inline]
4827            fn new(
4828                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4829                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4830            ) -> Self {
4831                Self {
4832                    account: topics.1,
4833                    amount: data.0,
4834                }
4835            }
4836            #[inline]
4837            fn check_signature(
4838                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4839            ) -> alloy_sol_types::Result<()> {
4840                if topics.0 != Self::SIGNATURE_HASH {
4841                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
4842                        Self::SIGNATURE,
4843                        topics.0,
4844                        Self::SIGNATURE_HASH,
4845                    ));
4846                }
4847                Ok(())
4848            }
4849            #[inline]
4850            fn tokenize_body(&self) -> Self::DataToken<'_> {
4851                (
4852                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
4853                        &self.amount,
4854                    ),
4855                )
4856            }
4857            #[inline]
4858            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4859                (Self::SIGNATURE_HASH.into(), self.account.clone())
4860            }
4861            #[inline]
4862            fn encode_topics_raw(
4863                &self,
4864                out: &mut [alloy_sol_types::abi::token::WordToken],
4865            ) -> alloy_sol_types::Result<()> {
4866                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4867                    return Err(alloy_sol_types::Error::Overrun);
4868                }
4869                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
4870                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4871                    &self.account,
4872                );
4873                Ok(())
4874            }
4875        }
4876        #[automatically_derived]
4877        impl alloy_sol_types::private::IntoLogData for Withdrawal {
4878            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4879                From::from(self)
4880            }
4881            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4882                From::from(&self)
4883            }
4884        }
4885        #[automatically_derived]
4886        impl From<&Withdrawal> for alloy_sol_types::private::LogData {
4887            #[inline]
4888            fn from(this: &Withdrawal) -> alloy_sol_types::private::LogData {
4889                alloy_sol_types::SolEvent::encode_log_data(this)
4890            }
4891        }
4892    };
4893    /**Constructor`.
4894    ```solidity
4895    constructor();
4896    ```*/
4897    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4898    #[derive(Clone)]
4899    pub struct constructorCall {}
4900    const _: () = {
4901        use alloy::sol_types as alloy_sol_types;
4902        {
4903            #[doc(hidden)]
4904            type UnderlyingSolTuple<'a> = ();
4905            #[doc(hidden)]
4906            type UnderlyingRustTuple<'a> = ();
4907            #[cfg(test)]
4908            #[allow(dead_code, unreachable_patterns)]
4909            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4910                match _t {
4911                    alloy_sol_types::private::AssertTypeEq::<
4912                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4913                    >(_) => {},
4914                }
4915            }
4916            #[automatically_derived]
4917            #[doc(hidden)]
4918            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
4919                fn from(value: constructorCall) -> Self {
4920                    ()
4921                }
4922            }
4923            #[automatically_derived]
4924            #[doc(hidden)]
4925            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
4926                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4927                    Self {}
4928                }
4929            }
4930        }
4931        #[automatically_derived]
4932        impl alloy_sol_types::SolConstructor for constructorCall {
4933            type Parameters<'a> = ();
4934            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4935            #[inline]
4936            fn new<'a>(
4937                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4938            ) -> Self {
4939                tuple.into()
4940            }
4941            #[inline]
4942            fn tokenize(&self) -> Self::Token<'_> {
4943                ()
4944            }
4945        }
4946    };
4947    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4948    /**Function with signature `UPGRADE_INTERFACE_VERSION()` and selector `0xad3cb1cc`.
4949    ```solidity
4950    function UPGRADE_INTERFACE_VERSION() external view returns (string memory);
4951    ```*/
4952    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4953    #[derive(Clone)]
4954    pub struct UPGRADE_INTERFACE_VERSIONCall {}
4955    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4956    ///Container type for the return parameters of the [`UPGRADE_INTERFACE_VERSION()`](UPGRADE_INTERFACE_VERSIONCall) function.
4957    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4958    #[derive(Clone)]
4959    pub struct UPGRADE_INTERFACE_VERSIONReturn {
4960        #[allow(missing_docs)]
4961        pub _0: alloy::sol_types::private::String,
4962    }
4963    #[allow(
4964        non_camel_case_types,
4965        non_snake_case,
4966        clippy::pub_underscore_fields,
4967        clippy::style
4968    )]
4969    const _: () = {
4970        use alloy::sol_types as alloy_sol_types;
4971        {
4972            #[doc(hidden)]
4973            type UnderlyingSolTuple<'a> = ();
4974            #[doc(hidden)]
4975            type UnderlyingRustTuple<'a> = ();
4976            #[cfg(test)]
4977            #[allow(dead_code, unreachable_patterns)]
4978            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4979                match _t {
4980                    alloy_sol_types::private::AssertTypeEq::<
4981                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4982                    >(_) => {},
4983                }
4984            }
4985            #[automatically_derived]
4986            #[doc(hidden)]
4987            impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONCall> for UnderlyingRustTuple<'_> {
4988                fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self {
4989                    ()
4990                }
4991            }
4992            #[automatically_derived]
4993            #[doc(hidden)]
4994            impl ::core::convert::From<UnderlyingRustTuple<'_>> for UPGRADE_INTERFACE_VERSIONCall {
4995                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4996                    Self {}
4997                }
4998            }
4999        }
5000        {
5001            #[doc(hidden)]
5002            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
5003            #[doc(hidden)]
5004            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
5005            #[cfg(test)]
5006            #[allow(dead_code, unreachable_patterns)]
5007            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5008                match _t {
5009                    alloy_sol_types::private::AssertTypeEq::<
5010                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5011                    >(_) => {},
5012                }
5013            }
5014            #[automatically_derived]
5015            #[doc(hidden)]
5016            impl ::core::convert::From<UPGRADE_INTERFACE_VERSIONReturn> for UnderlyingRustTuple<'_> {
5017                fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self {
5018                    (value._0,)
5019                }
5020            }
5021            #[automatically_derived]
5022            #[doc(hidden)]
5023            impl ::core::convert::From<UnderlyingRustTuple<'_>> for UPGRADE_INTERFACE_VERSIONReturn {
5024                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5025                    Self { _0: tuple.0 }
5026                }
5027            }
5028        }
5029        #[automatically_derived]
5030        impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall {
5031            type Parameters<'a> = ();
5032            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5033            type Return = UPGRADE_INTERFACE_VERSIONReturn;
5034            type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
5035            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5036            const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()";
5037            const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8];
5038            #[inline]
5039            fn new<'a>(
5040                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5041            ) -> Self {
5042                tuple.into()
5043            }
5044            #[inline]
5045            fn tokenize(&self) -> Self::Token<'_> {
5046                ()
5047            }
5048            #[inline]
5049            fn abi_decode_returns(
5050                data: &[u8],
5051                validate: bool,
5052            ) -> alloy_sol_types::Result<Self::Return> {
5053                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
5054                    data, validate,
5055                )
5056                .map(Into::into)
5057            }
5058        }
5059    };
5060    #[derive()]
5061    /**Function with signature `_hashBlsKey((uint256,uint256,uint256,uint256))` and selector `0x9b30a5e6`.
5062    ```solidity
5063    function _hashBlsKey(BN254.G2Point memory blsVK) external pure returns (bytes32);
5064    ```*/
5065    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5066    #[derive(Clone)]
5067    pub struct _hashBlsKeyCall {
5068        #[allow(missing_docs)]
5069        pub blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
5070    }
5071    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5072    ///Container type for the return parameters of the [`_hashBlsKey((uint256,uint256,uint256,uint256))`](_hashBlsKeyCall) function.
5073    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5074    #[derive(Clone)]
5075    pub struct _hashBlsKeyReturn {
5076        #[allow(missing_docs)]
5077        pub _0: alloy::sol_types::private::FixedBytes<32>,
5078    }
5079    #[allow(
5080        non_camel_case_types,
5081        non_snake_case,
5082        clippy::pub_underscore_fields,
5083        clippy::style
5084    )]
5085    const _: () = {
5086        use alloy::sol_types as alloy_sol_types;
5087        {
5088            #[doc(hidden)]
5089            type UnderlyingSolTuple<'a> = (BN254::G2Point,);
5090            #[doc(hidden)]
5091            type UnderlyingRustTuple<'a> =
5092                (<BN254::G2Point as alloy::sol_types::SolType>::RustType,);
5093            #[cfg(test)]
5094            #[allow(dead_code, unreachable_patterns)]
5095            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5096                match _t {
5097                    alloy_sol_types::private::AssertTypeEq::<
5098                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5099                    >(_) => {},
5100                }
5101            }
5102            #[automatically_derived]
5103            #[doc(hidden)]
5104            impl ::core::convert::From<_hashBlsKeyCall> for UnderlyingRustTuple<'_> {
5105                fn from(value: _hashBlsKeyCall) -> Self {
5106                    (value.blsVK,)
5107                }
5108            }
5109            #[automatically_derived]
5110            #[doc(hidden)]
5111            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _hashBlsKeyCall {
5112                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5113                    Self { blsVK: tuple.0 }
5114                }
5115            }
5116        }
5117        {
5118            #[doc(hidden)]
5119            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5120            #[doc(hidden)]
5121            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5122            #[cfg(test)]
5123            #[allow(dead_code, unreachable_patterns)]
5124            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5125                match _t {
5126                    alloy_sol_types::private::AssertTypeEq::<
5127                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5128                    >(_) => {},
5129                }
5130            }
5131            #[automatically_derived]
5132            #[doc(hidden)]
5133            impl ::core::convert::From<_hashBlsKeyReturn> for UnderlyingRustTuple<'_> {
5134                fn from(value: _hashBlsKeyReturn) -> Self {
5135                    (value._0,)
5136                }
5137            }
5138            #[automatically_derived]
5139            #[doc(hidden)]
5140            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _hashBlsKeyReturn {
5141                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5142                    Self { _0: tuple.0 }
5143                }
5144            }
5145        }
5146        #[automatically_derived]
5147        impl alloy_sol_types::SolCall for _hashBlsKeyCall {
5148            type Parameters<'a> = (BN254::G2Point,);
5149            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5150            type Return = _hashBlsKeyReturn;
5151            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5152            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5153            const SIGNATURE: &'static str = "_hashBlsKey((uint256,uint256,uint256,uint256))";
5154            const SELECTOR: [u8; 4] = [155u8, 48u8, 165u8, 230u8];
5155            #[inline]
5156            fn new<'a>(
5157                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5158            ) -> Self {
5159                tuple.into()
5160            }
5161            #[inline]
5162            fn tokenize(&self) -> Self::Token<'_> {
5163                (<BN254::G2Point as alloy_sol_types::SolType>::tokenize(
5164                    &self.blsVK,
5165                ),)
5166            }
5167            #[inline]
5168            fn abi_decode_returns(
5169                data: &[u8],
5170                validate: bool,
5171            ) -> alloy_sol_types::Result<Self::Return> {
5172                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
5173                    data, validate,
5174                )
5175                .map(Into::into)
5176            }
5177        }
5178    };
5179    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5180    /**Function with signature `blsKeys(bytes32)` and selector `0xb3e6ebd5`.
5181    ```solidity
5182    function blsKeys(bytes32 blsKeyHash) external view returns (bool used);
5183    ```*/
5184    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5185    #[derive(Clone)]
5186    pub struct blsKeysCall {
5187        #[allow(missing_docs)]
5188        pub blsKeyHash: alloy::sol_types::private::FixedBytes<32>,
5189    }
5190    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5191    ///Container type for the return parameters of the [`blsKeys(bytes32)`](blsKeysCall) function.
5192    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5193    #[derive(Clone)]
5194    pub struct blsKeysReturn {
5195        #[allow(missing_docs)]
5196        pub used: bool,
5197    }
5198    #[allow(
5199        non_camel_case_types,
5200        non_snake_case,
5201        clippy::pub_underscore_fields,
5202        clippy::style
5203    )]
5204    const _: () = {
5205        use alloy::sol_types as alloy_sol_types;
5206        {
5207            #[doc(hidden)]
5208            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5209            #[doc(hidden)]
5210            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5211            #[cfg(test)]
5212            #[allow(dead_code, unreachable_patterns)]
5213            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5214                match _t {
5215                    alloy_sol_types::private::AssertTypeEq::<
5216                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5217                    >(_) => {},
5218                }
5219            }
5220            #[automatically_derived]
5221            #[doc(hidden)]
5222            impl ::core::convert::From<blsKeysCall> for UnderlyingRustTuple<'_> {
5223                fn from(value: blsKeysCall) -> Self {
5224                    (value.blsKeyHash,)
5225                }
5226            }
5227            #[automatically_derived]
5228            #[doc(hidden)]
5229            impl ::core::convert::From<UnderlyingRustTuple<'_>> for blsKeysCall {
5230                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5231                    Self {
5232                        blsKeyHash: tuple.0,
5233                    }
5234                }
5235            }
5236        }
5237        {
5238            #[doc(hidden)]
5239            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5240            #[doc(hidden)]
5241            type UnderlyingRustTuple<'a> = (bool,);
5242            #[cfg(test)]
5243            #[allow(dead_code, unreachable_patterns)]
5244            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5245                match _t {
5246                    alloy_sol_types::private::AssertTypeEq::<
5247                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5248                    >(_) => {},
5249                }
5250            }
5251            #[automatically_derived]
5252            #[doc(hidden)]
5253            impl ::core::convert::From<blsKeysReturn> for UnderlyingRustTuple<'_> {
5254                fn from(value: blsKeysReturn) -> Self {
5255                    (value.used,)
5256                }
5257            }
5258            #[automatically_derived]
5259            #[doc(hidden)]
5260            impl ::core::convert::From<UnderlyingRustTuple<'_>> for blsKeysReturn {
5261                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5262                    Self { used: tuple.0 }
5263                }
5264            }
5265        }
5266        #[automatically_derived]
5267        impl alloy_sol_types::SolCall for blsKeysCall {
5268            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5269            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5270            type Return = blsKeysReturn;
5271            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5272            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5273            const SIGNATURE: &'static str = "blsKeys(bytes32)";
5274            const SELECTOR: [u8; 4] = [179u8, 230u8, 235u8, 213u8];
5275            #[inline]
5276            fn new<'a>(
5277                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5278            ) -> Self {
5279                tuple.into()
5280            }
5281            #[inline]
5282            fn tokenize(&self) -> Self::Token<'_> {
5283                (
5284                    <alloy::sol_types::sol_data::FixedBytes<
5285                        32,
5286                    > as alloy_sol_types::SolType>::tokenize(&self.blsKeyHash),
5287                )
5288            }
5289            #[inline]
5290            fn abi_decode_returns(
5291                data: &[u8],
5292                validate: bool,
5293            ) -> alloy_sol_types::Result<Self::Return> {
5294                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
5295                    data, validate,
5296                )
5297                .map(Into::into)
5298            }
5299        }
5300    };
5301    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5302    /**Function with signature `claimValidatorExit(address)` and selector `0x2140fecd`.
5303    ```solidity
5304    function claimValidatorExit(address validator) external;
5305    ```*/
5306    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5307    #[derive(Clone)]
5308    pub struct claimValidatorExitCall {
5309        #[allow(missing_docs)]
5310        pub validator: alloy::sol_types::private::Address,
5311    }
5312    ///Container type for the return parameters of the [`claimValidatorExit(address)`](claimValidatorExitCall) function.
5313    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5314    #[derive(Clone)]
5315    pub struct claimValidatorExitReturn {}
5316    #[allow(
5317        non_camel_case_types,
5318        non_snake_case,
5319        clippy::pub_underscore_fields,
5320        clippy::style
5321    )]
5322    const _: () = {
5323        use alloy::sol_types as alloy_sol_types;
5324        {
5325            #[doc(hidden)]
5326            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5327            #[doc(hidden)]
5328            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5329            #[cfg(test)]
5330            #[allow(dead_code, unreachable_patterns)]
5331            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5332                match _t {
5333                    alloy_sol_types::private::AssertTypeEq::<
5334                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5335                    >(_) => {},
5336                }
5337            }
5338            #[automatically_derived]
5339            #[doc(hidden)]
5340            impl ::core::convert::From<claimValidatorExitCall> for UnderlyingRustTuple<'_> {
5341                fn from(value: claimValidatorExitCall) -> Self {
5342                    (value.validator,)
5343                }
5344            }
5345            #[automatically_derived]
5346            #[doc(hidden)]
5347            impl ::core::convert::From<UnderlyingRustTuple<'_>> for claimValidatorExitCall {
5348                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5349                    Self { validator: tuple.0 }
5350                }
5351            }
5352        }
5353        {
5354            #[doc(hidden)]
5355            type UnderlyingSolTuple<'a> = ();
5356            #[doc(hidden)]
5357            type UnderlyingRustTuple<'a> = ();
5358            #[cfg(test)]
5359            #[allow(dead_code, unreachable_patterns)]
5360            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5361                match _t {
5362                    alloy_sol_types::private::AssertTypeEq::<
5363                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5364                    >(_) => {},
5365                }
5366            }
5367            #[automatically_derived]
5368            #[doc(hidden)]
5369            impl ::core::convert::From<claimValidatorExitReturn> for UnderlyingRustTuple<'_> {
5370                fn from(value: claimValidatorExitReturn) -> Self {
5371                    ()
5372                }
5373            }
5374            #[automatically_derived]
5375            #[doc(hidden)]
5376            impl ::core::convert::From<UnderlyingRustTuple<'_>> for claimValidatorExitReturn {
5377                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5378                    Self {}
5379                }
5380            }
5381        }
5382        #[automatically_derived]
5383        impl alloy_sol_types::SolCall for claimValidatorExitCall {
5384            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
5385            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5386            type Return = claimValidatorExitReturn;
5387            type ReturnTuple<'a> = ();
5388            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5389            const SIGNATURE: &'static str = "claimValidatorExit(address)";
5390            const SELECTOR: [u8; 4] = [33u8, 64u8, 254u8, 205u8];
5391            #[inline]
5392            fn new<'a>(
5393                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5394            ) -> Self {
5395                tuple.into()
5396            }
5397            #[inline]
5398            fn tokenize(&self) -> Self::Token<'_> {
5399                (
5400                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5401                        &self.validator,
5402                    ),
5403                )
5404            }
5405            #[inline]
5406            fn abi_decode_returns(
5407                data: &[u8],
5408                validate: bool,
5409            ) -> alloy_sol_types::Result<Self::Return> {
5410                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
5411                    data, validate,
5412                )
5413                .map(Into::into)
5414            }
5415        }
5416    };
5417    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5418    /**Function with signature `claimWithdrawal(address)` and selector `0xa3066aab`.
5419    ```solidity
5420    function claimWithdrawal(address validator) external;
5421    ```*/
5422    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5423    #[derive(Clone)]
5424    pub struct claimWithdrawalCall {
5425        #[allow(missing_docs)]
5426        pub validator: alloy::sol_types::private::Address,
5427    }
5428    ///Container type for the return parameters of the [`claimWithdrawal(address)`](claimWithdrawalCall) function.
5429    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5430    #[derive(Clone)]
5431    pub struct claimWithdrawalReturn {}
5432    #[allow(
5433        non_camel_case_types,
5434        non_snake_case,
5435        clippy::pub_underscore_fields,
5436        clippy::style
5437    )]
5438    const _: () = {
5439        use alloy::sol_types as alloy_sol_types;
5440        {
5441            #[doc(hidden)]
5442            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5443            #[doc(hidden)]
5444            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5445            #[cfg(test)]
5446            #[allow(dead_code, unreachable_patterns)]
5447            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5448                match _t {
5449                    alloy_sol_types::private::AssertTypeEq::<
5450                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5451                    >(_) => {},
5452                }
5453            }
5454            #[automatically_derived]
5455            #[doc(hidden)]
5456            impl ::core::convert::From<claimWithdrawalCall> for UnderlyingRustTuple<'_> {
5457                fn from(value: claimWithdrawalCall) -> Self {
5458                    (value.validator,)
5459                }
5460            }
5461            #[automatically_derived]
5462            #[doc(hidden)]
5463            impl ::core::convert::From<UnderlyingRustTuple<'_>> for claimWithdrawalCall {
5464                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5465                    Self { validator: tuple.0 }
5466                }
5467            }
5468        }
5469        {
5470            #[doc(hidden)]
5471            type UnderlyingSolTuple<'a> = ();
5472            #[doc(hidden)]
5473            type UnderlyingRustTuple<'a> = ();
5474            #[cfg(test)]
5475            #[allow(dead_code, unreachable_patterns)]
5476            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5477                match _t {
5478                    alloy_sol_types::private::AssertTypeEq::<
5479                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5480                    >(_) => {},
5481                }
5482            }
5483            #[automatically_derived]
5484            #[doc(hidden)]
5485            impl ::core::convert::From<claimWithdrawalReturn> for UnderlyingRustTuple<'_> {
5486                fn from(value: claimWithdrawalReturn) -> Self {
5487                    ()
5488                }
5489            }
5490            #[automatically_derived]
5491            #[doc(hidden)]
5492            impl ::core::convert::From<UnderlyingRustTuple<'_>> for claimWithdrawalReturn {
5493                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5494                    Self {}
5495                }
5496            }
5497        }
5498        #[automatically_derived]
5499        impl alloy_sol_types::SolCall for claimWithdrawalCall {
5500            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
5501            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5502            type Return = claimWithdrawalReturn;
5503            type ReturnTuple<'a> = ();
5504            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5505            const SIGNATURE: &'static str = "claimWithdrawal(address)";
5506            const SELECTOR: [u8; 4] = [163u8, 6u8, 106u8, 171u8];
5507            #[inline]
5508            fn new<'a>(
5509                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5510            ) -> Self {
5511                tuple.into()
5512            }
5513            #[inline]
5514            fn tokenize(&self) -> Self::Token<'_> {
5515                (
5516                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5517                        &self.validator,
5518                    ),
5519                )
5520            }
5521            #[inline]
5522            fn abi_decode_returns(
5523                data: &[u8],
5524                validate: bool,
5525            ) -> alloy_sol_types::Result<Self::Return> {
5526                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
5527                    data, validate,
5528                )
5529                .map(Into::into)
5530            }
5531        }
5532    };
5533    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5534    /**Function with signature `delegate(address,uint256)` and selector `0x026e402b`.
5535    ```solidity
5536    function delegate(address validator, uint256 amount) external;
5537    ```*/
5538    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5539    #[derive(Clone)]
5540    pub struct delegateCall {
5541        #[allow(missing_docs)]
5542        pub validator: alloy::sol_types::private::Address,
5543        #[allow(missing_docs)]
5544        pub amount: alloy::sol_types::private::primitives::aliases::U256,
5545    }
5546    ///Container type for the return parameters of the [`delegate(address,uint256)`](delegateCall) function.
5547    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5548    #[derive(Clone)]
5549    pub struct delegateReturn {}
5550    #[allow(
5551        non_camel_case_types,
5552        non_snake_case,
5553        clippy::pub_underscore_fields,
5554        clippy::style
5555    )]
5556    const _: () = {
5557        use alloy::sol_types as alloy_sol_types;
5558        {
5559            #[doc(hidden)]
5560            type UnderlyingSolTuple<'a> = (
5561                alloy::sol_types::sol_data::Address,
5562                alloy::sol_types::sol_data::Uint<256>,
5563            );
5564            #[doc(hidden)]
5565            type UnderlyingRustTuple<'a> = (
5566                alloy::sol_types::private::Address,
5567                alloy::sol_types::private::primitives::aliases::U256,
5568            );
5569            #[cfg(test)]
5570            #[allow(dead_code, unreachable_patterns)]
5571            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5572                match _t {
5573                    alloy_sol_types::private::AssertTypeEq::<
5574                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5575                    >(_) => {},
5576                }
5577            }
5578            #[automatically_derived]
5579            #[doc(hidden)]
5580            impl ::core::convert::From<delegateCall> for UnderlyingRustTuple<'_> {
5581                fn from(value: delegateCall) -> Self {
5582                    (value.validator, value.amount)
5583                }
5584            }
5585            #[automatically_derived]
5586            #[doc(hidden)]
5587            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegateCall {
5588                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5589                    Self {
5590                        validator: tuple.0,
5591                        amount: tuple.1,
5592                    }
5593                }
5594            }
5595        }
5596        {
5597            #[doc(hidden)]
5598            type UnderlyingSolTuple<'a> = ();
5599            #[doc(hidden)]
5600            type UnderlyingRustTuple<'a> = ();
5601            #[cfg(test)]
5602            #[allow(dead_code, unreachable_patterns)]
5603            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5604                match _t {
5605                    alloy_sol_types::private::AssertTypeEq::<
5606                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5607                    >(_) => {},
5608                }
5609            }
5610            #[automatically_derived]
5611            #[doc(hidden)]
5612            impl ::core::convert::From<delegateReturn> for UnderlyingRustTuple<'_> {
5613                fn from(value: delegateReturn) -> Self {
5614                    ()
5615                }
5616            }
5617            #[automatically_derived]
5618            #[doc(hidden)]
5619            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegateReturn {
5620                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5621                    Self {}
5622                }
5623            }
5624        }
5625        #[automatically_derived]
5626        impl alloy_sol_types::SolCall for delegateCall {
5627            type Parameters<'a> = (
5628                alloy::sol_types::sol_data::Address,
5629                alloy::sol_types::sol_data::Uint<256>,
5630            );
5631            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5632            type Return = delegateReturn;
5633            type ReturnTuple<'a> = ();
5634            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5635            const SIGNATURE: &'static str = "delegate(address,uint256)";
5636            const SELECTOR: [u8; 4] = [2u8, 110u8, 64u8, 43u8];
5637            #[inline]
5638            fn new<'a>(
5639                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5640            ) -> Self {
5641                tuple.into()
5642            }
5643            #[inline]
5644            fn tokenize(&self) -> Self::Token<'_> {
5645                (
5646                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5647                        &self.validator,
5648                    ),
5649                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
5650                        &self.amount,
5651                    ),
5652                )
5653            }
5654            #[inline]
5655            fn abi_decode_returns(
5656                data: &[u8],
5657                validate: bool,
5658            ) -> alloy_sol_types::Result<Self::Return> {
5659                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
5660                    data, validate,
5661                )
5662                .map(Into::into)
5663            }
5664        }
5665    };
5666    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5667    /**Function with signature `delegations(address,address)` and selector `0xc64814dd`.
5668    ```solidity
5669    function delegations(address validator, address delegator) external view returns (uint256 amount);
5670    ```*/
5671    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5672    #[derive(Clone)]
5673    pub struct delegationsCall {
5674        #[allow(missing_docs)]
5675        pub validator: alloy::sol_types::private::Address,
5676        #[allow(missing_docs)]
5677        pub delegator: alloy::sol_types::private::Address,
5678    }
5679    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5680    ///Container type for the return parameters of the [`delegations(address,address)`](delegationsCall) function.
5681    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5682    #[derive(Clone)]
5683    pub struct delegationsReturn {
5684        #[allow(missing_docs)]
5685        pub amount: alloy::sol_types::private::primitives::aliases::U256,
5686    }
5687    #[allow(
5688        non_camel_case_types,
5689        non_snake_case,
5690        clippy::pub_underscore_fields,
5691        clippy::style
5692    )]
5693    const _: () = {
5694        use alloy::sol_types as alloy_sol_types;
5695        {
5696            #[doc(hidden)]
5697            type UnderlyingSolTuple<'a> = (
5698                alloy::sol_types::sol_data::Address,
5699                alloy::sol_types::sol_data::Address,
5700            );
5701            #[doc(hidden)]
5702            type UnderlyingRustTuple<'a> = (
5703                alloy::sol_types::private::Address,
5704                alloy::sol_types::private::Address,
5705            );
5706            #[cfg(test)]
5707            #[allow(dead_code, unreachable_patterns)]
5708            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5709                match _t {
5710                    alloy_sol_types::private::AssertTypeEq::<
5711                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5712                    >(_) => {},
5713                }
5714            }
5715            #[automatically_derived]
5716            #[doc(hidden)]
5717            impl ::core::convert::From<delegationsCall> for UnderlyingRustTuple<'_> {
5718                fn from(value: delegationsCall) -> Self {
5719                    (value.validator, value.delegator)
5720                }
5721            }
5722            #[automatically_derived]
5723            #[doc(hidden)]
5724            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegationsCall {
5725                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5726                    Self {
5727                        validator: tuple.0,
5728                        delegator: tuple.1,
5729                    }
5730                }
5731            }
5732        }
5733        {
5734            #[doc(hidden)]
5735            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5736            #[doc(hidden)]
5737            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
5738            #[cfg(test)]
5739            #[allow(dead_code, unreachable_patterns)]
5740            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5741                match _t {
5742                    alloy_sol_types::private::AssertTypeEq::<
5743                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5744                    >(_) => {},
5745                }
5746            }
5747            #[automatically_derived]
5748            #[doc(hidden)]
5749            impl ::core::convert::From<delegationsReturn> for UnderlyingRustTuple<'_> {
5750                fn from(value: delegationsReturn) -> Self {
5751                    (value.amount,)
5752                }
5753            }
5754            #[automatically_derived]
5755            #[doc(hidden)]
5756            impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegationsReturn {
5757                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5758                    Self { amount: tuple.0 }
5759                }
5760            }
5761        }
5762        #[automatically_derived]
5763        impl alloy_sol_types::SolCall for delegationsCall {
5764            type Parameters<'a> = (
5765                alloy::sol_types::sol_data::Address,
5766                alloy::sol_types::sol_data::Address,
5767            );
5768            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5769            type Return = delegationsReturn;
5770            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5771            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5772            const SIGNATURE: &'static str = "delegations(address,address)";
5773            const SELECTOR: [u8; 4] = [198u8, 72u8, 20u8, 221u8];
5774            #[inline]
5775            fn new<'a>(
5776                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5777            ) -> Self {
5778                tuple.into()
5779            }
5780            #[inline]
5781            fn tokenize(&self) -> Self::Token<'_> {
5782                (
5783                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5784                        &self.validator,
5785                    ),
5786                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5787                        &self.delegator,
5788                    ),
5789                )
5790            }
5791            #[inline]
5792            fn abi_decode_returns(
5793                data: &[u8],
5794                validate: bool,
5795            ) -> alloy_sol_types::Result<Self::Return> {
5796                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
5797                    data, validate,
5798                )
5799                .map(Into::into)
5800            }
5801        }
5802    };
5803    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5804    /**Function with signature `deregisterValidator()` and selector `0x6a911ccf`.
5805    ```solidity
5806    function deregisterValidator() external;
5807    ```*/
5808    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5809    #[derive(Clone)]
5810    pub struct deregisterValidatorCall {}
5811    ///Container type for the return parameters of the [`deregisterValidator()`](deregisterValidatorCall) function.
5812    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5813    #[derive(Clone)]
5814    pub struct deregisterValidatorReturn {}
5815    #[allow(
5816        non_camel_case_types,
5817        non_snake_case,
5818        clippy::pub_underscore_fields,
5819        clippy::style
5820    )]
5821    const _: () = {
5822        use alloy::sol_types as alloy_sol_types;
5823        {
5824            #[doc(hidden)]
5825            type UnderlyingSolTuple<'a> = ();
5826            #[doc(hidden)]
5827            type UnderlyingRustTuple<'a> = ();
5828            #[cfg(test)]
5829            #[allow(dead_code, unreachable_patterns)]
5830            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5831                match _t {
5832                    alloy_sol_types::private::AssertTypeEq::<
5833                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5834                    >(_) => {},
5835                }
5836            }
5837            #[automatically_derived]
5838            #[doc(hidden)]
5839            impl ::core::convert::From<deregisterValidatorCall> for UnderlyingRustTuple<'_> {
5840                fn from(value: deregisterValidatorCall) -> Self {
5841                    ()
5842                }
5843            }
5844            #[automatically_derived]
5845            #[doc(hidden)]
5846            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterValidatorCall {
5847                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5848                    Self {}
5849                }
5850            }
5851        }
5852        {
5853            #[doc(hidden)]
5854            type UnderlyingSolTuple<'a> = ();
5855            #[doc(hidden)]
5856            type UnderlyingRustTuple<'a> = ();
5857            #[cfg(test)]
5858            #[allow(dead_code, unreachable_patterns)]
5859            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5860                match _t {
5861                    alloy_sol_types::private::AssertTypeEq::<
5862                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5863                    >(_) => {},
5864                }
5865            }
5866            #[automatically_derived]
5867            #[doc(hidden)]
5868            impl ::core::convert::From<deregisterValidatorReturn> for UnderlyingRustTuple<'_> {
5869                fn from(value: deregisterValidatorReturn) -> Self {
5870                    ()
5871                }
5872            }
5873            #[automatically_derived]
5874            #[doc(hidden)]
5875            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterValidatorReturn {
5876                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5877                    Self {}
5878                }
5879            }
5880        }
5881        #[automatically_derived]
5882        impl alloy_sol_types::SolCall for deregisterValidatorCall {
5883            type Parameters<'a> = ();
5884            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5885            type Return = deregisterValidatorReturn;
5886            type ReturnTuple<'a> = ();
5887            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5888            const SIGNATURE: &'static str = "deregisterValidator()";
5889            const SELECTOR: [u8; 4] = [106u8, 145u8, 28u8, 207u8];
5890            #[inline]
5891            fn new<'a>(
5892                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5893            ) -> Self {
5894                tuple.into()
5895            }
5896            #[inline]
5897            fn tokenize(&self) -> Self::Token<'_> {
5898                ()
5899            }
5900            #[inline]
5901            fn abi_decode_returns(
5902                data: &[u8],
5903                validate: bool,
5904            ) -> alloy_sol_types::Result<Self::Return> {
5905                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
5906                    data, validate,
5907                )
5908                .map(Into::into)
5909            }
5910        }
5911    };
5912    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5913    /**Function with signature `exitEscrowPeriod()` and selector `0x9e9a8f31`.
5914    ```solidity
5915    function exitEscrowPeriod() external view returns (uint256);
5916    ```*/
5917    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5918    #[derive(Clone)]
5919    pub struct exitEscrowPeriodCall {}
5920    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5921    ///Container type for the return parameters of the [`exitEscrowPeriod()`](exitEscrowPeriodCall) function.
5922    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5923    #[derive(Clone)]
5924    pub struct exitEscrowPeriodReturn {
5925        #[allow(missing_docs)]
5926        pub _0: alloy::sol_types::private::primitives::aliases::U256,
5927    }
5928    #[allow(
5929        non_camel_case_types,
5930        non_snake_case,
5931        clippy::pub_underscore_fields,
5932        clippy::style
5933    )]
5934    const _: () = {
5935        use alloy::sol_types as alloy_sol_types;
5936        {
5937            #[doc(hidden)]
5938            type UnderlyingSolTuple<'a> = ();
5939            #[doc(hidden)]
5940            type UnderlyingRustTuple<'a> = ();
5941            #[cfg(test)]
5942            #[allow(dead_code, unreachable_patterns)]
5943            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5944                match _t {
5945                    alloy_sol_types::private::AssertTypeEq::<
5946                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5947                    >(_) => {},
5948                }
5949            }
5950            #[automatically_derived]
5951            #[doc(hidden)]
5952            impl ::core::convert::From<exitEscrowPeriodCall> for UnderlyingRustTuple<'_> {
5953                fn from(value: exitEscrowPeriodCall) -> Self {
5954                    ()
5955                }
5956            }
5957            #[automatically_derived]
5958            #[doc(hidden)]
5959            impl ::core::convert::From<UnderlyingRustTuple<'_>> for exitEscrowPeriodCall {
5960                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5961                    Self {}
5962                }
5963            }
5964        }
5965        {
5966            #[doc(hidden)]
5967            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5968            #[doc(hidden)]
5969            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
5970            #[cfg(test)]
5971            #[allow(dead_code, unreachable_patterns)]
5972            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5973                match _t {
5974                    alloy_sol_types::private::AssertTypeEq::<
5975                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5976                    >(_) => {},
5977                }
5978            }
5979            #[automatically_derived]
5980            #[doc(hidden)]
5981            impl ::core::convert::From<exitEscrowPeriodReturn> for UnderlyingRustTuple<'_> {
5982                fn from(value: exitEscrowPeriodReturn) -> Self {
5983                    (value._0,)
5984                }
5985            }
5986            #[automatically_derived]
5987            #[doc(hidden)]
5988            impl ::core::convert::From<UnderlyingRustTuple<'_>> for exitEscrowPeriodReturn {
5989                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5990                    Self { _0: tuple.0 }
5991                }
5992            }
5993        }
5994        #[automatically_derived]
5995        impl alloy_sol_types::SolCall for exitEscrowPeriodCall {
5996            type Parameters<'a> = ();
5997            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5998            type Return = exitEscrowPeriodReturn;
5999            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6000            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6001            const SIGNATURE: &'static str = "exitEscrowPeriod()";
6002            const SELECTOR: [u8; 4] = [158u8, 154u8, 143u8, 49u8];
6003            #[inline]
6004            fn new<'a>(
6005                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6006            ) -> Self {
6007                tuple.into()
6008            }
6009            #[inline]
6010            fn tokenize(&self) -> Self::Token<'_> {
6011                ()
6012            }
6013            #[inline]
6014            fn abi_decode_returns(
6015                data: &[u8],
6016                validate: bool,
6017            ) -> alloy_sol_types::Result<Self::Return> {
6018                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
6019                    data, validate,
6020                )
6021                .map(Into::into)
6022            }
6023        }
6024    };
6025    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6026    /**Function with signature `getVersion()` and selector `0x0d8e6e2c`.
6027    ```solidity
6028    function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion);
6029    ```*/
6030    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6031    #[derive(Clone)]
6032    pub struct getVersionCall {}
6033    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6034    ///Container type for the return parameters of the [`getVersion()`](getVersionCall) function.
6035    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6036    #[derive(Clone)]
6037    pub struct getVersionReturn {
6038        #[allow(missing_docs)]
6039        pub majorVersion: u8,
6040        #[allow(missing_docs)]
6041        pub minorVersion: u8,
6042        #[allow(missing_docs)]
6043        pub patchVersion: u8,
6044    }
6045    #[allow(
6046        non_camel_case_types,
6047        non_snake_case,
6048        clippy::pub_underscore_fields,
6049        clippy::style
6050    )]
6051    const _: () = {
6052        use alloy::sol_types as alloy_sol_types;
6053        {
6054            #[doc(hidden)]
6055            type UnderlyingSolTuple<'a> = ();
6056            #[doc(hidden)]
6057            type UnderlyingRustTuple<'a> = ();
6058            #[cfg(test)]
6059            #[allow(dead_code, unreachable_patterns)]
6060            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6061                match _t {
6062                    alloy_sol_types::private::AssertTypeEq::<
6063                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6064                    >(_) => {},
6065                }
6066            }
6067            #[automatically_derived]
6068            #[doc(hidden)]
6069            impl ::core::convert::From<getVersionCall> for UnderlyingRustTuple<'_> {
6070                fn from(value: getVersionCall) -> Self {
6071                    ()
6072                }
6073            }
6074            #[automatically_derived]
6075            #[doc(hidden)]
6076            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionCall {
6077                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6078                    Self {}
6079                }
6080            }
6081        }
6082        {
6083            #[doc(hidden)]
6084            type UnderlyingSolTuple<'a> = (
6085                alloy::sol_types::sol_data::Uint<8>,
6086                alloy::sol_types::sol_data::Uint<8>,
6087                alloy::sol_types::sol_data::Uint<8>,
6088            );
6089            #[doc(hidden)]
6090            type UnderlyingRustTuple<'a> = (u8, u8, u8);
6091            #[cfg(test)]
6092            #[allow(dead_code, unreachable_patterns)]
6093            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6094                match _t {
6095                    alloy_sol_types::private::AssertTypeEq::<
6096                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6097                    >(_) => {},
6098                }
6099            }
6100            #[automatically_derived]
6101            #[doc(hidden)]
6102            impl ::core::convert::From<getVersionReturn> for UnderlyingRustTuple<'_> {
6103                fn from(value: getVersionReturn) -> Self {
6104                    (value.majorVersion, value.minorVersion, value.patchVersion)
6105                }
6106            }
6107            #[automatically_derived]
6108            #[doc(hidden)]
6109            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVersionReturn {
6110                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6111                    Self {
6112                        majorVersion: tuple.0,
6113                        minorVersion: tuple.1,
6114                        patchVersion: tuple.2,
6115                    }
6116                }
6117            }
6118        }
6119        #[automatically_derived]
6120        impl alloy_sol_types::SolCall for getVersionCall {
6121            type Parameters<'a> = ();
6122            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
6123            type Return = getVersionReturn;
6124            type ReturnTuple<'a> = (
6125                alloy::sol_types::sol_data::Uint<8>,
6126                alloy::sol_types::sol_data::Uint<8>,
6127                alloy::sol_types::sol_data::Uint<8>,
6128            );
6129            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6130            const SIGNATURE: &'static str = "getVersion()";
6131            const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8];
6132            #[inline]
6133            fn new<'a>(
6134                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6135            ) -> Self {
6136                tuple.into()
6137            }
6138            #[inline]
6139            fn tokenize(&self) -> Self::Token<'_> {
6140                ()
6141            }
6142            #[inline]
6143            fn abi_decode_returns(
6144                data: &[u8],
6145                validate: bool,
6146            ) -> alloy_sol_types::Result<Self::Return> {
6147                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
6148                    data, validate,
6149                )
6150                .map(Into::into)
6151            }
6152        }
6153    };
6154    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6155    /**Function with signature `initialize(address,address,uint256,address)` and selector `0xbe203094`.
6156    ```solidity
6157    function initialize(address _tokenAddress, address _lightClientAddress, uint256 _exitEscrowPeriod, address _timelock) external;
6158    ```*/
6159    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6160    #[derive(Clone)]
6161    pub struct initializeCall {
6162        #[allow(missing_docs)]
6163        pub _tokenAddress: alloy::sol_types::private::Address,
6164        #[allow(missing_docs)]
6165        pub _lightClientAddress: alloy::sol_types::private::Address,
6166        #[allow(missing_docs)]
6167        pub _exitEscrowPeriod: alloy::sol_types::private::primitives::aliases::U256,
6168        #[allow(missing_docs)]
6169        pub _timelock: alloy::sol_types::private::Address,
6170    }
6171    ///Container type for the return parameters of the [`initialize(address,address,uint256,address)`](initializeCall) function.
6172    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6173    #[derive(Clone)]
6174    pub struct initializeReturn {}
6175    #[allow(
6176        non_camel_case_types,
6177        non_snake_case,
6178        clippy::pub_underscore_fields,
6179        clippy::style
6180    )]
6181    const _: () = {
6182        use alloy::sol_types as alloy_sol_types;
6183        {
6184            #[doc(hidden)]
6185            type UnderlyingSolTuple<'a> = (
6186                alloy::sol_types::sol_data::Address,
6187                alloy::sol_types::sol_data::Address,
6188                alloy::sol_types::sol_data::Uint<256>,
6189                alloy::sol_types::sol_data::Address,
6190            );
6191            #[doc(hidden)]
6192            type UnderlyingRustTuple<'a> = (
6193                alloy::sol_types::private::Address,
6194                alloy::sol_types::private::Address,
6195                alloy::sol_types::private::primitives::aliases::U256,
6196                alloy::sol_types::private::Address,
6197            );
6198            #[cfg(test)]
6199            #[allow(dead_code, unreachable_patterns)]
6200            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6201                match _t {
6202                    alloy_sol_types::private::AssertTypeEq::<
6203                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6204                    >(_) => {},
6205                }
6206            }
6207            #[automatically_derived]
6208            #[doc(hidden)]
6209            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
6210                fn from(value: initializeCall) -> Self {
6211                    (
6212                        value._tokenAddress,
6213                        value._lightClientAddress,
6214                        value._exitEscrowPeriod,
6215                        value._timelock,
6216                    )
6217                }
6218            }
6219            #[automatically_derived]
6220            #[doc(hidden)]
6221            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
6222                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6223                    Self {
6224                        _tokenAddress: tuple.0,
6225                        _lightClientAddress: tuple.1,
6226                        _exitEscrowPeriod: tuple.2,
6227                        _timelock: tuple.3,
6228                    }
6229                }
6230            }
6231        }
6232        {
6233            #[doc(hidden)]
6234            type UnderlyingSolTuple<'a> = ();
6235            #[doc(hidden)]
6236            type UnderlyingRustTuple<'a> = ();
6237            #[cfg(test)]
6238            #[allow(dead_code, unreachable_patterns)]
6239            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6240                match _t {
6241                    alloy_sol_types::private::AssertTypeEq::<
6242                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6243                    >(_) => {},
6244                }
6245            }
6246            #[automatically_derived]
6247            #[doc(hidden)]
6248            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
6249                fn from(value: initializeReturn) -> Self {
6250                    ()
6251                }
6252            }
6253            #[automatically_derived]
6254            #[doc(hidden)]
6255            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
6256                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6257                    Self {}
6258                }
6259            }
6260        }
6261        #[automatically_derived]
6262        impl alloy_sol_types::SolCall for initializeCall {
6263            type Parameters<'a> = (
6264                alloy::sol_types::sol_data::Address,
6265                alloy::sol_types::sol_data::Address,
6266                alloy::sol_types::sol_data::Uint<256>,
6267                alloy::sol_types::sol_data::Address,
6268            );
6269            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
6270            type Return = initializeReturn;
6271            type ReturnTuple<'a> = ();
6272            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6273            const SIGNATURE: &'static str = "initialize(address,address,uint256,address)";
6274            const SELECTOR: [u8; 4] = [190u8, 32u8, 48u8, 148u8];
6275            #[inline]
6276            fn new<'a>(
6277                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6278            ) -> Self {
6279                tuple.into()
6280            }
6281            #[inline]
6282            fn tokenize(&self) -> Self::Token<'_> {
6283                (
6284                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6285                        &self._tokenAddress,
6286                    ),
6287                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6288                        &self._lightClientAddress,
6289                    ),
6290                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
6291                        &self._exitEscrowPeriod,
6292                    ),
6293                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6294                        &self._timelock,
6295                    ),
6296                )
6297            }
6298            #[inline]
6299            fn abi_decode_returns(
6300                data: &[u8],
6301                validate: bool,
6302            ) -> alloy_sol_types::Result<Self::Return> {
6303                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
6304                    data, validate,
6305                )
6306                .map(Into::into)
6307            }
6308        }
6309    };
6310    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6311    /**Function with signature `initializedAtBlock()` and selector `0x3e9df9b5`.
6312    ```solidity
6313    function initializedAtBlock() external view returns (uint256);
6314    ```*/
6315    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6316    #[derive(Clone)]
6317    pub struct initializedAtBlockCall {}
6318    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6319    ///Container type for the return parameters of the [`initializedAtBlock()`](initializedAtBlockCall) function.
6320    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6321    #[derive(Clone)]
6322    pub struct initializedAtBlockReturn {
6323        #[allow(missing_docs)]
6324        pub _0: alloy::sol_types::private::primitives::aliases::U256,
6325    }
6326    #[allow(
6327        non_camel_case_types,
6328        non_snake_case,
6329        clippy::pub_underscore_fields,
6330        clippy::style
6331    )]
6332    const _: () = {
6333        use alloy::sol_types as alloy_sol_types;
6334        {
6335            #[doc(hidden)]
6336            type UnderlyingSolTuple<'a> = ();
6337            #[doc(hidden)]
6338            type UnderlyingRustTuple<'a> = ();
6339            #[cfg(test)]
6340            #[allow(dead_code, unreachable_patterns)]
6341            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6342                match _t {
6343                    alloy_sol_types::private::AssertTypeEq::<
6344                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6345                    >(_) => {},
6346                }
6347            }
6348            #[automatically_derived]
6349            #[doc(hidden)]
6350            impl ::core::convert::From<initializedAtBlockCall> for UnderlyingRustTuple<'_> {
6351                fn from(value: initializedAtBlockCall) -> Self {
6352                    ()
6353                }
6354            }
6355            #[automatically_derived]
6356            #[doc(hidden)]
6357            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializedAtBlockCall {
6358                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6359                    Self {}
6360                }
6361            }
6362        }
6363        {
6364            #[doc(hidden)]
6365            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6366            #[doc(hidden)]
6367            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
6368            #[cfg(test)]
6369            #[allow(dead_code, unreachable_patterns)]
6370            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6371                match _t {
6372                    alloy_sol_types::private::AssertTypeEq::<
6373                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6374                    >(_) => {},
6375                }
6376            }
6377            #[automatically_derived]
6378            #[doc(hidden)]
6379            impl ::core::convert::From<initializedAtBlockReturn> for UnderlyingRustTuple<'_> {
6380                fn from(value: initializedAtBlockReturn) -> Self {
6381                    (value._0,)
6382                }
6383            }
6384            #[automatically_derived]
6385            #[doc(hidden)]
6386            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializedAtBlockReturn {
6387                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6388                    Self { _0: tuple.0 }
6389                }
6390            }
6391        }
6392        #[automatically_derived]
6393        impl alloy_sol_types::SolCall for initializedAtBlockCall {
6394            type Parameters<'a> = ();
6395            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
6396            type Return = initializedAtBlockReturn;
6397            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6398            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6399            const SIGNATURE: &'static str = "initializedAtBlock()";
6400            const SELECTOR: [u8; 4] = [62u8, 157u8, 249u8, 181u8];
6401            #[inline]
6402            fn new<'a>(
6403                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6404            ) -> Self {
6405                tuple.into()
6406            }
6407            #[inline]
6408            fn tokenize(&self) -> Self::Token<'_> {
6409                ()
6410            }
6411            #[inline]
6412            fn abi_decode_returns(
6413                data: &[u8],
6414                validate: bool,
6415            ) -> alloy_sol_types::Result<Self::Return> {
6416                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
6417                    data, validate,
6418                )
6419                .map(Into::into)
6420            }
6421        }
6422    };
6423    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6424    /**Function with signature `lightClient()` and selector `0xb5700e68`.
6425    ```solidity
6426    function lightClient() external view returns (address);
6427    ```*/
6428    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6429    #[derive(Clone)]
6430    pub struct lightClientCall {}
6431    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6432    ///Container type for the return parameters of the [`lightClient()`](lightClientCall) function.
6433    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6434    #[derive(Clone)]
6435    pub struct lightClientReturn {
6436        #[allow(missing_docs)]
6437        pub _0: alloy::sol_types::private::Address,
6438    }
6439    #[allow(
6440        non_camel_case_types,
6441        non_snake_case,
6442        clippy::pub_underscore_fields,
6443        clippy::style
6444    )]
6445    const _: () = {
6446        use alloy::sol_types as alloy_sol_types;
6447        {
6448            #[doc(hidden)]
6449            type UnderlyingSolTuple<'a> = ();
6450            #[doc(hidden)]
6451            type UnderlyingRustTuple<'a> = ();
6452            #[cfg(test)]
6453            #[allow(dead_code, unreachable_patterns)]
6454            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6455                match _t {
6456                    alloy_sol_types::private::AssertTypeEq::<
6457                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6458                    >(_) => {},
6459                }
6460            }
6461            #[automatically_derived]
6462            #[doc(hidden)]
6463            impl ::core::convert::From<lightClientCall> for UnderlyingRustTuple<'_> {
6464                fn from(value: lightClientCall) -> Self {
6465                    ()
6466                }
6467            }
6468            #[automatically_derived]
6469            #[doc(hidden)]
6470            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lightClientCall {
6471                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6472                    Self {}
6473                }
6474            }
6475        }
6476        {
6477            #[doc(hidden)]
6478            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6479            #[doc(hidden)]
6480            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6481            #[cfg(test)]
6482            #[allow(dead_code, unreachable_patterns)]
6483            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6484                match _t {
6485                    alloy_sol_types::private::AssertTypeEq::<
6486                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6487                    >(_) => {},
6488                }
6489            }
6490            #[automatically_derived]
6491            #[doc(hidden)]
6492            impl ::core::convert::From<lightClientReturn> for UnderlyingRustTuple<'_> {
6493                fn from(value: lightClientReturn) -> Self {
6494                    (value._0,)
6495                }
6496            }
6497            #[automatically_derived]
6498            #[doc(hidden)]
6499            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lightClientReturn {
6500                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6501                    Self { _0: tuple.0 }
6502                }
6503            }
6504        }
6505        #[automatically_derived]
6506        impl alloy_sol_types::SolCall for lightClientCall {
6507            type Parameters<'a> = ();
6508            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
6509            type Return = lightClientReturn;
6510            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
6511            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6512            const SIGNATURE: &'static str = "lightClient()";
6513            const SELECTOR: [u8; 4] = [181u8, 112u8, 14u8, 104u8];
6514            #[inline]
6515            fn new<'a>(
6516                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6517            ) -> Self {
6518                tuple.into()
6519            }
6520            #[inline]
6521            fn tokenize(&self) -> Self::Token<'_> {
6522                ()
6523            }
6524            #[inline]
6525            fn abi_decode_returns(
6526                data: &[u8],
6527                validate: bool,
6528            ) -> alloy_sol_types::Result<Self::Return> {
6529                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
6530                    data, validate,
6531                )
6532                .map(Into::into)
6533            }
6534        }
6535    };
6536    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6537    /**Function with signature `owner()` and selector `0x8da5cb5b`.
6538    ```solidity
6539    function owner() external view returns (address);
6540    ```*/
6541    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6542    #[derive(Clone)]
6543    pub struct ownerCall {}
6544    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6545    ///Container type for the return parameters of the [`owner()`](ownerCall) function.
6546    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6547    #[derive(Clone)]
6548    pub struct ownerReturn {
6549        #[allow(missing_docs)]
6550        pub _0: alloy::sol_types::private::Address,
6551    }
6552    #[allow(
6553        non_camel_case_types,
6554        non_snake_case,
6555        clippy::pub_underscore_fields,
6556        clippy::style
6557    )]
6558    const _: () = {
6559        use alloy::sol_types as alloy_sol_types;
6560        {
6561            #[doc(hidden)]
6562            type UnderlyingSolTuple<'a> = ();
6563            #[doc(hidden)]
6564            type UnderlyingRustTuple<'a> = ();
6565            #[cfg(test)]
6566            #[allow(dead_code, unreachable_patterns)]
6567            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6568                match _t {
6569                    alloy_sol_types::private::AssertTypeEq::<
6570                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6571                    >(_) => {},
6572                }
6573            }
6574            #[automatically_derived]
6575            #[doc(hidden)]
6576            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
6577                fn from(value: ownerCall) -> Self {
6578                    ()
6579                }
6580            }
6581            #[automatically_derived]
6582            #[doc(hidden)]
6583            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
6584                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6585                    Self {}
6586                }
6587            }
6588        }
6589        {
6590            #[doc(hidden)]
6591            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6592            #[doc(hidden)]
6593            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6594            #[cfg(test)]
6595            #[allow(dead_code, unreachable_patterns)]
6596            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6597                match _t {
6598                    alloy_sol_types::private::AssertTypeEq::<
6599                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6600                    >(_) => {},
6601                }
6602            }
6603            #[automatically_derived]
6604            #[doc(hidden)]
6605            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
6606                fn from(value: ownerReturn) -> Self {
6607                    (value._0,)
6608                }
6609            }
6610            #[automatically_derived]
6611            #[doc(hidden)]
6612            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
6613                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6614                    Self { _0: tuple.0 }
6615                }
6616            }
6617        }
6618        #[automatically_derived]
6619        impl alloy_sol_types::SolCall for ownerCall {
6620            type Parameters<'a> = ();
6621            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
6622            type Return = ownerReturn;
6623            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
6624            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6625            const SIGNATURE: &'static str = "owner()";
6626            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
6627            #[inline]
6628            fn new<'a>(
6629                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6630            ) -> Self {
6631                tuple.into()
6632            }
6633            #[inline]
6634            fn tokenize(&self) -> Self::Token<'_> {
6635                ()
6636            }
6637            #[inline]
6638            fn abi_decode_returns(
6639                data: &[u8],
6640                validate: bool,
6641            ) -> alloy_sol_types::Result<Self::Return> {
6642                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
6643                    data, validate,
6644                )
6645                .map(Into::into)
6646            }
6647        }
6648    };
6649    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6650    /**Function with signature `proxiableUUID()` and selector `0x52d1902d`.
6651    ```solidity
6652    function proxiableUUID() external view returns (bytes32);
6653    ```*/
6654    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6655    #[derive(Clone)]
6656    pub struct proxiableUUIDCall {}
6657    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6658    ///Container type for the return parameters of the [`proxiableUUID()`](proxiableUUIDCall) function.
6659    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6660    #[derive(Clone)]
6661    pub struct proxiableUUIDReturn {
6662        #[allow(missing_docs)]
6663        pub _0: alloy::sol_types::private::FixedBytes<32>,
6664    }
6665    #[allow(
6666        non_camel_case_types,
6667        non_snake_case,
6668        clippy::pub_underscore_fields,
6669        clippy::style
6670    )]
6671    const _: () = {
6672        use alloy::sol_types as alloy_sol_types;
6673        {
6674            #[doc(hidden)]
6675            type UnderlyingSolTuple<'a> = ();
6676            #[doc(hidden)]
6677            type UnderlyingRustTuple<'a> = ();
6678            #[cfg(test)]
6679            #[allow(dead_code, unreachable_patterns)]
6680            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6681                match _t {
6682                    alloy_sol_types::private::AssertTypeEq::<
6683                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6684                    >(_) => {},
6685                }
6686            }
6687            #[automatically_derived]
6688            #[doc(hidden)]
6689            impl ::core::convert::From<proxiableUUIDCall> for UnderlyingRustTuple<'_> {
6690                fn from(value: proxiableUUIDCall) -> Self {
6691                    ()
6692                }
6693            }
6694            #[automatically_derived]
6695            #[doc(hidden)]
6696            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDCall {
6697                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6698                    Self {}
6699                }
6700            }
6701        }
6702        {
6703            #[doc(hidden)]
6704            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6705            #[doc(hidden)]
6706            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
6707            #[cfg(test)]
6708            #[allow(dead_code, unreachable_patterns)]
6709            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6710                match _t {
6711                    alloy_sol_types::private::AssertTypeEq::<
6712                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6713                    >(_) => {},
6714                }
6715            }
6716            #[automatically_derived]
6717            #[doc(hidden)]
6718            impl ::core::convert::From<proxiableUUIDReturn> for UnderlyingRustTuple<'_> {
6719                fn from(value: proxiableUUIDReturn) -> Self {
6720                    (value._0,)
6721                }
6722            }
6723            #[automatically_derived]
6724            #[doc(hidden)]
6725            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxiableUUIDReturn {
6726                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6727                    Self { _0: tuple.0 }
6728                }
6729            }
6730        }
6731        #[automatically_derived]
6732        impl alloy_sol_types::SolCall for proxiableUUIDCall {
6733            type Parameters<'a> = ();
6734            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
6735            type Return = proxiableUUIDReturn;
6736            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6737            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6738            const SIGNATURE: &'static str = "proxiableUUID()";
6739            const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8];
6740            #[inline]
6741            fn new<'a>(
6742                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6743            ) -> Self {
6744                tuple.into()
6745            }
6746            #[inline]
6747            fn tokenize(&self) -> Self::Token<'_> {
6748                ()
6749            }
6750            #[inline]
6751            fn abi_decode_returns(
6752                data: &[u8],
6753                validate: bool,
6754            ) -> alloy_sol_types::Result<Self::Return> {
6755                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
6756                    data, validate,
6757                )
6758                .map(Into::into)
6759            }
6760        }
6761    };
6762    #[derive()]
6763    /**Function with signature `registerValidator((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256),uint16)` and selector `0x13b9057a`.
6764    ```solidity
6765    function registerValidator(BN254.G2Point memory blsVK, EdOnBN254.EdOnBN254Point memory schnorrVK, BN254.G1Point memory blsSig, uint16 commission) external;
6766    ```*/
6767    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6768    #[derive(Clone)]
6769    pub struct registerValidatorCall {
6770        #[allow(missing_docs)]
6771        pub blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
6772        #[allow(missing_docs)]
6773        pub schnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
6774        #[allow(missing_docs)]
6775        pub blsSig: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
6776        #[allow(missing_docs)]
6777        pub commission: u16,
6778    }
6779    ///Container type for the return parameters of the [`registerValidator((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256),uint16)`](registerValidatorCall) function.
6780    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6781    #[derive(Clone)]
6782    pub struct registerValidatorReturn {}
6783    #[allow(
6784        non_camel_case_types,
6785        non_snake_case,
6786        clippy::pub_underscore_fields,
6787        clippy::style
6788    )]
6789    const _: () = {
6790        use alloy::sol_types as alloy_sol_types;
6791        {
6792            #[doc(hidden)]
6793            type UnderlyingSolTuple<'a> = (
6794                BN254::G2Point,
6795                EdOnBN254::EdOnBN254Point,
6796                BN254::G1Point,
6797                alloy::sol_types::sol_data::Uint<16>,
6798            );
6799            #[doc(hidden)]
6800            type UnderlyingRustTuple<'a> = (
6801                <BN254::G2Point as alloy::sol_types::SolType>::RustType,
6802                <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
6803                <BN254::G1Point as alloy::sol_types::SolType>::RustType,
6804                u16,
6805            );
6806            #[cfg(test)]
6807            #[allow(dead_code, unreachable_patterns)]
6808            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6809                match _t {
6810                    alloy_sol_types::private::AssertTypeEq::<
6811                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6812                    >(_) => {},
6813                }
6814            }
6815            #[automatically_derived]
6816            #[doc(hidden)]
6817            impl ::core::convert::From<registerValidatorCall> for UnderlyingRustTuple<'_> {
6818                fn from(value: registerValidatorCall) -> Self {
6819                    (value.blsVK, value.schnorrVK, value.blsSig, value.commission)
6820                }
6821            }
6822            #[automatically_derived]
6823            #[doc(hidden)]
6824            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerValidatorCall {
6825                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6826                    Self {
6827                        blsVK: tuple.0,
6828                        schnorrVK: tuple.1,
6829                        blsSig: tuple.2,
6830                        commission: tuple.3,
6831                    }
6832                }
6833            }
6834        }
6835        {
6836            #[doc(hidden)]
6837            type UnderlyingSolTuple<'a> = ();
6838            #[doc(hidden)]
6839            type UnderlyingRustTuple<'a> = ();
6840            #[cfg(test)]
6841            #[allow(dead_code, unreachable_patterns)]
6842            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6843                match _t {
6844                    alloy_sol_types::private::AssertTypeEq::<
6845                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6846                    >(_) => {},
6847                }
6848            }
6849            #[automatically_derived]
6850            #[doc(hidden)]
6851            impl ::core::convert::From<registerValidatorReturn> for UnderlyingRustTuple<'_> {
6852                fn from(value: registerValidatorReturn) -> Self {
6853                    ()
6854                }
6855            }
6856            #[automatically_derived]
6857            #[doc(hidden)]
6858            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerValidatorReturn {
6859                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6860                    Self {}
6861                }
6862            }
6863        }
6864        #[automatically_derived]
6865        impl alloy_sol_types::SolCall for registerValidatorCall {
6866            type Parameters<'a> = (
6867                BN254::G2Point,
6868                EdOnBN254::EdOnBN254Point,
6869                BN254::G1Point,
6870                alloy::sol_types::sol_data::Uint<16>,
6871            );
6872            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
6873            type Return = registerValidatorReturn;
6874            type ReturnTuple<'a> = ();
6875            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6876            const SIGNATURE: &'static str = "registerValidator((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256),uint16)";
6877            const SELECTOR: [u8; 4] = [19u8, 185u8, 5u8, 122u8];
6878            #[inline]
6879            fn new<'a>(
6880                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6881            ) -> Self {
6882                tuple.into()
6883            }
6884            #[inline]
6885            fn tokenize(&self) -> Self::Token<'_> {
6886                (
6887                    <BN254::G2Point as alloy_sol_types::SolType>::tokenize(&self.blsVK),
6888                    <EdOnBN254::EdOnBN254Point as alloy_sol_types::SolType>::tokenize(
6889                        &self.schnorrVK,
6890                    ),
6891                    <BN254::G1Point as alloy_sol_types::SolType>::tokenize(&self.blsSig),
6892                    <alloy::sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
6893                        &self.commission,
6894                    ),
6895                )
6896            }
6897            #[inline]
6898            fn abi_decode_returns(
6899                data: &[u8],
6900                validate: bool,
6901            ) -> alloy_sol_types::Result<Self::Return> {
6902                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
6903                    data, validate,
6904                )
6905                .map(Into::into)
6906            }
6907        }
6908    };
6909    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6910    /**Function with signature `renounceOwnership()` and selector `0x715018a6`.
6911    ```solidity
6912    function renounceOwnership() external;
6913    ```*/
6914    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6915    #[derive(Clone)]
6916    pub struct renounceOwnershipCall {}
6917    ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function.
6918    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6919    #[derive(Clone)]
6920    pub struct renounceOwnershipReturn {}
6921    #[allow(
6922        non_camel_case_types,
6923        non_snake_case,
6924        clippy::pub_underscore_fields,
6925        clippy::style
6926    )]
6927    const _: () = {
6928        use alloy::sol_types as alloy_sol_types;
6929        {
6930            #[doc(hidden)]
6931            type UnderlyingSolTuple<'a> = ();
6932            #[doc(hidden)]
6933            type UnderlyingRustTuple<'a> = ();
6934            #[cfg(test)]
6935            #[allow(dead_code, unreachable_patterns)]
6936            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6937                match _t {
6938                    alloy_sol_types::private::AssertTypeEq::<
6939                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6940                    >(_) => {},
6941                }
6942            }
6943            #[automatically_derived]
6944            #[doc(hidden)]
6945            impl ::core::convert::From<renounceOwnershipCall> for UnderlyingRustTuple<'_> {
6946                fn from(value: renounceOwnershipCall) -> Self {
6947                    ()
6948                }
6949            }
6950            #[automatically_derived]
6951            #[doc(hidden)]
6952            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipCall {
6953                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6954                    Self {}
6955                }
6956            }
6957        }
6958        {
6959            #[doc(hidden)]
6960            type UnderlyingSolTuple<'a> = ();
6961            #[doc(hidden)]
6962            type UnderlyingRustTuple<'a> = ();
6963            #[cfg(test)]
6964            #[allow(dead_code, unreachable_patterns)]
6965            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
6966                match _t {
6967                    alloy_sol_types::private::AssertTypeEq::<
6968                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6969                    >(_) => {},
6970                }
6971            }
6972            #[automatically_derived]
6973            #[doc(hidden)]
6974            impl ::core::convert::From<renounceOwnershipReturn> for UnderlyingRustTuple<'_> {
6975                fn from(value: renounceOwnershipReturn) -> Self {
6976                    ()
6977                }
6978            }
6979            #[automatically_derived]
6980            #[doc(hidden)]
6981            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipReturn {
6982                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6983                    Self {}
6984                }
6985            }
6986        }
6987        #[automatically_derived]
6988        impl alloy_sol_types::SolCall for renounceOwnershipCall {
6989            type Parameters<'a> = ();
6990            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
6991            type Return = renounceOwnershipReturn;
6992            type ReturnTuple<'a> = ();
6993            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
6994            const SIGNATURE: &'static str = "renounceOwnership()";
6995            const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
6996            #[inline]
6997            fn new<'a>(
6998                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6999            ) -> Self {
7000                tuple.into()
7001            }
7002            #[inline]
7003            fn tokenize(&self) -> Self::Token<'_> {
7004                ()
7005            }
7006            #[inline]
7007            fn abi_decode_returns(
7008                data: &[u8],
7009                validate: bool,
7010            ) -> alloy_sol_types::Result<Self::Return> {
7011                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
7012                    data, validate,
7013                )
7014                .map(Into::into)
7015            }
7016        }
7017    };
7018    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7019    /**Function with signature `token()` and selector `0xfc0c546a`.
7020    ```solidity
7021    function token() external view returns (address);
7022    ```*/
7023    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7024    #[derive(Clone)]
7025    pub struct tokenCall {}
7026    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7027    ///Container type for the return parameters of the [`token()`](tokenCall) function.
7028    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7029    #[derive(Clone)]
7030    pub struct tokenReturn {
7031        #[allow(missing_docs)]
7032        pub _0: alloy::sol_types::private::Address,
7033    }
7034    #[allow(
7035        non_camel_case_types,
7036        non_snake_case,
7037        clippy::pub_underscore_fields,
7038        clippy::style
7039    )]
7040    const _: () = {
7041        use alloy::sol_types as alloy_sol_types;
7042        {
7043            #[doc(hidden)]
7044            type UnderlyingSolTuple<'a> = ();
7045            #[doc(hidden)]
7046            type UnderlyingRustTuple<'a> = ();
7047            #[cfg(test)]
7048            #[allow(dead_code, unreachable_patterns)]
7049            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7050                match _t {
7051                    alloy_sol_types::private::AssertTypeEq::<
7052                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7053                    >(_) => {},
7054                }
7055            }
7056            #[automatically_derived]
7057            #[doc(hidden)]
7058            impl ::core::convert::From<tokenCall> for UnderlyingRustTuple<'_> {
7059                fn from(value: tokenCall) -> Self {
7060                    ()
7061                }
7062            }
7063            #[automatically_derived]
7064            #[doc(hidden)]
7065            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenCall {
7066                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7067                    Self {}
7068                }
7069            }
7070        }
7071        {
7072            #[doc(hidden)]
7073            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7074            #[doc(hidden)]
7075            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7076            #[cfg(test)]
7077            #[allow(dead_code, unreachable_patterns)]
7078            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7079                match _t {
7080                    alloy_sol_types::private::AssertTypeEq::<
7081                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7082                    >(_) => {},
7083                }
7084            }
7085            #[automatically_derived]
7086            #[doc(hidden)]
7087            impl ::core::convert::From<tokenReturn> for UnderlyingRustTuple<'_> {
7088                fn from(value: tokenReturn) -> Self {
7089                    (value._0,)
7090                }
7091            }
7092            #[automatically_derived]
7093            #[doc(hidden)]
7094            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenReturn {
7095                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7096                    Self { _0: tuple.0 }
7097                }
7098            }
7099        }
7100        #[automatically_derived]
7101        impl alloy_sol_types::SolCall for tokenCall {
7102            type Parameters<'a> = ();
7103            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7104            type Return = tokenReturn;
7105            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
7106            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7107            const SIGNATURE: &'static str = "token()";
7108            const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8];
7109            #[inline]
7110            fn new<'a>(
7111                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7112            ) -> Self {
7113                tuple.into()
7114            }
7115            #[inline]
7116            fn tokenize(&self) -> Self::Token<'_> {
7117                ()
7118            }
7119            #[inline]
7120            fn abi_decode_returns(
7121                data: &[u8],
7122                validate: bool,
7123            ) -> alloy_sol_types::Result<Self::Return> {
7124                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
7125                    data, validate,
7126                )
7127                .map(Into::into)
7128            }
7129        }
7130    };
7131    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7132    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
7133    ```solidity
7134    function transferOwnership(address newOwner) external;
7135    ```*/
7136    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7137    #[derive(Clone)]
7138    pub struct transferOwnershipCall {
7139        #[allow(missing_docs)]
7140        pub newOwner: alloy::sol_types::private::Address,
7141    }
7142    ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function.
7143    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7144    #[derive(Clone)]
7145    pub struct transferOwnershipReturn {}
7146    #[allow(
7147        non_camel_case_types,
7148        non_snake_case,
7149        clippy::pub_underscore_fields,
7150        clippy::style
7151    )]
7152    const _: () = {
7153        use alloy::sol_types as alloy_sol_types;
7154        {
7155            #[doc(hidden)]
7156            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7157            #[doc(hidden)]
7158            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7159            #[cfg(test)]
7160            #[allow(dead_code, unreachable_patterns)]
7161            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7162                match _t {
7163                    alloy_sol_types::private::AssertTypeEq::<
7164                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7165                    >(_) => {},
7166                }
7167            }
7168            #[automatically_derived]
7169            #[doc(hidden)]
7170            impl ::core::convert::From<transferOwnershipCall> for UnderlyingRustTuple<'_> {
7171                fn from(value: transferOwnershipCall) -> Self {
7172                    (value.newOwner,)
7173                }
7174            }
7175            #[automatically_derived]
7176            #[doc(hidden)]
7177            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipCall {
7178                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7179                    Self { newOwner: tuple.0 }
7180                }
7181            }
7182        }
7183        {
7184            #[doc(hidden)]
7185            type UnderlyingSolTuple<'a> = ();
7186            #[doc(hidden)]
7187            type UnderlyingRustTuple<'a> = ();
7188            #[cfg(test)]
7189            #[allow(dead_code, unreachable_patterns)]
7190            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7191                match _t {
7192                    alloy_sol_types::private::AssertTypeEq::<
7193                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7194                    >(_) => {},
7195                }
7196            }
7197            #[automatically_derived]
7198            #[doc(hidden)]
7199            impl ::core::convert::From<transferOwnershipReturn> for UnderlyingRustTuple<'_> {
7200                fn from(value: transferOwnershipReturn) -> Self {
7201                    ()
7202                }
7203            }
7204            #[automatically_derived]
7205            #[doc(hidden)]
7206            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipReturn {
7207                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7208                    Self {}
7209                }
7210            }
7211        }
7212        #[automatically_derived]
7213        impl alloy_sol_types::SolCall for transferOwnershipCall {
7214            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
7215            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7216            type Return = transferOwnershipReturn;
7217            type ReturnTuple<'a> = ();
7218            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7219            const SIGNATURE: &'static str = "transferOwnership(address)";
7220            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
7221            #[inline]
7222            fn new<'a>(
7223                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7224            ) -> Self {
7225                tuple.into()
7226            }
7227            #[inline]
7228            fn tokenize(&self) -> Self::Token<'_> {
7229                (
7230                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7231                        &self.newOwner,
7232                    ),
7233                )
7234            }
7235            #[inline]
7236            fn abi_decode_returns(
7237                data: &[u8],
7238                validate: bool,
7239            ) -> alloy_sol_types::Result<Self::Return> {
7240                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
7241                    data, validate,
7242                )
7243                .map(Into::into)
7244            }
7245        }
7246    };
7247    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7248    /**Function with signature `undelegate(address,uint256)` and selector `0x4d99dd16`.
7249    ```solidity
7250    function undelegate(address validator, uint256 amount) external;
7251    ```*/
7252    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7253    #[derive(Clone)]
7254    pub struct undelegateCall {
7255        #[allow(missing_docs)]
7256        pub validator: alloy::sol_types::private::Address,
7257        #[allow(missing_docs)]
7258        pub amount: alloy::sol_types::private::primitives::aliases::U256,
7259    }
7260    ///Container type for the return parameters of the [`undelegate(address,uint256)`](undelegateCall) function.
7261    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7262    #[derive(Clone)]
7263    pub struct undelegateReturn {}
7264    #[allow(
7265        non_camel_case_types,
7266        non_snake_case,
7267        clippy::pub_underscore_fields,
7268        clippy::style
7269    )]
7270    const _: () = {
7271        use alloy::sol_types as alloy_sol_types;
7272        {
7273            #[doc(hidden)]
7274            type UnderlyingSolTuple<'a> = (
7275                alloy::sol_types::sol_data::Address,
7276                alloy::sol_types::sol_data::Uint<256>,
7277            );
7278            #[doc(hidden)]
7279            type UnderlyingRustTuple<'a> = (
7280                alloy::sol_types::private::Address,
7281                alloy::sol_types::private::primitives::aliases::U256,
7282            );
7283            #[cfg(test)]
7284            #[allow(dead_code, unreachable_patterns)]
7285            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7286                match _t {
7287                    alloy_sol_types::private::AssertTypeEq::<
7288                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7289                    >(_) => {},
7290                }
7291            }
7292            #[automatically_derived]
7293            #[doc(hidden)]
7294            impl ::core::convert::From<undelegateCall> for UnderlyingRustTuple<'_> {
7295                fn from(value: undelegateCall) -> Self {
7296                    (value.validator, value.amount)
7297                }
7298            }
7299            #[automatically_derived]
7300            #[doc(hidden)]
7301            impl ::core::convert::From<UnderlyingRustTuple<'_>> for undelegateCall {
7302                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7303                    Self {
7304                        validator: tuple.0,
7305                        amount: tuple.1,
7306                    }
7307                }
7308            }
7309        }
7310        {
7311            #[doc(hidden)]
7312            type UnderlyingSolTuple<'a> = ();
7313            #[doc(hidden)]
7314            type UnderlyingRustTuple<'a> = ();
7315            #[cfg(test)]
7316            #[allow(dead_code, unreachable_patterns)]
7317            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7318                match _t {
7319                    alloy_sol_types::private::AssertTypeEq::<
7320                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7321                    >(_) => {},
7322                }
7323            }
7324            #[automatically_derived]
7325            #[doc(hidden)]
7326            impl ::core::convert::From<undelegateReturn> for UnderlyingRustTuple<'_> {
7327                fn from(value: undelegateReturn) -> Self {
7328                    ()
7329                }
7330            }
7331            #[automatically_derived]
7332            #[doc(hidden)]
7333            impl ::core::convert::From<UnderlyingRustTuple<'_>> for undelegateReturn {
7334                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7335                    Self {}
7336                }
7337            }
7338        }
7339        #[automatically_derived]
7340        impl alloy_sol_types::SolCall for undelegateCall {
7341            type Parameters<'a> = (
7342                alloy::sol_types::sol_data::Address,
7343                alloy::sol_types::sol_data::Uint<256>,
7344            );
7345            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7346            type Return = undelegateReturn;
7347            type ReturnTuple<'a> = ();
7348            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7349            const SIGNATURE: &'static str = "undelegate(address,uint256)";
7350            const SELECTOR: [u8; 4] = [77u8, 153u8, 221u8, 22u8];
7351            #[inline]
7352            fn new<'a>(
7353                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7354            ) -> Self {
7355                tuple.into()
7356            }
7357            #[inline]
7358            fn tokenize(&self) -> Self::Token<'_> {
7359                (
7360                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7361                        &self.validator,
7362                    ),
7363                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
7364                        &self.amount,
7365                    ),
7366                )
7367            }
7368            #[inline]
7369            fn abi_decode_returns(
7370                data: &[u8],
7371                validate: bool,
7372            ) -> alloy_sol_types::Result<Self::Return> {
7373                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
7374                    data, validate,
7375                )
7376                .map(Into::into)
7377            }
7378        }
7379    };
7380    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7381    /**Function with signature `undelegations(address,address)` and selector `0xa2d78dd5`.
7382    ```solidity
7383    function undelegations(address validator, address delegator) external view returns (uint256 amount, uint256 unlocksAt);
7384    ```*/
7385    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7386    #[derive(Clone)]
7387    pub struct undelegationsCall {
7388        #[allow(missing_docs)]
7389        pub validator: alloy::sol_types::private::Address,
7390        #[allow(missing_docs)]
7391        pub delegator: alloy::sol_types::private::Address,
7392    }
7393    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7394    ///Container type for the return parameters of the [`undelegations(address,address)`](undelegationsCall) function.
7395    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7396    #[derive(Clone)]
7397    pub struct undelegationsReturn {
7398        #[allow(missing_docs)]
7399        pub amount: alloy::sol_types::private::primitives::aliases::U256,
7400        #[allow(missing_docs)]
7401        pub unlocksAt: alloy::sol_types::private::primitives::aliases::U256,
7402    }
7403    #[allow(
7404        non_camel_case_types,
7405        non_snake_case,
7406        clippy::pub_underscore_fields,
7407        clippy::style
7408    )]
7409    const _: () = {
7410        use alloy::sol_types as alloy_sol_types;
7411        {
7412            #[doc(hidden)]
7413            type UnderlyingSolTuple<'a> = (
7414                alloy::sol_types::sol_data::Address,
7415                alloy::sol_types::sol_data::Address,
7416            );
7417            #[doc(hidden)]
7418            type UnderlyingRustTuple<'a> = (
7419                alloy::sol_types::private::Address,
7420                alloy::sol_types::private::Address,
7421            );
7422            #[cfg(test)]
7423            #[allow(dead_code, unreachable_patterns)]
7424            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7425                match _t {
7426                    alloy_sol_types::private::AssertTypeEq::<
7427                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7428                    >(_) => {},
7429                }
7430            }
7431            #[automatically_derived]
7432            #[doc(hidden)]
7433            impl ::core::convert::From<undelegationsCall> for UnderlyingRustTuple<'_> {
7434                fn from(value: undelegationsCall) -> Self {
7435                    (value.validator, value.delegator)
7436                }
7437            }
7438            #[automatically_derived]
7439            #[doc(hidden)]
7440            impl ::core::convert::From<UnderlyingRustTuple<'_>> for undelegationsCall {
7441                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7442                    Self {
7443                        validator: tuple.0,
7444                        delegator: tuple.1,
7445                    }
7446                }
7447            }
7448        }
7449        {
7450            #[doc(hidden)]
7451            type UnderlyingSolTuple<'a> = (
7452                alloy::sol_types::sol_data::Uint<256>,
7453                alloy::sol_types::sol_data::Uint<256>,
7454            );
7455            #[doc(hidden)]
7456            type UnderlyingRustTuple<'a> = (
7457                alloy::sol_types::private::primitives::aliases::U256,
7458                alloy::sol_types::private::primitives::aliases::U256,
7459            );
7460            #[cfg(test)]
7461            #[allow(dead_code, unreachable_patterns)]
7462            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7463                match _t {
7464                    alloy_sol_types::private::AssertTypeEq::<
7465                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7466                    >(_) => {},
7467                }
7468            }
7469            #[automatically_derived]
7470            #[doc(hidden)]
7471            impl ::core::convert::From<undelegationsReturn> for UnderlyingRustTuple<'_> {
7472                fn from(value: undelegationsReturn) -> Self {
7473                    (value.amount, value.unlocksAt)
7474                }
7475            }
7476            #[automatically_derived]
7477            #[doc(hidden)]
7478            impl ::core::convert::From<UnderlyingRustTuple<'_>> for undelegationsReturn {
7479                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7480                    Self {
7481                        amount: tuple.0,
7482                        unlocksAt: tuple.1,
7483                    }
7484                }
7485            }
7486        }
7487        #[automatically_derived]
7488        impl alloy_sol_types::SolCall for undelegationsCall {
7489            type Parameters<'a> = (
7490                alloy::sol_types::sol_data::Address,
7491                alloy::sol_types::sol_data::Address,
7492            );
7493            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7494            type Return = undelegationsReturn;
7495            type ReturnTuple<'a> = (
7496                alloy::sol_types::sol_data::Uint<256>,
7497                alloy::sol_types::sol_data::Uint<256>,
7498            );
7499            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7500            const SIGNATURE: &'static str = "undelegations(address,address)";
7501            const SELECTOR: [u8; 4] = [162u8, 215u8, 141u8, 213u8];
7502            #[inline]
7503            fn new<'a>(
7504                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7505            ) -> Self {
7506                tuple.into()
7507            }
7508            #[inline]
7509            fn tokenize(&self) -> Self::Token<'_> {
7510                (
7511                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7512                        &self.validator,
7513                    ),
7514                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7515                        &self.delegator,
7516                    ),
7517                )
7518            }
7519            #[inline]
7520            fn abi_decode_returns(
7521                data: &[u8],
7522                validate: bool,
7523            ) -> alloy_sol_types::Result<Self::Return> {
7524                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
7525                    data, validate,
7526                )
7527                .map(Into::into)
7528            }
7529        }
7530    };
7531    #[derive()]
7532    /**Function with signature `updateConsensusKeys((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256))` and selector `0x5544c2f1`.
7533    ```solidity
7534    function updateConsensusKeys(BN254.G2Point memory newBlsVK, EdOnBN254.EdOnBN254Point memory newSchnorrVK, BN254.G1Point memory newBlsSig) external;
7535    ```*/
7536    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7537    #[derive(Clone)]
7538    pub struct updateConsensusKeysCall {
7539        #[allow(missing_docs)]
7540        pub newBlsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
7541        #[allow(missing_docs)]
7542        pub newSchnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
7543        #[allow(missing_docs)]
7544        pub newBlsSig: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
7545    }
7546    ///Container type for the return parameters of the [`updateConsensusKeys((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256))`](updateConsensusKeysCall) function.
7547    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7548    #[derive(Clone)]
7549    pub struct updateConsensusKeysReturn {}
7550    #[allow(
7551        non_camel_case_types,
7552        non_snake_case,
7553        clippy::pub_underscore_fields,
7554        clippy::style
7555    )]
7556    const _: () = {
7557        use alloy::sol_types as alloy_sol_types;
7558        {
7559            #[doc(hidden)]
7560            type UnderlyingSolTuple<'a> =
7561                (BN254::G2Point, EdOnBN254::EdOnBN254Point, BN254::G1Point);
7562            #[doc(hidden)]
7563            type UnderlyingRustTuple<'a> = (
7564                <BN254::G2Point as alloy::sol_types::SolType>::RustType,
7565                <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
7566                <BN254::G1Point as alloy::sol_types::SolType>::RustType,
7567            );
7568            #[cfg(test)]
7569            #[allow(dead_code, unreachable_patterns)]
7570            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7571                match _t {
7572                    alloy_sol_types::private::AssertTypeEq::<
7573                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7574                    >(_) => {},
7575                }
7576            }
7577            #[automatically_derived]
7578            #[doc(hidden)]
7579            impl ::core::convert::From<updateConsensusKeysCall> for UnderlyingRustTuple<'_> {
7580                fn from(value: updateConsensusKeysCall) -> Self {
7581                    (value.newBlsVK, value.newSchnorrVK, value.newBlsSig)
7582                }
7583            }
7584            #[automatically_derived]
7585            #[doc(hidden)]
7586            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateConsensusKeysCall {
7587                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7588                    Self {
7589                        newBlsVK: tuple.0,
7590                        newSchnorrVK: tuple.1,
7591                        newBlsSig: tuple.2,
7592                    }
7593                }
7594            }
7595        }
7596        {
7597            #[doc(hidden)]
7598            type UnderlyingSolTuple<'a> = ();
7599            #[doc(hidden)]
7600            type UnderlyingRustTuple<'a> = ();
7601            #[cfg(test)]
7602            #[allow(dead_code, unreachable_patterns)]
7603            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7604                match _t {
7605                    alloy_sol_types::private::AssertTypeEq::<
7606                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7607                    >(_) => {},
7608                }
7609            }
7610            #[automatically_derived]
7611            #[doc(hidden)]
7612            impl ::core::convert::From<updateConsensusKeysReturn> for UnderlyingRustTuple<'_> {
7613                fn from(value: updateConsensusKeysReturn) -> Self {
7614                    ()
7615                }
7616            }
7617            #[automatically_derived]
7618            #[doc(hidden)]
7619            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateConsensusKeysReturn {
7620                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7621                    Self {}
7622                }
7623            }
7624        }
7625        #[automatically_derived]
7626        impl alloy_sol_types::SolCall for updateConsensusKeysCall {
7627            type Parameters<'a> = (BN254::G2Point, EdOnBN254::EdOnBN254Point, BN254::G1Point);
7628            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7629            type Return = updateConsensusKeysReturn;
7630            type ReturnTuple<'a> = ();
7631            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7632            const SIGNATURE: &'static str = "updateConsensusKeys((uint256,uint256,uint256,uint256),(uint256,uint256),(uint256,uint256))";
7633            const SELECTOR: [u8; 4] = [85u8, 68u8, 194u8, 241u8];
7634            #[inline]
7635            fn new<'a>(
7636                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7637            ) -> Self {
7638                tuple.into()
7639            }
7640            #[inline]
7641            fn tokenize(&self) -> Self::Token<'_> {
7642                (
7643                    <BN254::G2Point as alloy_sol_types::SolType>::tokenize(&self.newBlsVK),
7644                    <EdOnBN254::EdOnBN254Point as alloy_sol_types::SolType>::tokenize(
7645                        &self.newSchnorrVK,
7646                    ),
7647                    <BN254::G1Point as alloy_sol_types::SolType>::tokenize(&self.newBlsSig),
7648                )
7649            }
7650            #[inline]
7651            fn abi_decode_returns(
7652                data: &[u8],
7653                validate: bool,
7654            ) -> alloy_sol_types::Result<Self::Return> {
7655                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
7656                    data, validate,
7657                )
7658                .map(Into::into)
7659            }
7660        }
7661    };
7662    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7663    /**Function with signature `upgradeToAndCall(address,bytes)` and selector `0x4f1ef286`.
7664    ```solidity
7665    function upgradeToAndCall(address newImplementation, bytes memory data) external payable;
7666    ```*/
7667    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7668    #[derive(Clone)]
7669    pub struct upgradeToAndCallCall {
7670        #[allow(missing_docs)]
7671        pub newImplementation: alloy::sol_types::private::Address,
7672        #[allow(missing_docs)]
7673        pub data: alloy::sol_types::private::Bytes,
7674    }
7675    ///Container type for the return parameters of the [`upgradeToAndCall(address,bytes)`](upgradeToAndCallCall) function.
7676    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7677    #[derive(Clone)]
7678    pub struct upgradeToAndCallReturn {}
7679    #[allow(
7680        non_camel_case_types,
7681        non_snake_case,
7682        clippy::pub_underscore_fields,
7683        clippy::style
7684    )]
7685    const _: () = {
7686        use alloy::sol_types as alloy_sol_types;
7687        {
7688            #[doc(hidden)]
7689            type UnderlyingSolTuple<'a> = (
7690                alloy::sol_types::sol_data::Address,
7691                alloy::sol_types::sol_data::Bytes,
7692            );
7693            #[doc(hidden)]
7694            type UnderlyingRustTuple<'a> = (
7695                alloy::sol_types::private::Address,
7696                alloy::sol_types::private::Bytes,
7697            );
7698            #[cfg(test)]
7699            #[allow(dead_code, unreachable_patterns)]
7700            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7701                match _t {
7702                    alloy_sol_types::private::AssertTypeEq::<
7703                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7704                    >(_) => {},
7705                }
7706            }
7707            #[automatically_derived]
7708            #[doc(hidden)]
7709            impl ::core::convert::From<upgradeToAndCallCall> for UnderlyingRustTuple<'_> {
7710                fn from(value: upgradeToAndCallCall) -> Self {
7711                    (value.newImplementation, value.data)
7712                }
7713            }
7714            #[automatically_derived]
7715            #[doc(hidden)]
7716            impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeToAndCallCall {
7717                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7718                    Self {
7719                        newImplementation: tuple.0,
7720                        data: tuple.1,
7721                    }
7722                }
7723            }
7724        }
7725        {
7726            #[doc(hidden)]
7727            type UnderlyingSolTuple<'a> = ();
7728            #[doc(hidden)]
7729            type UnderlyingRustTuple<'a> = ();
7730            #[cfg(test)]
7731            #[allow(dead_code, unreachable_patterns)]
7732            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7733                match _t {
7734                    alloy_sol_types::private::AssertTypeEq::<
7735                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7736                    >(_) => {},
7737                }
7738            }
7739            #[automatically_derived]
7740            #[doc(hidden)]
7741            impl ::core::convert::From<upgradeToAndCallReturn> for UnderlyingRustTuple<'_> {
7742                fn from(value: upgradeToAndCallReturn) -> Self {
7743                    ()
7744                }
7745            }
7746            #[automatically_derived]
7747            #[doc(hidden)]
7748            impl ::core::convert::From<UnderlyingRustTuple<'_>> for upgradeToAndCallReturn {
7749                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7750                    Self {}
7751                }
7752            }
7753        }
7754        #[automatically_derived]
7755        impl alloy_sol_types::SolCall for upgradeToAndCallCall {
7756            type Parameters<'a> = (
7757                alloy::sol_types::sol_data::Address,
7758                alloy::sol_types::sol_data::Bytes,
7759            );
7760            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7761            type Return = upgradeToAndCallReturn;
7762            type ReturnTuple<'a> = ();
7763            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7764            const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)";
7765            const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8];
7766            #[inline]
7767            fn new<'a>(
7768                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7769            ) -> Self {
7770                tuple.into()
7771            }
7772            #[inline]
7773            fn tokenize(&self) -> Self::Token<'_> {
7774                (
7775                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7776                        &self.newImplementation,
7777                    ),
7778                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
7779                        &self.data,
7780                    ),
7781                )
7782            }
7783            #[inline]
7784            fn abi_decode_returns(
7785                data: &[u8],
7786                validate: bool,
7787            ) -> alloy_sol_types::Result<Self::Return> {
7788                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
7789                    data, validate,
7790                )
7791                .map(Into::into)
7792            }
7793        }
7794    };
7795    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7796    /**Function with signature `validatorExits(address)` and selector `0xb5ecb344`.
7797    ```solidity
7798    function validatorExits(address validator) external view returns (uint256 unlocksAt);
7799    ```*/
7800    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7801    #[derive(Clone)]
7802    pub struct validatorExitsCall {
7803        #[allow(missing_docs)]
7804        pub validator: alloy::sol_types::private::Address,
7805    }
7806    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7807    ///Container type for the return parameters of the [`validatorExits(address)`](validatorExitsCall) function.
7808    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7809    #[derive(Clone)]
7810    pub struct validatorExitsReturn {
7811        #[allow(missing_docs)]
7812        pub unlocksAt: alloy::sol_types::private::primitives::aliases::U256,
7813    }
7814    #[allow(
7815        non_camel_case_types,
7816        non_snake_case,
7817        clippy::pub_underscore_fields,
7818        clippy::style
7819    )]
7820    const _: () = {
7821        use alloy::sol_types as alloy_sol_types;
7822        {
7823            #[doc(hidden)]
7824            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7825            #[doc(hidden)]
7826            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7827            #[cfg(test)]
7828            #[allow(dead_code, unreachable_patterns)]
7829            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7830                match _t {
7831                    alloy_sol_types::private::AssertTypeEq::<
7832                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7833                    >(_) => {},
7834                }
7835            }
7836            #[automatically_derived]
7837            #[doc(hidden)]
7838            impl ::core::convert::From<validatorExitsCall> for UnderlyingRustTuple<'_> {
7839                fn from(value: validatorExitsCall) -> Self {
7840                    (value.validator,)
7841                }
7842            }
7843            #[automatically_derived]
7844            #[doc(hidden)]
7845            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validatorExitsCall {
7846                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7847                    Self { validator: tuple.0 }
7848                }
7849            }
7850        }
7851        {
7852            #[doc(hidden)]
7853            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7854            #[doc(hidden)]
7855            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
7856            #[cfg(test)]
7857            #[allow(dead_code, unreachable_patterns)]
7858            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7859                match _t {
7860                    alloy_sol_types::private::AssertTypeEq::<
7861                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7862                    >(_) => {},
7863                }
7864            }
7865            #[automatically_derived]
7866            #[doc(hidden)]
7867            impl ::core::convert::From<validatorExitsReturn> for UnderlyingRustTuple<'_> {
7868                fn from(value: validatorExitsReturn) -> Self {
7869                    (value.unlocksAt,)
7870                }
7871            }
7872            #[automatically_derived]
7873            #[doc(hidden)]
7874            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validatorExitsReturn {
7875                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7876                    Self { unlocksAt: tuple.0 }
7877                }
7878            }
7879        }
7880        #[automatically_derived]
7881        impl alloy_sol_types::SolCall for validatorExitsCall {
7882            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
7883            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
7884            type Return = validatorExitsReturn;
7885            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7886            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
7887            const SIGNATURE: &'static str = "validatorExits(address)";
7888            const SELECTOR: [u8; 4] = [181u8, 236u8, 179u8, 68u8];
7889            #[inline]
7890            fn new<'a>(
7891                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7892            ) -> Self {
7893                tuple.into()
7894            }
7895            #[inline]
7896            fn tokenize(&self) -> Self::Token<'_> {
7897                (
7898                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7899                        &self.validator,
7900                    ),
7901                )
7902            }
7903            #[inline]
7904            fn abi_decode_returns(
7905                data: &[u8],
7906                validate: bool,
7907            ) -> alloy_sol_types::Result<Self::Return> {
7908                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
7909                    data, validate,
7910                )
7911                .map(Into::into)
7912            }
7913        }
7914    };
7915    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7916    /**Function with signature `validators(address)` and selector `0xfa52c7d8`.
7917    ```solidity
7918    function validators(address account) external view returns (uint256 delegatedAmount, ValidatorStatus status);
7919    ```*/
7920    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7921    #[derive(Clone)]
7922    pub struct validatorsCall {
7923        #[allow(missing_docs)]
7924        pub account: alloy::sol_types::private::Address,
7925    }
7926    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7927    ///Container type for the return parameters of the [`validators(address)`](validatorsCall) function.
7928    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7929    #[derive(Clone)]
7930    pub struct validatorsReturn {
7931        #[allow(missing_docs)]
7932        pub delegatedAmount: alloy::sol_types::private::primitives::aliases::U256,
7933        #[allow(missing_docs)]
7934        pub status: <ValidatorStatus as alloy::sol_types::SolType>::RustType,
7935    }
7936    #[allow(
7937        non_camel_case_types,
7938        non_snake_case,
7939        clippy::pub_underscore_fields,
7940        clippy::style
7941    )]
7942    const _: () = {
7943        use alloy::sol_types as alloy_sol_types;
7944        {
7945            #[doc(hidden)]
7946            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7947            #[doc(hidden)]
7948            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7949            #[cfg(test)]
7950            #[allow(dead_code, unreachable_patterns)]
7951            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7952                match _t {
7953                    alloy_sol_types::private::AssertTypeEq::<
7954                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7955                    >(_) => {},
7956                }
7957            }
7958            #[automatically_derived]
7959            #[doc(hidden)]
7960            impl ::core::convert::From<validatorsCall> for UnderlyingRustTuple<'_> {
7961                fn from(value: validatorsCall) -> Self {
7962                    (value.account,)
7963                }
7964            }
7965            #[automatically_derived]
7966            #[doc(hidden)]
7967            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validatorsCall {
7968                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7969                    Self { account: tuple.0 }
7970                }
7971            }
7972        }
7973        {
7974            #[doc(hidden)]
7975            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>, ValidatorStatus);
7976            #[doc(hidden)]
7977            type UnderlyingRustTuple<'a> = (
7978                alloy::sol_types::private::primitives::aliases::U256,
7979                <ValidatorStatus as alloy::sol_types::SolType>::RustType,
7980            );
7981            #[cfg(test)]
7982            #[allow(dead_code, unreachable_patterns)]
7983            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
7984                match _t {
7985                    alloy_sol_types::private::AssertTypeEq::<
7986                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7987                    >(_) => {},
7988                }
7989            }
7990            #[automatically_derived]
7991            #[doc(hidden)]
7992            impl ::core::convert::From<validatorsReturn> for UnderlyingRustTuple<'_> {
7993                fn from(value: validatorsReturn) -> Self {
7994                    (value.delegatedAmount, value.status)
7995                }
7996            }
7997            #[automatically_derived]
7998            #[doc(hidden)]
7999            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validatorsReturn {
8000                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8001                    Self {
8002                        delegatedAmount: tuple.0,
8003                        status: tuple.1,
8004                    }
8005                }
8006            }
8007        }
8008        #[automatically_derived]
8009        impl alloy_sol_types::SolCall for validatorsCall {
8010            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
8011            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
8012            type Return = validatorsReturn;
8013            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>, ValidatorStatus);
8014            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
8015            const SIGNATURE: &'static str = "validators(address)";
8016            const SELECTOR: [u8; 4] = [250u8, 82u8, 199u8, 216u8];
8017            #[inline]
8018            fn new<'a>(
8019                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8020            ) -> Self {
8021                tuple.into()
8022            }
8023            #[inline]
8024            fn tokenize(&self) -> Self::Token<'_> {
8025                (
8026                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8027                        &self.account,
8028                    ),
8029                )
8030            }
8031            #[inline]
8032            fn abi_decode_returns(
8033                data: &[u8],
8034                validate: bool,
8035            ) -> alloy_sol_types::Result<Self::Return> {
8036                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(
8037                    data, validate,
8038                )
8039                .map(Into::into)
8040            }
8041        }
8042    };
8043    ///Container for all the [`StakeTable`](self) function calls.
8044    #[derive()]
8045    pub enum StakeTableCalls {
8046        #[allow(missing_docs)]
8047        UPGRADE_INTERFACE_VERSION(UPGRADE_INTERFACE_VERSIONCall),
8048        #[allow(missing_docs)]
8049        _hashBlsKey(_hashBlsKeyCall),
8050        #[allow(missing_docs)]
8051        blsKeys(blsKeysCall),
8052        #[allow(missing_docs)]
8053        claimValidatorExit(claimValidatorExitCall),
8054        #[allow(missing_docs)]
8055        claimWithdrawal(claimWithdrawalCall),
8056        #[allow(missing_docs)]
8057        delegate(delegateCall),
8058        #[allow(missing_docs)]
8059        delegations(delegationsCall),
8060        #[allow(missing_docs)]
8061        deregisterValidator(deregisterValidatorCall),
8062        #[allow(missing_docs)]
8063        exitEscrowPeriod(exitEscrowPeriodCall),
8064        #[allow(missing_docs)]
8065        getVersion(getVersionCall),
8066        #[allow(missing_docs)]
8067        initialize(initializeCall),
8068        #[allow(missing_docs)]
8069        initializedAtBlock(initializedAtBlockCall),
8070        #[allow(missing_docs)]
8071        lightClient(lightClientCall),
8072        #[allow(missing_docs)]
8073        owner(ownerCall),
8074        #[allow(missing_docs)]
8075        proxiableUUID(proxiableUUIDCall),
8076        #[allow(missing_docs)]
8077        registerValidator(registerValidatorCall),
8078        #[allow(missing_docs)]
8079        renounceOwnership(renounceOwnershipCall),
8080        #[allow(missing_docs)]
8081        token(tokenCall),
8082        #[allow(missing_docs)]
8083        transferOwnership(transferOwnershipCall),
8084        #[allow(missing_docs)]
8085        undelegate(undelegateCall),
8086        #[allow(missing_docs)]
8087        undelegations(undelegationsCall),
8088        #[allow(missing_docs)]
8089        updateConsensusKeys(updateConsensusKeysCall),
8090        #[allow(missing_docs)]
8091        upgradeToAndCall(upgradeToAndCallCall),
8092        #[allow(missing_docs)]
8093        validatorExits(validatorExitsCall),
8094        #[allow(missing_docs)]
8095        validators(validatorsCall),
8096    }
8097    #[automatically_derived]
8098    impl StakeTableCalls {
8099        /// All the selectors of this enum.
8100        ///
8101        /// Note that the selectors might not be in the same order as the variants.
8102        /// No guarantees are made about the order of the selectors.
8103        ///
8104        /// Prefer using `SolInterface` methods instead.
8105        pub const SELECTORS: &'static [[u8; 4usize]] = &[
8106            [2u8, 110u8, 64u8, 43u8],
8107            [13u8, 142u8, 110u8, 44u8],
8108            [19u8, 185u8, 5u8, 122u8],
8109            [33u8, 64u8, 254u8, 205u8],
8110            [62u8, 157u8, 249u8, 181u8],
8111            [77u8, 153u8, 221u8, 22u8],
8112            [79u8, 30u8, 242u8, 134u8],
8113            [82u8, 209u8, 144u8, 45u8],
8114            [85u8, 68u8, 194u8, 241u8],
8115            [106u8, 145u8, 28u8, 207u8],
8116            [113u8, 80u8, 24u8, 166u8],
8117            [141u8, 165u8, 203u8, 91u8],
8118            [155u8, 48u8, 165u8, 230u8],
8119            [158u8, 154u8, 143u8, 49u8],
8120            [162u8, 215u8, 141u8, 213u8],
8121            [163u8, 6u8, 106u8, 171u8],
8122            [173u8, 60u8, 177u8, 204u8],
8123            [179u8, 230u8, 235u8, 213u8],
8124            [181u8, 112u8, 14u8, 104u8],
8125            [181u8, 236u8, 179u8, 68u8],
8126            [190u8, 32u8, 48u8, 148u8],
8127            [198u8, 72u8, 20u8, 221u8],
8128            [242u8, 253u8, 227u8, 139u8],
8129            [250u8, 82u8, 199u8, 216u8],
8130            [252u8, 12u8, 84u8, 106u8],
8131        ];
8132    }
8133    #[automatically_derived]
8134    impl alloy_sol_types::SolInterface for StakeTableCalls {
8135        const NAME: &'static str = "StakeTableCalls";
8136        const MIN_DATA_LENGTH: usize = 0usize;
8137        const COUNT: usize = 25usize;
8138        #[inline]
8139        fn selector(&self) -> [u8; 4] {
8140            match self {
8141                Self::UPGRADE_INTERFACE_VERSION(_) => {
8142                    <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::SELECTOR
8143                },
8144                Self::_hashBlsKey(_) => <_hashBlsKeyCall as alloy_sol_types::SolCall>::SELECTOR,
8145                Self::blsKeys(_) => <blsKeysCall as alloy_sol_types::SolCall>::SELECTOR,
8146                Self::claimValidatorExit(_) => {
8147                    <claimValidatorExitCall as alloy_sol_types::SolCall>::SELECTOR
8148                },
8149                Self::claimWithdrawal(_) => {
8150                    <claimWithdrawalCall as alloy_sol_types::SolCall>::SELECTOR
8151                },
8152                Self::delegate(_) => <delegateCall as alloy_sol_types::SolCall>::SELECTOR,
8153                Self::delegations(_) => <delegationsCall as alloy_sol_types::SolCall>::SELECTOR,
8154                Self::deregisterValidator(_) => {
8155                    <deregisterValidatorCall as alloy_sol_types::SolCall>::SELECTOR
8156                },
8157                Self::exitEscrowPeriod(_) => {
8158                    <exitEscrowPeriodCall as alloy_sol_types::SolCall>::SELECTOR
8159                },
8160                Self::getVersion(_) => <getVersionCall as alloy_sol_types::SolCall>::SELECTOR,
8161                Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
8162                Self::initializedAtBlock(_) => {
8163                    <initializedAtBlockCall as alloy_sol_types::SolCall>::SELECTOR
8164                },
8165                Self::lightClient(_) => <lightClientCall as alloy_sol_types::SolCall>::SELECTOR,
8166                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
8167                Self::proxiableUUID(_) => <proxiableUUIDCall as alloy_sol_types::SolCall>::SELECTOR,
8168                Self::registerValidator(_) => {
8169                    <registerValidatorCall as alloy_sol_types::SolCall>::SELECTOR
8170                },
8171                Self::renounceOwnership(_) => {
8172                    <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
8173                },
8174                Self::token(_) => <tokenCall as alloy_sol_types::SolCall>::SELECTOR,
8175                Self::transferOwnership(_) => {
8176                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
8177                },
8178                Self::undelegate(_) => <undelegateCall as alloy_sol_types::SolCall>::SELECTOR,
8179                Self::undelegations(_) => <undelegationsCall as alloy_sol_types::SolCall>::SELECTOR,
8180                Self::updateConsensusKeys(_) => {
8181                    <updateConsensusKeysCall as alloy_sol_types::SolCall>::SELECTOR
8182                },
8183                Self::upgradeToAndCall(_) => {
8184                    <upgradeToAndCallCall as alloy_sol_types::SolCall>::SELECTOR
8185                },
8186                Self::validatorExits(_) => {
8187                    <validatorExitsCall as alloy_sol_types::SolCall>::SELECTOR
8188                },
8189                Self::validators(_) => <validatorsCall as alloy_sol_types::SolCall>::SELECTOR,
8190            }
8191        }
8192        #[inline]
8193        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
8194            Self::SELECTORS.get(i).copied()
8195        }
8196        #[inline]
8197        fn valid_selector(selector: [u8; 4]) -> bool {
8198            Self::SELECTORS.binary_search(&selector).is_ok()
8199        }
8200        #[inline]
8201        #[allow(non_snake_case)]
8202        fn abi_decode_raw(
8203            selector: [u8; 4],
8204            data: &[u8],
8205            validate: bool,
8206        ) -> alloy_sol_types::Result<Self> {
8207            static DECODE_SHIMS: &[fn(&[u8], bool) -> alloy_sol_types::Result<StakeTableCalls>] = &[
8208                {
8209                    fn delegate(
8210                        data: &[u8],
8211                        validate: bool,
8212                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8213                        <delegateCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
8214                            .map(StakeTableCalls::delegate)
8215                    }
8216                    delegate
8217                },
8218                {
8219                    fn getVersion(
8220                        data: &[u8],
8221                        validate: bool,
8222                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8223                        <getVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
8224                            .map(StakeTableCalls::getVersion)
8225                    }
8226                    getVersion
8227                },
8228                {
8229                    fn registerValidator(
8230                        data: &[u8],
8231                        validate: bool,
8232                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8233                        <registerValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
8234                            data, validate,
8235                        )
8236                        .map(StakeTableCalls::registerValidator)
8237                    }
8238                    registerValidator
8239                },
8240                {
8241                    fn claimValidatorExit(
8242                        data: &[u8],
8243                        validate: bool,
8244                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8245                        <claimValidatorExitCall as alloy_sol_types::SolCall>::abi_decode_raw(
8246                            data, validate,
8247                        )
8248                        .map(StakeTableCalls::claimValidatorExit)
8249                    }
8250                    claimValidatorExit
8251                },
8252                {
8253                    fn initializedAtBlock(
8254                        data: &[u8],
8255                        validate: bool,
8256                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8257                        <initializedAtBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
8258                            data, validate,
8259                        )
8260                        .map(StakeTableCalls::initializedAtBlock)
8261                    }
8262                    initializedAtBlock
8263                },
8264                {
8265                    fn undelegate(
8266                        data: &[u8],
8267                        validate: bool,
8268                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8269                        <undelegateCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
8270                            .map(StakeTableCalls::undelegate)
8271                    }
8272                    undelegate
8273                },
8274                {
8275                    fn upgradeToAndCall(
8276                        data: &[u8],
8277                        validate: bool,
8278                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8279                        <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(
8280                            data, validate,
8281                        )
8282                        .map(StakeTableCalls::upgradeToAndCall)
8283                    }
8284                    upgradeToAndCall
8285                },
8286                {
8287                    fn proxiableUUID(
8288                        data: &[u8],
8289                        validate: bool,
8290                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8291                        <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
8292                            data, validate,
8293                        )
8294                        .map(StakeTableCalls::proxiableUUID)
8295                    }
8296                    proxiableUUID
8297                },
8298                {
8299                    fn updateConsensusKeys(
8300                        data: &[u8],
8301                        validate: bool,
8302                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8303                        <updateConsensusKeysCall as alloy_sol_types::SolCall>::abi_decode_raw(
8304                            data, validate,
8305                        )
8306                        .map(StakeTableCalls::updateConsensusKeys)
8307                    }
8308                    updateConsensusKeys
8309                },
8310                {
8311                    fn deregisterValidator(
8312                        data: &[u8],
8313                        validate: bool,
8314                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8315                        <deregisterValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
8316                            data, validate,
8317                        )
8318                        .map(StakeTableCalls::deregisterValidator)
8319                    }
8320                    deregisterValidator
8321                },
8322                {
8323                    fn renounceOwnership(
8324                        data: &[u8],
8325                        validate: bool,
8326                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8327                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
8328                            data, validate,
8329                        )
8330                        .map(StakeTableCalls::renounceOwnership)
8331                    }
8332                    renounceOwnership
8333                },
8334                {
8335                    fn owner(
8336                        data: &[u8],
8337                        validate: bool,
8338                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8339                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
8340                            .map(StakeTableCalls::owner)
8341                    }
8342                    owner
8343                },
8344                {
8345                    fn _hashBlsKey(
8346                        data: &[u8],
8347                        validate: bool,
8348                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8349                        <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_decode_raw(
8350                            data, validate,
8351                        )
8352                        .map(StakeTableCalls::_hashBlsKey)
8353                    }
8354                    _hashBlsKey
8355                },
8356                {
8357                    fn exitEscrowPeriod(
8358                        data: &[u8],
8359                        validate: bool,
8360                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8361                        <exitEscrowPeriodCall as alloy_sol_types::SolCall>::abi_decode_raw(
8362                            data, validate,
8363                        )
8364                        .map(StakeTableCalls::exitEscrowPeriod)
8365                    }
8366                    exitEscrowPeriod
8367                },
8368                {
8369                    fn undelegations(
8370                        data: &[u8],
8371                        validate: bool,
8372                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8373                        <undelegationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
8374                            data, validate,
8375                        )
8376                        .map(StakeTableCalls::undelegations)
8377                    }
8378                    undelegations
8379                },
8380                {
8381                    fn claimWithdrawal(
8382                        data: &[u8],
8383                        validate: bool,
8384                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8385                        <claimWithdrawalCall as alloy_sol_types::SolCall>::abi_decode_raw(
8386                            data, validate,
8387                        )
8388                        .map(StakeTableCalls::claimWithdrawal)
8389                    }
8390                    claimWithdrawal
8391                },
8392                {
8393                    fn UPGRADE_INTERFACE_VERSION(
8394                        data: &[u8],
8395                        validate: bool,
8396                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8397                        <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(
8398                            data, validate,
8399                        )
8400                        .map(StakeTableCalls::UPGRADE_INTERFACE_VERSION)
8401                    }
8402                    UPGRADE_INTERFACE_VERSION
8403                },
8404                {
8405                    fn blsKeys(
8406                        data: &[u8],
8407                        validate: bool,
8408                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8409                        <blsKeysCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
8410                            .map(StakeTableCalls::blsKeys)
8411                    }
8412                    blsKeys
8413                },
8414                {
8415                    fn lightClient(
8416                        data: &[u8],
8417                        validate: bool,
8418                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8419                        <lightClientCall as alloy_sol_types::SolCall>::abi_decode_raw(
8420                            data, validate,
8421                        )
8422                        .map(StakeTableCalls::lightClient)
8423                    }
8424                    lightClient
8425                },
8426                {
8427                    fn validatorExits(
8428                        data: &[u8],
8429                        validate: bool,
8430                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8431                        <validatorExitsCall as alloy_sol_types::SolCall>::abi_decode_raw(
8432                            data, validate,
8433                        )
8434                        .map(StakeTableCalls::validatorExits)
8435                    }
8436                    validatorExits
8437                },
8438                {
8439                    fn initialize(
8440                        data: &[u8],
8441                        validate: bool,
8442                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8443                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
8444                            .map(StakeTableCalls::initialize)
8445                    }
8446                    initialize
8447                },
8448                {
8449                    fn delegations(
8450                        data: &[u8],
8451                        validate: bool,
8452                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8453                        <delegationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
8454                            data, validate,
8455                        )
8456                        .map(StakeTableCalls::delegations)
8457                    }
8458                    delegations
8459                },
8460                {
8461                    fn transferOwnership(
8462                        data: &[u8],
8463                        validate: bool,
8464                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8465                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
8466                            data, validate,
8467                        )
8468                        .map(StakeTableCalls::transferOwnership)
8469                    }
8470                    transferOwnership
8471                },
8472                {
8473                    fn validators(
8474                        data: &[u8],
8475                        validate: bool,
8476                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8477                        <validatorsCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
8478                            .map(StakeTableCalls::validators)
8479                    }
8480                    validators
8481                },
8482                {
8483                    fn token(
8484                        data: &[u8],
8485                        validate: bool,
8486                    ) -> alloy_sol_types::Result<StakeTableCalls> {
8487                        <tokenCall as alloy_sol_types::SolCall>::abi_decode_raw(data, validate)
8488                            .map(StakeTableCalls::token)
8489                    }
8490                    token
8491                },
8492            ];
8493            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
8494                return Err(alloy_sol_types::Error::unknown_selector(
8495                    <Self as alloy_sol_types::SolInterface>::NAME,
8496                    selector,
8497                ));
8498            };
8499            DECODE_SHIMS[idx](data, validate)
8500        }
8501        #[inline]
8502        fn abi_encoded_size(&self) -> usize {
8503            match self {
8504                Self::UPGRADE_INTERFACE_VERSION(inner) => {
8505                    <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
8506                        inner,
8507                    )
8508                },
8509                Self::_hashBlsKey(inner) => {
8510                    <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8511                },
8512                Self::blsKeys(inner) => {
8513                    <blsKeysCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8514                },
8515                Self::claimValidatorExit(inner) => {
8516                    <claimValidatorExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8517                },
8518                Self::claimWithdrawal(inner) => {
8519                    <claimWithdrawalCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8520                },
8521                Self::delegate(inner) => {
8522                    <delegateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8523                },
8524                Self::delegations(inner) => {
8525                    <delegationsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8526                },
8527                Self::deregisterValidator(inner) => {
8528                    <deregisterValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8529                },
8530                Self::exitEscrowPeriod(inner) => {
8531                    <exitEscrowPeriodCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8532                },
8533                Self::getVersion(inner) => {
8534                    <getVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8535                },
8536                Self::initialize(inner) => {
8537                    <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8538                },
8539                Self::initializedAtBlock(inner) => {
8540                    <initializedAtBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8541                },
8542                Self::lightClient(inner) => {
8543                    <lightClientCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8544                },
8545                Self::owner(inner) => {
8546                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8547                },
8548                Self::proxiableUUID(inner) => {
8549                    <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8550                },
8551                Self::registerValidator(inner) => {
8552                    <registerValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8553                },
8554                Self::renounceOwnership(inner) => {
8555                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8556                },
8557                Self::token(inner) => {
8558                    <tokenCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8559                },
8560                Self::transferOwnership(inner) => {
8561                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8562                },
8563                Self::undelegate(inner) => {
8564                    <undelegateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8565                },
8566                Self::undelegations(inner) => {
8567                    <undelegationsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8568                },
8569                Self::updateConsensusKeys(inner) => {
8570                    <updateConsensusKeysCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8571                },
8572                Self::upgradeToAndCall(inner) => {
8573                    <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8574                },
8575                Self::validatorExits(inner) => {
8576                    <validatorExitsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8577                },
8578                Self::validators(inner) => {
8579                    <validatorsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8580                },
8581            }
8582        }
8583        #[inline]
8584        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
8585            match self {
8586                Self::UPGRADE_INTERFACE_VERSION(inner) => {
8587                    <UPGRADE_INTERFACE_VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
8588                        inner, out,
8589                    )
8590                },
8591                Self::_hashBlsKey(inner) => {
8592                    <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8593                },
8594                Self::blsKeys(inner) => {
8595                    <blsKeysCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8596                },
8597                Self::claimValidatorExit(inner) => {
8598                    <claimValidatorExitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8599                },
8600                Self::claimWithdrawal(inner) => {
8601                    <claimWithdrawalCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8602                },
8603                Self::delegate(inner) => {
8604                    <delegateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8605                },
8606                Self::delegations(inner) => {
8607                    <delegationsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8608                },
8609                Self::deregisterValidator(inner) => {
8610                    <deregisterValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
8611                        inner, out,
8612                    )
8613                },
8614                Self::exitEscrowPeriod(inner) => {
8615                    <exitEscrowPeriodCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8616                },
8617                Self::getVersion(inner) => {
8618                    <getVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8619                },
8620                Self::initialize(inner) => {
8621                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8622                },
8623                Self::initializedAtBlock(inner) => {
8624                    <initializedAtBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8625                },
8626                Self::lightClient(inner) => {
8627                    <lightClientCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8628                },
8629                Self::owner(inner) => {
8630                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8631                },
8632                Self::proxiableUUID(inner) => {
8633                    <proxiableUUIDCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8634                },
8635                Self::registerValidator(inner) => {
8636                    <registerValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8637                },
8638                Self::renounceOwnership(inner) => {
8639                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8640                },
8641                Self::token(inner) => {
8642                    <tokenCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8643                },
8644                Self::transferOwnership(inner) => {
8645                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8646                },
8647                Self::undelegate(inner) => {
8648                    <undelegateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8649                },
8650                Self::undelegations(inner) => {
8651                    <undelegationsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8652                },
8653                Self::updateConsensusKeys(inner) => {
8654                    <updateConsensusKeysCall as alloy_sol_types::SolCall>::abi_encode_raw(
8655                        inner, out,
8656                    )
8657                },
8658                Self::upgradeToAndCall(inner) => {
8659                    <upgradeToAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8660                },
8661                Self::validatorExits(inner) => {
8662                    <validatorExitsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8663                },
8664                Self::validators(inner) => {
8665                    <validatorsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8666                },
8667            }
8668        }
8669    }
8670    ///Container for all the [`StakeTable`](self) custom errors.
8671    #[derive(Debug, PartialEq, Eq, Hash)]
8672    pub enum StakeTableErrors {
8673        #[allow(missing_docs)]
8674        AddressEmptyCode(AddressEmptyCode),
8675        #[allow(missing_docs)]
8676        BLSSigVerificationFailed(BLSSigVerificationFailed),
8677        #[allow(missing_docs)]
8678        BlsKeyAlreadyUsed(BlsKeyAlreadyUsed),
8679        #[allow(missing_docs)]
8680        ERC1967InvalidImplementation(ERC1967InvalidImplementation),
8681        #[allow(missing_docs)]
8682        ERC1967NonPayable(ERC1967NonPayable),
8683        #[allow(missing_docs)]
8684        FailedInnerCall(FailedInnerCall),
8685        #[allow(missing_docs)]
8686        InsufficientAllowance(InsufficientAllowance),
8687        #[allow(missing_docs)]
8688        InsufficientBalance(InsufficientBalance),
8689        #[allow(missing_docs)]
8690        InvalidCommission(InvalidCommission),
8691        #[allow(missing_docs)]
8692        InvalidInitialization(InvalidInitialization),
8693        #[allow(missing_docs)]
8694        InvalidSchnorrVK(InvalidSchnorrVK),
8695        #[allow(missing_docs)]
8696        NotInitializing(NotInitializing),
8697        #[allow(missing_docs)]
8698        NothingToWithdraw(NothingToWithdraw),
8699        #[allow(missing_docs)]
8700        OwnableInvalidOwner(OwnableInvalidOwner),
8701        #[allow(missing_docs)]
8702        OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
8703        #[allow(missing_docs)]
8704        PrematureWithdrawal(PrematureWithdrawal),
8705        #[allow(missing_docs)]
8706        UUPSUnauthorizedCallContext(UUPSUnauthorizedCallContext),
8707        #[allow(missing_docs)]
8708        UUPSUnsupportedProxiableUUID(UUPSUnsupportedProxiableUUID),
8709        #[allow(missing_docs)]
8710        UndelegationAlreadyExists(UndelegationAlreadyExists),
8711        #[allow(missing_docs)]
8712        ValidatorAlreadyExited(ValidatorAlreadyExited),
8713        #[allow(missing_docs)]
8714        ValidatorAlreadyRegistered(ValidatorAlreadyRegistered),
8715        #[allow(missing_docs)]
8716        ValidatorInactive(ValidatorInactive),
8717        #[allow(missing_docs)]
8718        ValidatorNotExited(ValidatorNotExited),
8719        #[allow(missing_docs)]
8720        ZeroAddress(ZeroAddress),
8721        #[allow(missing_docs)]
8722        ZeroAmount(ZeroAmount),
8723    }
8724    #[automatically_derived]
8725    impl StakeTableErrors {
8726        /// All the selectors of this enum.
8727        ///
8728        /// Note that the selectors might not be in the same order as the variants.
8729        /// No guarantees are made about the order of the selectors.
8730        ///
8731        /// Prefer using `SolInterface` methods instead.
8732        pub const SELECTORS: &'static [[u8; 4usize]] = &[
8733            [1u8, 181u8, 20u8, 174u8],
8734            [6u8, 207u8, 67u8, 143u8],
8735            [12u8, 237u8, 62u8, 80u8],
8736            [17u8, 140u8, 218u8, 167u8],
8737            [20u8, 37u8, 234u8, 66u8],
8738            [30u8, 79u8, 189u8, 247u8],
8739            [31u8, 42u8, 32u8, 5u8],
8740            [42u8, 27u8, 45u8, 216u8],
8741            [76u8, 156u8, 140u8, 227u8],
8742            [80u8, 138u8, 121u8, 63u8],
8743            [90u8, 119u8, 67u8, 87u8],
8744            [146u8, 102u8, 83u8, 81u8],
8745            [153u8, 115u8, 247u8, 216u8],
8746            [153u8, 150u8, 179u8, 21u8],
8747            [170u8, 29u8, 73u8, 164u8],
8748            [179u8, 152u8, 151u8, 159u8],
8749            [208u8, 208u8, 79u8, 96u8],
8750            [212u8, 35u8, 164u8, 241u8],
8751            [215u8, 230u8, 188u8, 248u8],
8752            [217u8, 46u8, 35u8, 61u8],
8753            [220u8, 129u8, 219u8, 133u8],
8754            [224u8, 124u8, 141u8, 186u8],
8755            [234u8, 180u8, 169u8, 99u8],
8756            [242u8, 83u8, 20u8, 166u8],
8757            [249u8, 46u8, 232u8, 169u8],
8758        ];
8759    }
8760    #[automatically_derived]
8761    impl alloy_sol_types::SolInterface for StakeTableErrors {
8762        const NAME: &'static str = "StakeTableErrors";
8763        const MIN_DATA_LENGTH: usize = 0usize;
8764        const COUNT: usize = 25usize;
8765        #[inline]
8766        fn selector(&self) -> [u8; 4] {
8767            match self {
8768                Self::AddressEmptyCode(_) => {
8769                    <AddressEmptyCode as alloy_sol_types::SolError>::SELECTOR
8770                },
8771                Self::BLSSigVerificationFailed(_) => {
8772                    <BLSSigVerificationFailed as alloy_sol_types::SolError>::SELECTOR
8773                },
8774                Self::BlsKeyAlreadyUsed(_) => {
8775                    <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::SELECTOR
8776                },
8777                Self::ERC1967InvalidImplementation(_) => {
8778                    <ERC1967InvalidImplementation as alloy_sol_types::SolError>::SELECTOR
8779                },
8780                Self::ERC1967NonPayable(_) => {
8781                    <ERC1967NonPayable as alloy_sol_types::SolError>::SELECTOR
8782                },
8783                Self::FailedInnerCall(_) => {
8784                    <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
8785                },
8786                Self::InsufficientAllowance(_) => {
8787                    <InsufficientAllowance as alloy_sol_types::SolError>::SELECTOR
8788                },
8789                Self::InsufficientBalance(_) => {
8790                    <InsufficientBalance as alloy_sol_types::SolError>::SELECTOR
8791                },
8792                Self::InvalidCommission(_) => {
8793                    <InvalidCommission as alloy_sol_types::SolError>::SELECTOR
8794                },
8795                Self::InvalidInitialization(_) => {
8796                    <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
8797                },
8798                Self::InvalidSchnorrVK(_) => {
8799                    <InvalidSchnorrVK as alloy_sol_types::SolError>::SELECTOR
8800                },
8801                Self::NotInitializing(_) => {
8802                    <NotInitializing as alloy_sol_types::SolError>::SELECTOR
8803                },
8804                Self::NothingToWithdraw(_) => {
8805                    <NothingToWithdraw as alloy_sol_types::SolError>::SELECTOR
8806                },
8807                Self::OwnableInvalidOwner(_) => {
8808                    <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
8809                },
8810                Self::OwnableUnauthorizedAccount(_) => {
8811                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
8812                },
8813                Self::PrematureWithdrawal(_) => {
8814                    <PrematureWithdrawal as alloy_sol_types::SolError>::SELECTOR
8815                },
8816                Self::UUPSUnauthorizedCallContext(_) => {
8817                    <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::SELECTOR
8818                },
8819                Self::UUPSUnsupportedProxiableUUID(_) => {
8820                    <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::SELECTOR
8821                },
8822                Self::UndelegationAlreadyExists(_) => {
8823                    <UndelegationAlreadyExists as alloy_sol_types::SolError>::SELECTOR
8824                },
8825                Self::ValidatorAlreadyExited(_) => {
8826                    <ValidatorAlreadyExited as alloy_sol_types::SolError>::SELECTOR
8827                },
8828                Self::ValidatorAlreadyRegistered(_) => {
8829                    <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::SELECTOR
8830                },
8831                Self::ValidatorInactive(_) => {
8832                    <ValidatorInactive as alloy_sol_types::SolError>::SELECTOR
8833                },
8834                Self::ValidatorNotExited(_) => {
8835                    <ValidatorNotExited as alloy_sol_types::SolError>::SELECTOR
8836                },
8837                Self::ZeroAddress(_) => <ZeroAddress as alloy_sol_types::SolError>::SELECTOR,
8838                Self::ZeroAmount(_) => <ZeroAmount as alloy_sol_types::SolError>::SELECTOR,
8839            }
8840        }
8841        #[inline]
8842        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
8843            Self::SELECTORS.get(i).copied()
8844        }
8845        #[inline]
8846        fn valid_selector(selector: [u8; 4]) -> bool {
8847            Self::SELECTORS.binary_search(&selector).is_ok()
8848        }
8849        #[inline]
8850        #[allow(non_snake_case)]
8851        fn abi_decode_raw(
8852            selector: [u8; 4],
8853            data: &[u8],
8854            validate: bool,
8855        ) -> alloy_sol_types::Result<Self> {
8856            static DECODE_SHIMS: &[fn(&[u8], bool) -> alloy_sol_types::Result<StakeTableErrors>] =
8857                &[
8858                    {
8859                        fn BlsKeyAlreadyUsed(
8860                            data: &[u8],
8861                            validate: bool,
8862                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8863                            <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::abi_decode_raw(
8864                                data, validate,
8865                            )
8866                            .map(StakeTableErrors::BlsKeyAlreadyUsed)
8867                        }
8868                        BlsKeyAlreadyUsed
8869                    },
8870                    {
8871                        fn InvalidSchnorrVK(
8872                            data: &[u8],
8873                            validate: bool,
8874                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8875                            <InvalidSchnorrVK as alloy_sol_types::SolError>::abi_decode_raw(
8876                                data, validate,
8877                            )
8878                            .map(StakeTableErrors::InvalidSchnorrVK)
8879                        }
8880                        InvalidSchnorrVK
8881                    },
8882                    {
8883                        fn BLSSigVerificationFailed(
8884                            data: &[u8],
8885                            validate: bool,
8886                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8887                            <BLSSigVerificationFailed as alloy_sol_types::SolError>::abi_decode_raw(
8888                                data, validate,
8889                            )
8890                            .map(StakeTableErrors::BLSSigVerificationFailed)
8891                        }
8892                        BLSSigVerificationFailed
8893                    },
8894                    {
8895                        fn OwnableUnauthorizedAccount(
8896                            data: &[u8],
8897                            validate: bool,
8898                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8899                            <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
8900                                data,
8901                                validate,
8902                            )
8903                            .map(StakeTableErrors::OwnableUnauthorizedAccount)
8904                        }
8905                        OwnableUnauthorizedAccount
8906                    },
8907                    {
8908                        fn FailedInnerCall(
8909                            data: &[u8],
8910                            validate: bool,
8911                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8912                            <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(
8913                                data, validate,
8914                            )
8915                            .map(StakeTableErrors::FailedInnerCall)
8916                        }
8917                        FailedInnerCall
8918                    },
8919                    {
8920                        fn OwnableInvalidOwner(
8921                            data: &[u8],
8922                            validate: bool,
8923                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8924                            <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
8925                                data, validate,
8926                            )
8927                            .map(StakeTableErrors::OwnableInvalidOwner)
8928                        }
8929                        OwnableInvalidOwner
8930                    },
8931                    {
8932                        fn ZeroAmount(
8933                            data: &[u8],
8934                            validate: bool,
8935                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8936                            <ZeroAmount as alloy_sol_types::SolError>::abi_decode_raw(
8937                                data, validate,
8938                            )
8939                            .map(StakeTableErrors::ZeroAmount)
8940                        }
8941                        ZeroAmount
8942                    },
8943                    {
8944                        fn InsufficientAllowance(
8945                            data: &[u8],
8946                            validate: bool,
8947                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8948                            <InsufficientAllowance as alloy_sol_types::SolError>::abi_decode_raw(
8949                                data, validate,
8950                            )
8951                            .map(StakeTableErrors::InsufficientAllowance)
8952                        }
8953                        InsufficientAllowance
8954                    },
8955                    {
8956                        fn ERC1967InvalidImplementation(
8957                            data: &[u8],
8958                            validate: bool,
8959                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8960                            <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_decode_raw(
8961                                data,
8962                                validate,
8963                            )
8964                            .map(StakeTableErrors::ERC1967InvalidImplementation)
8965                        }
8966                        ERC1967InvalidImplementation
8967                    },
8968                    {
8969                        fn ValidatorInactive(
8970                            data: &[u8],
8971                            validate: bool,
8972                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8973                            <ValidatorInactive as alloy_sol_types::SolError>::abi_decode_raw(
8974                                data, validate,
8975                            )
8976                            .map(StakeTableErrors::ValidatorInactive)
8977                        }
8978                        ValidatorInactive
8979                    },
8980                    {
8981                        fn PrematureWithdrawal(
8982                            data: &[u8],
8983                            validate: bool,
8984                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8985                            <PrematureWithdrawal as alloy_sol_types::SolError>::abi_decode_raw(
8986                                data, validate,
8987                            )
8988                            .map(StakeTableErrors::PrematureWithdrawal)
8989                        }
8990                        PrematureWithdrawal
8991                    },
8992                    {
8993                        fn InsufficientBalance(
8994                            data: &[u8],
8995                            validate: bool,
8996                        ) -> alloy_sol_types::Result<StakeTableErrors> {
8997                            <InsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw(
8998                                data, validate,
8999                            )
9000                            .map(StakeTableErrors::InsufficientBalance)
9001                        }
9002                        InsufficientBalance
9003                    },
9004                    {
9005                        fn ValidatorAlreadyRegistered(
9006                            data: &[u8],
9007                            validate: bool,
9008                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9009                            <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::abi_decode_raw(
9010                                data,
9011                                validate,
9012                            )
9013                            .map(StakeTableErrors::ValidatorAlreadyRegistered)
9014                        }
9015                        ValidatorAlreadyRegistered
9016                    },
9017                    {
9018                        fn AddressEmptyCode(
9019                            data: &[u8],
9020                            validate: bool,
9021                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9022                            <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw(
9023                                data, validate,
9024                            )
9025                            .map(StakeTableErrors::AddressEmptyCode)
9026                        }
9027                        AddressEmptyCode
9028                    },
9029                    {
9030                        fn UUPSUnsupportedProxiableUUID(
9031                            data: &[u8],
9032                            validate: bool,
9033                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9034                            <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_decode_raw(
9035                                data,
9036                                validate,
9037                            )
9038                            .map(StakeTableErrors::UUPSUnsupportedProxiableUUID)
9039                        }
9040                        UUPSUnsupportedProxiableUUID
9041                    },
9042                    {
9043                        fn ERC1967NonPayable(
9044                            data: &[u8],
9045                            validate: bool,
9046                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9047                            <ERC1967NonPayable as alloy_sol_types::SolError>::abi_decode_raw(
9048                                data, validate,
9049                            )
9050                            .map(StakeTableErrors::ERC1967NonPayable)
9051                        }
9052                        ERC1967NonPayable
9053                    },
9054                    {
9055                        fn NothingToWithdraw(
9056                            data: &[u8],
9057                            validate: bool,
9058                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9059                            <NothingToWithdraw as alloy_sol_types::SolError>::abi_decode_raw(
9060                                data, validate,
9061                            )
9062                            .map(StakeTableErrors::NothingToWithdraw)
9063                        }
9064                        NothingToWithdraw
9065                    },
9066                    {
9067                        fn UndelegationAlreadyExists(
9068                            data: &[u8],
9069                            validate: bool,
9070                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9071                            <UndelegationAlreadyExists as alloy_sol_types::SolError>::abi_decode_raw(
9072                                data,
9073                                validate,
9074                            )
9075                            .map(StakeTableErrors::UndelegationAlreadyExists)
9076                        }
9077                        UndelegationAlreadyExists
9078                    },
9079                    {
9080                        fn NotInitializing(
9081                            data: &[u8],
9082                            validate: bool,
9083                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9084                            <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw(
9085                                data, validate,
9086                            )
9087                            .map(StakeTableErrors::NotInitializing)
9088                        }
9089                        NotInitializing
9090                    },
9091                    {
9092                        fn ZeroAddress(
9093                            data: &[u8],
9094                            validate: bool,
9095                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9096                            <ZeroAddress as alloy_sol_types::SolError>::abi_decode_raw(
9097                                data, validate,
9098                            )
9099                            .map(StakeTableErrors::ZeroAddress)
9100                        }
9101                        ZeroAddress
9102                    },
9103                    {
9104                        fn InvalidCommission(
9105                            data: &[u8],
9106                            validate: bool,
9107                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9108                            <InvalidCommission as alloy_sol_types::SolError>::abi_decode_raw(
9109                                data, validate,
9110                            )
9111                            .map(StakeTableErrors::InvalidCommission)
9112                        }
9113                        InvalidCommission
9114                    },
9115                    {
9116                        fn UUPSUnauthorizedCallContext(
9117                            data: &[u8],
9118                            validate: bool,
9119                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9120                            <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_decode_raw(
9121                                data,
9122                                validate,
9123                            )
9124                            .map(StakeTableErrors::UUPSUnauthorizedCallContext)
9125                        }
9126                        UUPSUnauthorizedCallContext
9127                    },
9128                    {
9129                        fn ValidatorAlreadyExited(
9130                            data: &[u8],
9131                            validate: bool,
9132                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9133                            <ValidatorAlreadyExited as alloy_sol_types::SolError>::abi_decode_raw(
9134                                data, validate,
9135                            )
9136                            .map(StakeTableErrors::ValidatorAlreadyExited)
9137                        }
9138                        ValidatorAlreadyExited
9139                    },
9140                    {
9141                        fn ValidatorNotExited(
9142                            data: &[u8],
9143                            validate: bool,
9144                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9145                            <ValidatorNotExited as alloy_sol_types::SolError>::abi_decode_raw(
9146                                data, validate,
9147                            )
9148                            .map(StakeTableErrors::ValidatorNotExited)
9149                        }
9150                        ValidatorNotExited
9151                    },
9152                    {
9153                        fn InvalidInitialization(
9154                            data: &[u8],
9155                            validate: bool,
9156                        ) -> alloy_sol_types::Result<StakeTableErrors> {
9157                            <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw(
9158                                data, validate,
9159                            )
9160                            .map(StakeTableErrors::InvalidInitialization)
9161                        }
9162                        InvalidInitialization
9163                    },
9164                ];
9165            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
9166                return Err(alloy_sol_types::Error::unknown_selector(
9167                    <Self as alloy_sol_types::SolInterface>::NAME,
9168                    selector,
9169                ));
9170            };
9171            DECODE_SHIMS[idx](data, validate)
9172        }
9173        #[inline]
9174        fn abi_encoded_size(&self) -> usize {
9175            match self {
9176                Self::AddressEmptyCode(inner) => {
9177                    <AddressEmptyCode as alloy_sol_types::SolError>::abi_encoded_size(inner)
9178                },
9179                Self::BLSSigVerificationFailed(inner) => {
9180                    <BLSSigVerificationFailed as alloy_sol_types::SolError>::abi_encoded_size(inner)
9181                },
9182                Self::BlsKeyAlreadyUsed(inner) => {
9183                    <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::abi_encoded_size(inner)
9184                },
9185                Self::ERC1967InvalidImplementation(inner) => {
9186                    <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encoded_size(
9187                        inner,
9188                    )
9189                },
9190                Self::ERC1967NonPayable(inner) => {
9191                    <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encoded_size(inner)
9192                },
9193                Self::FailedInnerCall(inner) => {
9194                    <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(inner)
9195                },
9196                Self::InsufficientAllowance(inner) => {
9197                    <InsufficientAllowance as alloy_sol_types::SolError>::abi_encoded_size(inner)
9198                },
9199                Self::InsufficientBalance(inner) => {
9200                    <InsufficientBalance as alloy_sol_types::SolError>::abi_encoded_size(inner)
9201                },
9202                Self::InvalidCommission(inner) => {
9203                    <InvalidCommission as alloy_sol_types::SolError>::abi_encoded_size(inner)
9204                },
9205                Self::InvalidInitialization(inner) => {
9206                    <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(inner)
9207                },
9208                Self::InvalidSchnorrVK(inner) => {
9209                    <InvalidSchnorrVK as alloy_sol_types::SolError>::abi_encoded_size(inner)
9210                },
9211                Self::NotInitializing(inner) => {
9212                    <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(inner)
9213                },
9214                Self::NothingToWithdraw(inner) => {
9215                    <NothingToWithdraw as alloy_sol_types::SolError>::abi_encoded_size(inner)
9216                },
9217                Self::OwnableInvalidOwner(inner) => {
9218                    <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(inner)
9219                },
9220                Self::OwnableUnauthorizedAccount(inner) => {
9221                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
9222                        inner,
9223                    )
9224                },
9225                Self::PrematureWithdrawal(inner) => {
9226                    <PrematureWithdrawal as alloy_sol_types::SolError>::abi_encoded_size(inner)
9227                },
9228                Self::UUPSUnauthorizedCallContext(inner) => {
9229                    <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encoded_size(
9230                        inner,
9231                    )
9232                },
9233                Self::UUPSUnsupportedProxiableUUID(inner) => {
9234                    <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encoded_size(
9235                        inner,
9236                    )
9237                },
9238                Self::UndelegationAlreadyExists(inner) => {
9239                    <UndelegationAlreadyExists as alloy_sol_types::SolError>::abi_encoded_size(
9240                        inner,
9241                    )
9242                },
9243                Self::ValidatorAlreadyExited(inner) => {
9244                    <ValidatorAlreadyExited as alloy_sol_types::SolError>::abi_encoded_size(inner)
9245                },
9246                Self::ValidatorAlreadyRegistered(inner) => {
9247                    <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::abi_encoded_size(
9248                        inner,
9249                    )
9250                },
9251                Self::ValidatorInactive(inner) => {
9252                    <ValidatorInactive as alloy_sol_types::SolError>::abi_encoded_size(inner)
9253                },
9254                Self::ValidatorNotExited(inner) => {
9255                    <ValidatorNotExited as alloy_sol_types::SolError>::abi_encoded_size(inner)
9256                },
9257                Self::ZeroAddress(inner) => {
9258                    <ZeroAddress as alloy_sol_types::SolError>::abi_encoded_size(inner)
9259                },
9260                Self::ZeroAmount(inner) => {
9261                    <ZeroAmount as alloy_sol_types::SolError>::abi_encoded_size(inner)
9262                },
9263            }
9264        }
9265        #[inline]
9266        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
9267            match self {
9268                Self::AddressEmptyCode(inner) => {
9269                    <AddressEmptyCode as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9270                },
9271                Self::BLSSigVerificationFailed(inner) => {
9272                    <BLSSigVerificationFailed as alloy_sol_types::SolError>::abi_encode_raw(
9273                        inner, out,
9274                    )
9275                },
9276                Self::BlsKeyAlreadyUsed(inner) => {
9277                    <BlsKeyAlreadyUsed as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9278                },
9279                Self::ERC1967InvalidImplementation(inner) => {
9280                    <ERC1967InvalidImplementation as alloy_sol_types::SolError>::abi_encode_raw(
9281                        inner, out,
9282                    )
9283                },
9284                Self::ERC1967NonPayable(inner) => {
9285                    <ERC1967NonPayable as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9286                },
9287                Self::FailedInnerCall(inner) => {
9288                    <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9289                },
9290                Self::InsufficientAllowance(inner) => {
9291                    <InsufficientAllowance as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9292                },
9293                Self::InsufficientBalance(inner) => {
9294                    <InsufficientBalance as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9295                },
9296                Self::InvalidCommission(inner) => {
9297                    <InvalidCommission as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9298                },
9299                Self::InvalidInitialization(inner) => {
9300                    <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9301                },
9302                Self::InvalidSchnorrVK(inner) => {
9303                    <InvalidSchnorrVK as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9304                },
9305                Self::NotInitializing(inner) => {
9306                    <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9307                },
9308                Self::NothingToWithdraw(inner) => {
9309                    <NothingToWithdraw as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9310                },
9311                Self::OwnableInvalidOwner(inner) => {
9312                    <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9313                },
9314                Self::OwnableUnauthorizedAccount(inner) => {
9315                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
9316                        inner, out,
9317                    )
9318                },
9319                Self::PrematureWithdrawal(inner) => {
9320                    <PrematureWithdrawal as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9321                },
9322                Self::UUPSUnauthorizedCallContext(inner) => {
9323                    <UUPSUnauthorizedCallContext as alloy_sol_types::SolError>::abi_encode_raw(
9324                        inner, out,
9325                    )
9326                },
9327                Self::UUPSUnsupportedProxiableUUID(inner) => {
9328                    <UUPSUnsupportedProxiableUUID as alloy_sol_types::SolError>::abi_encode_raw(
9329                        inner, out,
9330                    )
9331                },
9332                Self::UndelegationAlreadyExists(inner) => {
9333                    <UndelegationAlreadyExists as alloy_sol_types::SolError>::abi_encode_raw(
9334                        inner, out,
9335                    )
9336                },
9337                Self::ValidatorAlreadyExited(inner) => {
9338                    <ValidatorAlreadyExited as alloy_sol_types::SolError>::abi_encode_raw(
9339                        inner, out,
9340                    )
9341                },
9342                Self::ValidatorAlreadyRegistered(inner) => {
9343                    <ValidatorAlreadyRegistered as alloy_sol_types::SolError>::abi_encode_raw(
9344                        inner, out,
9345                    )
9346                },
9347                Self::ValidatorInactive(inner) => {
9348                    <ValidatorInactive as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9349                },
9350                Self::ValidatorNotExited(inner) => {
9351                    <ValidatorNotExited as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9352                },
9353                Self::ZeroAddress(inner) => {
9354                    <ZeroAddress as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9355                },
9356                Self::ZeroAmount(inner) => {
9357                    <ZeroAmount as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
9358                },
9359            }
9360        }
9361    }
9362    ///Container for all the [`StakeTable`](self) events.
9363    #[derive()]
9364    pub enum StakeTableEvents {
9365        #[allow(missing_docs)]
9366        ConsensusKeysUpdated(ConsensusKeysUpdated),
9367        #[allow(missing_docs)]
9368        Delegated(Delegated),
9369        #[allow(missing_docs)]
9370        Initialized(Initialized),
9371        #[allow(missing_docs)]
9372        OwnershipTransferred(OwnershipTransferred),
9373        #[allow(missing_docs)]
9374        Undelegated(Undelegated),
9375        #[allow(missing_docs)]
9376        Upgrade(Upgrade),
9377        #[allow(missing_docs)]
9378        Upgraded(Upgraded),
9379        #[allow(missing_docs)]
9380        ValidatorExit(ValidatorExit),
9381        #[allow(missing_docs)]
9382        ValidatorRegistered(ValidatorRegistered),
9383        #[allow(missing_docs)]
9384        Withdrawal(Withdrawal),
9385    }
9386    #[automatically_derived]
9387    impl StakeTableEvents {
9388        /// All the selectors of this enum.
9389        ///
9390        /// Note that the selectors might not be in the same order as the variants.
9391        /// No guarantees are made about the order of the selectors.
9392        ///
9393        /// Prefer using `SolInterface` methods instead.
9394        pub const SELECTORS: &'static [[u8; 32usize]] = &[
9395            [
9396                77u8, 16u8, 189u8, 4u8, 151u8, 117u8, 199u8, 123u8, 215u8, 242u8, 85u8, 25u8, 90u8,
9397                251u8, 165u8, 8u8, 128u8, 40u8, 236u8, 179u8, 199u8, 194u8, 119u8, 211u8, 147u8,
9398                204u8, 255u8, 121u8, 52u8, 242u8, 249u8, 44u8,
9399            ],
9400            [
9401                127u8, 207u8, 83u8, 44u8, 21u8, 240u8, 166u8, 219u8, 11u8, 214u8, 208u8, 224u8,
9402                56u8, 190u8, 167u8, 29u8, 48u8, 216u8, 8u8, 199u8, 217u8, 140u8, 179u8, 191u8,
9403                114u8, 104u8, 169u8, 91u8, 245u8, 8u8, 27u8, 101u8,
9404            ],
9405            [
9406                128u8, 216u8, 164u8, 161u8, 102u8, 51u8, 40u8, 169u8, 152u8, 212u8, 85u8, 91u8,
9407                162u8, 29u8, 139u8, 186u8, 110u8, 241u8, 87u8, 106u8, 140u8, 94u8, 157u8, 39u8,
9408                249u8, 197u8, 69u8, 241u8, 163u8, 213u8, 43u8, 29u8,
9409            ],
9410            [
9411                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8,
9412                164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8,
9413                180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
9414            ],
9415            [
9416                188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, 179u8,
9417                32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, 192u8, 34u8,
9418                91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8,
9419            ],
9420            [
9421                199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8,
9422                244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8,
9423                209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
9424            ],
9425            [
9426                229u8, 84u8, 26u8, 107u8, 97u8, 3u8, 212u8, 250u8, 126u8, 2u8, 30u8, 213u8, 79u8,
9427                173u8, 57u8, 198u8, 111u8, 39u8, 167u8, 107u8, 209u8, 61u8, 55u8, 76u8, 246u8,
9428                36u8, 10u8, 230u8, 189u8, 11u8, 183u8, 43u8,
9429            ],
9430            [
9431                246u8, 232u8, 53u8, 156u8, 87u8, 82u8, 11u8, 70u8, 150u8, 52u8, 115u8, 107u8,
9432                252u8, 59u8, 183u8, 236u8, 92u8, 189u8, 26u8, 11u8, 210u8, 139u8, 16u8, 168u8,
9433                39u8, 87u8, 147u8, 187u8, 115u8, 11u8, 121u8, 127u8,
9434            ],
9435            [
9436                247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8,
9437                22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, 237u8,
9438                168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8,
9439            ],
9440            [
9441                251u8, 36u8, 48u8, 83u8, 84u8, 200u8, 119u8, 98u8, 213u8, 87u8, 72u8, 122u8, 228u8,
9442                165u8, 100u8, 232u8, 208u8, 62u8, 203u8, 185u8, 169u8, 125u8, 216u8, 175u8, 255u8,
9443                142u8, 31u8, 111u8, 202u8, 240u8, 221u8, 22u8,
9444            ],
9445        ];
9446    }
9447    #[automatically_derived]
9448    impl alloy_sol_types::SolEventInterface for StakeTableEvents {
9449        const NAME: &'static str = "StakeTableEvents";
9450        const COUNT: usize = 10usize;
9451        fn decode_raw_log(
9452            topics: &[alloy_sol_types::Word],
9453            data: &[u8],
9454            validate: bool,
9455        ) -> alloy_sol_types::Result<Self> {
9456            match topics.first().copied() {
9457                Some(<ConsensusKeysUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9458                    <ConsensusKeysUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
9459                        topics, data, validate,
9460                    )
9461                    .map(Self::ConsensusKeysUpdated)
9462                },
9463                Some(<Delegated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9464                    <Delegated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
9465                        .map(Self::Delegated)
9466                },
9467                Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9468                    <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
9469                        topics, data, validate,
9470                    )
9471                    .map(Self::Initialized)
9472                },
9473                Some(<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9474                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
9475                        topics, data, validate,
9476                    )
9477                    .map(Self::OwnershipTransferred)
9478                },
9479                Some(<Undelegated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9480                    <Undelegated as alloy_sol_types::SolEvent>::decode_raw_log(
9481                        topics, data, validate,
9482                    )
9483                    .map(Self::Undelegated)
9484                },
9485                Some(<Upgrade as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9486                    <Upgrade as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
9487                        .map(Self::Upgrade)
9488                },
9489                Some(<Upgraded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9490                    <Upgraded as alloy_sol_types::SolEvent>::decode_raw_log(topics, data, validate)
9491                        .map(Self::Upgraded)
9492                },
9493                Some(<ValidatorExit as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9494                    <ValidatorExit as alloy_sol_types::SolEvent>::decode_raw_log(
9495                        topics, data, validate,
9496                    )
9497                    .map(Self::ValidatorExit)
9498                },
9499                Some(<ValidatorRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9500                    <ValidatorRegistered as alloy_sol_types::SolEvent>::decode_raw_log(
9501                        topics, data, validate,
9502                    )
9503                    .map(Self::ValidatorRegistered)
9504                },
9505                Some(<Withdrawal as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9506                    <Withdrawal as alloy_sol_types::SolEvent>::decode_raw_log(
9507                        topics, data, validate,
9508                    )
9509                    .map(Self::Withdrawal)
9510                },
9511                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
9512                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
9513                    log: alloy_sol_types::private::Box::new(
9514                        alloy_sol_types::private::LogData::new_unchecked(
9515                            topics.to_vec(),
9516                            data.to_vec().into(),
9517                        ),
9518                    ),
9519                }),
9520            }
9521        }
9522    }
9523    #[automatically_derived]
9524    impl alloy_sol_types::private::IntoLogData for StakeTableEvents {
9525        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9526            match self {
9527                Self::ConsensusKeysUpdated(inner) => {
9528                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
9529                },
9530                Self::Delegated(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
9531                Self::Initialized(inner) => {
9532                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
9533                },
9534                Self::OwnershipTransferred(inner) => {
9535                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
9536                },
9537                Self::Undelegated(inner) => {
9538                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
9539                },
9540                Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
9541                Self::Upgraded(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
9542                Self::ValidatorExit(inner) => {
9543                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
9544                },
9545                Self::ValidatorRegistered(inner) => {
9546                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
9547                },
9548                Self::Withdrawal(inner) => {
9549                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
9550                },
9551            }
9552        }
9553        fn into_log_data(self) -> alloy_sol_types::private::LogData {
9554            match self {
9555                Self::ConsensusKeysUpdated(inner) => {
9556                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
9557                },
9558                Self::Delegated(inner) => {
9559                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
9560                },
9561                Self::Initialized(inner) => {
9562                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
9563                },
9564                Self::OwnershipTransferred(inner) => {
9565                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
9566                },
9567                Self::Undelegated(inner) => {
9568                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
9569                },
9570                Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
9571                Self::Upgraded(inner) => {
9572                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
9573                },
9574                Self::ValidatorExit(inner) => {
9575                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
9576                },
9577                Self::ValidatorRegistered(inner) => {
9578                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
9579                },
9580                Self::Withdrawal(inner) => {
9581                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
9582                },
9583            }
9584        }
9585    }
9586    use alloy::contract as alloy_contract;
9587    /**Creates a new wrapper around an on-chain [`StakeTable`](self) contract instance.
9588
9589    See the [wrapper's documentation](`StakeTableInstance`) for more details.*/
9590    #[inline]
9591    pub const fn new<
9592        T: alloy_contract::private::Transport + ::core::clone::Clone,
9593        P: alloy_contract::private::Provider<T, N>,
9594        N: alloy_contract::private::Network,
9595    >(
9596        address: alloy_sol_types::private::Address,
9597        provider: P,
9598    ) -> StakeTableInstance<T, P, N> {
9599        StakeTableInstance::<T, P, N>::new(address, provider)
9600    }
9601    /**Deploys this contract using the given `provider` and constructor arguments, if any.
9602
9603    Returns a new instance of the contract, if the deployment was successful.
9604
9605    For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
9606    #[inline]
9607    pub fn deploy<
9608        T: alloy_contract::private::Transport + ::core::clone::Clone,
9609        P: alloy_contract::private::Provider<T, N>,
9610        N: alloy_contract::private::Network,
9611    >(
9612        provider: P,
9613    ) -> impl ::core::future::Future<Output = alloy_contract::Result<StakeTableInstance<T, P, N>>>
9614    {
9615        StakeTableInstance::<T, P, N>::deploy(provider)
9616    }
9617    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
9618    and constructor arguments, if any.
9619
9620    This is a simple wrapper around creating a `RawCallBuilder` with the data set to
9621    the bytecode concatenated with the constructor's ABI-encoded arguments.*/
9622    #[inline]
9623    pub fn deploy_builder<
9624        T: alloy_contract::private::Transport + ::core::clone::Clone,
9625        P: alloy_contract::private::Provider<T, N>,
9626        N: alloy_contract::private::Network,
9627    >(
9628        provider: P,
9629    ) -> alloy_contract::RawCallBuilder<T, P, N> {
9630        StakeTableInstance::<T, P, N>::deploy_builder(provider)
9631    }
9632    /**A [`StakeTable`](self) instance.
9633
9634    Contains type-safe methods for interacting with an on-chain instance of the
9635    [`StakeTable`](self) contract located at a given `address`, using a given
9636    provider `P`.
9637
9638    If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
9639    documentation on how to provide it), the `deploy` and `deploy_builder` methods can
9640    be used to deploy a new instance of the contract.
9641
9642    See the [module-level documentation](self) for all the available methods.*/
9643    #[derive(Clone)]
9644    pub struct StakeTableInstance<T, P, N = alloy_contract::private::Ethereum> {
9645        address: alloy_sol_types::private::Address,
9646        provider: P,
9647        _network_transport: ::core::marker::PhantomData<(N, T)>,
9648    }
9649    #[automatically_derived]
9650    impl<T, P, N> ::core::fmt::Debug for StakeTableInstance<T, P, N> {
9651        #[inline]
9652        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9653            f.debug_tuple("StakeTableInstance")
9654                .field(&self.address)
9655                .finish()
9656        }
9657    }
9658    /// Instantiation and getters/setters.
9659    #[automatically_derived]
9660    impl<
9661            T: alloy_contract::private::Transport + ::core::clone::Clone,
9662            P: alloy_contract::private::Provider<T, N>,
9663            N: alloy_contract::private::Network,
9664        > StakeTableInstance<T, P, N>
9665    {
9666        /**Creates a new wrapper around an on-chain [`StakeTable`](self) contract instance.
9667
9668        See the [wrapper's documentation](`StakeTableInstance`) for more details.*/
9669        #[inline]
9670        pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
9671            Self {
9672                address,
9673                provider,
9674                _network_transport: ::core::marker::PhantomData,
9675            }
9676        }
9677        /**Deploys this contract using the given `provider` and constructor arguments, if any.
9678
9679        Returns a new instance of the contract, if the deployment was successful.
9680
9681        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
9682        #[inline]
9683        pub async fn deploy(provider: P) -> alloy_contract::Result<StakeTableInstance<T, P, N>> {
9684            let call_builder = Self::deploy_builder(provider);
9685            let contract_address = call_builder.deploy().await?;
9686            Ok(Self::new(contract_address, call_builder.provider))
9687        }
9688        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
9689        and constructor arguments, if any.
9690
9691        This is a simple wrapper around creating a `RawCallBuilder` with the data set to
9692        the bytecode concatenated with the constructor's ABI-encoded arguments.*/
9693        #[inline]
9694        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
9695            alloy_contract::RawCallBuilder::new_raw_deploy(
9696                provider,
9697                ::core::clone::Clone::clone(&BYTECODE),
9698            )
9699        }
9700        /// Returns a reference to the address.
9701        #[inline]
9702        pub const fn address(&self) -> &alloy_sol_types::private::Address {
9703            &self.address
9704        }
9705        /// Sets the address.
9706        #[inline]
9707        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
9708            self.address = address;
9709        }
9710        /// Sets the address and returns `self`.
9711        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
9712            self.set_address(address);
9713            self
9714        }
9715        /// Returns a reference to the provider.
9716        #[inline]
9717        pub const fn provider(&self) -> &P {
9718            &self.provider
9719        }
9720    }
9721    impl<T, P: ::core::clone::Clone, N> StakeTableInstance<T, &P, N> {
9722        /// Clones the provider and returns a new instance with the cloned provider.
9723        #[inline]
9724        pub fn with_cloned_provider(self) -> StakeTableInstance<T, P, N> {
9725            StakeTableInstance {
9726                address: self.address,
9727                provider: ::core::clone::Clone::clone(&self.provider),
9728                _network_transport: ::core::marker::PhantomData,
9729            }
9730        }
9731    }
9732    /// Function calls.
9733    #[automatically_derived]
9734    impl<
9735            T: alloy_contract::private::Transport + ::core::clone::Clone,
9736            P: alloy_contract::private::Provider<T, N>,
9737            N: alloy_contract::private::Network,
9738        > StakeTableInstance<T, P, N>
9739    {
9740        /// Creates a new call builder using this contract instance's provider and address.
9741        ///
9742        /// Note that the call can be any function call, not just those defined in this
9743        /// contract. Prefer using the other methods for building type-safe contract calls.
9744        pub fn call_builder<C: alloy_sol_types::SolCall>(
9745            &self,
9746            call: &C,
9747        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
9748            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
9749        }
9750        ///Creates a new call builder for the [`UPGRADE_INTERFACE_VERSION`] function.
9751        pub fn UPGRADE_INTERFACE_VERSION(
9752            &self,
9753        ) -> alloy_contract::SolCallBuilder<T, &P, UPGRADE_INTERFACE_VERSIONCall, N> {
9754            self.call_builder(&UPGRADE_INTERFACE_VERSIONCall {})
9755        }
9756        ///Creates a new call builder for the [`_hashBlsKey`] function.
9757        pub fn _hashBlsKey(
9758            &self,
9759            blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
9760        ) -> alloy_contract::SolCallBuilder<T, &P, _hashBlsKeyCall, N> {
9761            self.call_builder(&_hashBlsKeyCall { blsVK })
9762        }
9763        ///Creates a new call builder for the [`blsKeys`] function.
9764        pub fn blsKeys(
9765            &self,
9766            blsKeyHash: alloy::sol_types::private::FixedBytes<32>,
9767        ) -> alloy_contract::SolCallBuilder<T, &P, blsKeysCall, N> {
9768            self.call_builder(&blsKeysCall { blsKeyHash })
9769        }
9770        ///Creates a new call builder for the [`claimValidatorExit`] function.
9771        pub fn claimValidatorExit(
9772            &self,
9773            validator: alloy::sol_types::private::Address,
9774        ) -> alloy_contract::SolCallBuilder<T, &P, claimValidatorExitCall, N> {
9775            self.call_builder(&claimValidatorExitCall { validator })
9776        }
9777        ///Creates a new call builder for the [`claimWithdrawal`] function.
9778        pub fn claimWithdrawal(
9779            &self,
9780            validator: alloy::sol_types::private::Address,
9781        ) -> alloy_contract::SolCallBuilder<T, &P, claimWithdrawalCall, N> {
9782            self.call_builder(&claimWithdrawalCall { validator })
9783        }
9784        ///Creates a new call builder for the [`delegate`] function.
9785        pub fn delegate(
9786            &self,
9787            validator: alloy::sol_types::private::Address,
9788            amount: alloy::sol_types::private::primitives::aliases::U256,
9789        ) -> alloy_contract::SolCallBuilder<T, &P, delegateCall, N> {
9790            self.call_builder(&delegateCall { validator, amount })
9791        }
9792        ///Creates a new call builder for the [`delegations`] function.
9793        pub fn delegations(
9794            &self,
9795            validator: alloy::sol_types::private::Address,
9796            delegator: alloy::sol_types::private::Address,
9797        ) -> alloy_contract::SolCallBuilder<T, &P, delegationsCall, N> {
9798            self.call_builder(&delegationsCall {
9799                validator,
9800                delegator,
9801            })
9802        }
9803        ///Creates a new call builder for the [`deregisterValidator`] function.
9804        pub fn deregisterValidator(
9805            &self,
9806        ) -> alloy_contract::SolCallBuilder<T, &P, deregisterValidatorCall, N> {
9807            self.call_builder(&deregisterValidatorCall {})
9808        }
9809        ///Creates a new call builder for the [`exitEscrowPeriod`] function.
9810        pub fn exitEscrowPeriod(
9811            &self,
9812        ) -> alloy_contract::SolCallBuilder<T, &P, exitEscrowPeriodCall, N> {
9813            self.call_builder(&exitEscrowPeriodCall {})
9814        }
9815        ///Creates a new call builder for the [`getVersion`] function.
9816        pub fn getVersion(&self) -> alloy_contract::SolCallBuilder<T, &P, getVersionCall, N> {
9817            self.call_builder(&getVersionCall {})
9818        }
9819        ///Creates a new call builder for the [`initialize`] function.
9820        pub fn initialize(
9821            &self,
9822            _tokenAddress: alloy::sol_types::private::Address,
9823            _lightClientAddress: alloy::sol_types::private::Address,
9824            _exitEscrowPeriod: alloy::sol_types::private::primitives::aliases::U256,
9825            _timelock: alloy::sol_types::private::Address,
9826        ) -> alloy_contract::SolCallBuilder<T, &P, initializeCall, N> {
9827            self.call_builder(&initializeCall {
9828                _tokenAddress,
9829                _lightClientAddress,
9830                _exitEscrowPeriod,
9831                _timelock,
9832            })
9833        }
9834        ///Creates a new call builder for the [`initializedAtBlock`] function.
9835        pub fn initializedAtBlock(
9836            &self,
9837        ) -> alloy_contract::SolCallBuilder<T, &P, initializedAtBlockCall, N> {
9838            self.call_builder(&initializedAtBlockCall {})
9839        }
9840        ///Creates a new call builder for the [`lightClient`] function.
9841        pub fn lightClient(&self) -> alloy_contract::SolCallBuilder<T, &P, lightClientCall, N> {
9842            self.call_builder(&lightClientCall {})
9843        }
9844        ///Creates a new call builder for the [`owner`] function.
9845        pub fn owner(&self) -> alloy_contract::SolCallBuilder<T, &P, ownerCall, N> {
9846            self.call_builder(&ownerCall {})
9847        }
9848        ///Creates a new call builder for the [`proxiableUUID`] function.
9849        pub fn proxiableUUID(&self) -> alloy_contract::SolCallBuilder<T, &P, proxiableUUIDCall, N> {
9850            self.call_builder(&proxiableUUIDCall {})
9851        }
9852        ///Creates a new call builder for the [`registerValidator`] function.
9853        pub fn registerValidator(
9854            &self,
9855            blsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
9856            schnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
9857            blsSig: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
9858            commission: u16,
9859        ) -> alloy_contract::SolCallBuilder<T, &P, registerValidatorCall, N> {
9860            self.call_builder(&registerValidatorCall {
9861                blsVK,
9862                schnorrVK,
9863                blsSig,
9864                commission,
9865            })
9866        }
9867        ///Creates a new call builder for the [`renounceOwnership`] function.
9868        pub fn renounceOwnership(
9869            &self,
9870        ) -> alloy_contract::SolCallBuilder<T, &P, renounceOwnershipCall, N> {
9871            self.call_builder(&renounceOwnershipCall {})
9872        }
9873        ///Creates a new call builder for the [`token`] function.
9874        pub fn token(&self) -> alloy_contract::SolCallBuilder<T, &P, tokenCall, N> {
9875            self.call_builder(&tokenCall {})
9876        }
9877        ///Creates a new call builder for the [`transferOwnership`] function.
9878        pub fn transferOwnership(
9879            &self,
9880            newOwner: alloy::sol_types::private::Address,
9881        ) -> alloy_contract::SolCallBuilder<T, &P, transferOwnershipCall, N> {
9882            self.call_builder(&transferOwnershipCall { newOwner })
9883        }
9884        ///Creates a new call builder for the [`undelegate`] function.
9885        pub fn undelegate(
9886            &self,
9887            validator: alloy::sol_types::private::Address,
9888            amount: alloy::sol_types::private::primitives::aliases::U256,
9889        ) -> alloy_contract::SolCallBuilder<T, &P, undelegateCall, N> {
9890            self.call_builder(&undelegateCall { validator, amount })
9891        }
9892        ///Creates a new call builder for the [`undelegations`] function.
9893        pub fn undelegations(
9894            &self,
9895            validator: alloy::sol_types::private::Address,
9896            delegator: alloy::sol_types::private::Address,
9897        ) -> alloy_contract::SolCallBuilder<T, &P, undelegationsCall, N> {
9898            self.call_builder(&undelegationsCall {
9899                validator,
9900                delegator,
9901            })
9902        }
9903        ///Creates a new call builder for the [`updateConsensusKeys`] function.
9904        pub fn updateConsensusKeys(
9905            &self,
9906            newBlsVK: <BN254::G2Point as alloy::sol_types::SolType>::RustType,
9907            newSchnorrVK: <EdOnBN254::EdOnBN254Point as alloy::sol_types::SolType>::RustType,
9908            newBlsSig: <BN254::G1Point as alloy::sol_types::SolType>::RustType,
9909        ) -> alloy_contract::SolCallBuilder<T, &P, updateConsensusKeysCall, N> {
9910            self.call_builder(&updateConsensusKeysCall {
9911                newBlsVK,
9912                newSchnorrVK,
9913                newBlsSig,
9914            })
9915        }
9916        ///Creates a new call builder for the [`upgradeToAndCall`] function.
9917        pub fn upgradeToAndCall(
9918            &self,
9919            newImplementation: alloy::sol_types::private::Address,
9920            data: alloy::sol_types::private::Bytes,
9921        ) -> alloy_contract::SolCallBuilder<T, &P, upgradeToAndCallCall, N> {
9922            self.call_builder(&upgradeToAndCallCall {
9923                newImplementation,
9924                data,
9925            })
9926        }
9927        ///Creates a new call builder for the [`validatorExits`] function.
9928        pub fn validatorExits(
9929            &self,
9930            validator: alloy::sol_types::private::Address,
9931        ) -> alloy_contract::SolCallBuilder<T, &P, validatorExitsCall, N> {
9932            self.call_builder(&validatorExitsCall { validator })
9933        }
9934        ///Creates a new call builder for the [`validators`] function.
9935        pub fn validators(
9936            &self,
9937            account: alloy::sol_types::private::Address,
9938        ) -> alloy_contract::SolCallBuilder<T, &P, validatorsCall, N> {
9939            self.call_builder(&validatorsCall { account })
9940        }
9941    }
9942    /// Event filters.
9943    #[automatically_derived]
9944    impl<
9945            T: alloy_contract::private::Transport + ::core::clone::Clone,
9946            P: alloy_contract::private::Provider<T, N>,
9947            N: alloy_contract::private::Network,
9948        > StakeTableInstance<T, P, N>
9949    {
9950        /// Creates a new event filter using this contract instance's provider and address.
9951        ///
9952        /// Note that the type can be any event, not just those defined in this contract.
9953        /// Prefer using the other methods for building type-safe event filters.
9954        pub fn event_filter<E: alloy_sol_types::SolEvent>(
9955            &self,
9956        ) -> alloy_contract::Event<T, &P, E, N> {
9957            alloy_contract::Event::new_sol(&self.provider, &self.address)
9958        }
9959        ///Creates a new event filter for the [`ConsensusKeysUpdated`] event.
9960        pub fn ConsensusKeysUpdated_filter(
9961            &self,
9962        ) -> alloy_contract::Event<T, &P, ConsensusKeysUpdated, N> {
9963            self.event_filter::<ConsensusKeysUpdated>()
9964        }
9965        ///Creates a new event filter for the [`Delegated`] event.
9966        pub fn Delegated_filter(&self) -> alloy_contract::Event<T, &P, Delegated, N> {
9967            self.event_filter::<Delegated>()
9968        }
9969        ///Creates a new event filter for the [`Initialized`] event.
9970        pub fn Initialized_filter(&self) -> alloy_contract::Event<T, &P, Initialized, N> {
9971            self.event_filter::<Initialized>()
9972        }
9973        ///Creates a new event filter for the [`OwnershipTransferred`] event.
9974        pub fn OwnershipTransferred_filter(
9975            &self,
9976        ) -> alloy_contract::Event<T, &P, OwnershipTransferred, N> {
9977            self.event_filter::<OwnershipTransferred>()
9978        }
9979        ///Creates a new event filter for the [`Undelegated`] event.
9980        pub fn Undelegated_filter(&self) -> alloy_contract::Event<T, &P, Undelegated, N> {
9981            self.event_filter::<Undelegated>()
9982        }
9983        ///Creates a new event filter for the [`Upgrade`] event.
9984        pub fn Upgrade_filter(&self) -> alloy_contract::Event<T, &P, Upgrade, N> {
9985            self.event_filter::<Upgrade>()
9986        }
9987        ///Creates a new event filter for the [`Upgraded`] event.
9988        pub fn Upgraded_filter(&self) -> alloy_contract::Event<T, &P, Upgraded, N> {
9989            self.event_filter::<Upgraded>()
9990        }
9991        ///Creates a new event filter for the [`ValidatorExit`] event.
9992        pub fn ValidatorExit_filter(&self) -> alloy_contract::Event<T, &P, ValidatorExit, N> {
9993            self.event_filter::<ValidatorExit>()
9994        }
9995        ///Creates a new event filter for the [`ValidatorRegistered`] event.
9996        pub fn ValidatorRegistered_filter(
9997            &self,
9998        ) -> alloy_contract::Event<T, &P, ValidatorRegistered, N> {
9999            self.event_filter::<ValidatorRegistered>()
10000        }
10001        ///Creates a new event filter for the [`Withdrawal`] event.
10002        pub fn Withdrawal_filter(&self) -> alloy_contract::Event<T, &P, Withdrawal, N> {
10003            self.event_filter::<Withdrawal>()
10004        }
10005    }
10006}
hotshot_contract_adapter/bindings/staketable.rs

hotshot_contract_adapter/bindings/
staketable.rs
