eigenlayer_contract_deployer/bindings/core/
index_registry.rs

1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use IndexRegistry::*;
3
4///Module containing a contract's types and functions.
5/**
6
7```solidity
8library IIndexRegistryTypes {
9    struct OperatorUpdate { uint32 fromBlockNumber; bytes32 operatorId; }
10    struct QuorumUpdate { uint32 fromBlockNumber; uint32 numOperators; }
11}
12```*/
13#[allow(
14    non_camel_case_types,
15    non_snake_case,
16    clippy::pub_underscore_fields,
17    clippy::style,
18    clippy::empty_structs_with_brackets
19)]
20pub mod IIndexRegistryTypes {
21    use super::*;
22    use alloy::sol_types as alloy_sol_types;
23    #[derive(serde::Serialize, serde::Deserialize)]
24    #[derive(Default, Debug, PartialEq, Eq, Hash)]
25    /**```solidity
26struct OperatorUpdate { uint32 fromBlockNumber; bytes32 operatorId; }
27```*/
28    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
29    #[derive(Clone)]
30    pub struct OperatorUpdate {
31        #[allow(missing_docs)]
32        pub fromBlockNumber: u32,
33        #[allow(missing_docs)]
34        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
35    }
36    #[allow(
37        non_camel_case_types,
38        non_snake_case,
39        clippy::pub_underscore_fields,
40        clippy::style
41    )]
42    const _: () = {
43        use alloy::sol_types as alloy_sol_types;
44        #[doc(hidden)]
45        type UnderlyingSolTuple<'a> = (
46            alloy::sol_types::sol_data::Uint<32>,
47            alloy::sol_types::sol_data::FixedBytes<32>,
48        );
49        #[doc(hidden)]
50        type UnderlyingRustTuple<'a> = (u32, alloy::sol_types::private::FixedBytes<32>);
51        #[cfg(test)]
52        #[allow(dead_code, unreachable_patterns)]
53        fn _type_assertion(
54            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
55        ) {
56            match _t {
57                alloy_sol_types::private::AssertTypeEq::<
58                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
59                >(_) => {}
60            }
61        }
62        #[automatically_derived]
63        #[doc(hidden)]
64        impl ::core::convert::From<OperatorUpdate> for UnderlyingRustTuple<'_> {
65            fn from(value: OperatorUpdate) -> Self {
66                (value.fromBlockNumber, value.operatorId)
67            }
68        }
69        #[automatically_derived]
70        #[doc(hidden)]
71        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorUpdate {
72            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
73                Self {
74                    fromBlockNumber: tuple.0,
75                    operatorId: tuple.1,
76                }
77            }
78        }
79        #[automatically_derived]
80        impl alloy_sol_types::SolValue for OperatorUpdate {
81            type SolType = Self;
82        }
83        #[automatically_derived]
84        impl alloy_sol_types::private::SolTypeValue<Self> for OperatorUpdate {
85            #[inline]
86            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
87                (
88                    <alloy::sol_types::sol_data::Uint<
89                        32,
90                    > as alloy_sol_types::SolType>::tokenize(&self.fromBlockNumber),
91                    <alloy::sol_types::sol_data::FixedBytes<
92                        32,
93                    > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
94                )
95            }
96            #[inline]
97            fn stv_abi_encoded_size(&self) -> usize {
98                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
99                    return size;
100                }
101                let tuple = <UnderlyingRustTuple<
102                    '_,
103                > as ::core::convert::From<Self>>::from(self.clone());
104                <UnderlyingSolTuple<
105                    '_,
106                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
107            }
108            #[inline]
109            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
110                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
111            }
112            #[inline]
113            fn stv_abi_encode_packed_to(
114                &self,
115                out: &mut alloy_sol_types::private::Vec<u8>,
116            ) {
117                let tuple = <UnderlyingRustTuple<
118                    '_,
119                > as ::core::convert::From<Self>>::from(self.clone());
120                <UnderlyingSolTuple<
121                    '_,
122                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
123            }
124            #[inline]
125            fn stv_abi_packed_encoded_size(&self) -> usize {
126                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
127                    return size;
128                }
129                let tuple = <UnderlyingRustTuple<
130                    '_,
131                > as ::core::convert::From<Self>>::from(self.clone());
132                <UnderlyingSolTuple<
133                    '_,
134                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
135            }
136        }
137        #[automatically_derived]
138        impl alloy_sol_types::SolType for OperatorUpdate {
139            type RustType = Self;
140            type Token<'a> = <UnderlyingSolTuple<
141                'a,
142            > as alloy_sol_types::SolType>::Token<'a>;
143            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
144            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
145                '_,
146            > as alloy_sol_types::SolType>::ENCODED_SIZE;
147            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
148                '_,
149            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
150            #[inline]
151            fn valid_token(token: &Self::Token<'_>) -> bool {
152                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
153            }
154            #[inline]
155            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
156                let tuple = <UnderlyingSolTuple<
157                    '_,
158                > as alloy_sol_types::SolType>::detokenize(token);
159                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
160            }
161        }
162        #[automatically_derived]
163        impl alloy_sol_types::SolStruct for OperatorUpdate {
164            const NAME: &'static str = "OperatorUpdate";
165            #[inline]
166            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
167                alloy_sol_types::private::Cow::Borrowed(
168                    "OperatorUpdate(uint32 fromBlockNumber,bytes32 operatorId)",
169                )
170            }
171            #[inline]
172            fn eip712_components() -> alloy_sol_types::private::Vec<
173                alloy_sol_types::private::Cow<'static, str>,
174            > {
175                alloy_sol_types::private::Vec::new()
176            }
177            #[inline]
178            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
179                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
180            }
181            #[inline]
182            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
183                [
184                    <alloy::sol_types::sol_data::Uint<
185                        32,
186                    > as alloy_sol_types::SolType>::eip712_data_word(
187                            &self.fromBlockNumber,
188                        )
189                        .0,
190                    <alloy::sol_types::sol_data::FixedBytes<
191                        32,
192                    > as alloy_sol_types::SolType>::eip712_data_word(&self.operatorId)
193                        .0,
194                ]
195                    .concat()
196            }
197        }
198        #[automatically_derived]
199        impl alloy_sol_types::EventTopic for OperatorUpdate {
200            #[inline]
201            fn topic_preimage_length(rust: &Self::RustType) -> usize {
202                0usize
203                    + <alloy::sol_types::sol_data::Uint<
204                        32,
205                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
206                        &rust.fromBlockNumber,
207                    )
208                    + <alloy::sol_types::sol_data::FixedBytes<
209                        32,
210                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
211                        &rust.operatorId,
212                    )
213            }
214            #[inline]
215            fn encode_topic_preimage(
216                rust: &Self::RustType,
217                out: &mut alloy_sol_types::private::Vec<u8>,
218            ) {
219                out.reserve(
220                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
221                );
222                <alloy::sol_types::sol_data::Uint<
223                    32,
224                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
225                    &rust.fromBlockNumber,
226                    out,
227                );
228                <alloy::sol_types::sol_data::FixedBytes<
229                    32,
230                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
231                    &rust.operatorId,
232                    out,
233                );
234            }
235            #[inline]
236            fn encode_topic(
237                rust: &Self::RustType,
238            ) -> alloy_sol_types::abi::token::WordToken {
239                let mut out = alloy_sol_types::private::Vec::new();
240                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
241                    rust,
242                    &mut out,
243                );
244                alloy_sol_types::abi::token::WordToken(
245                    alloy_sol_types::private::keccak256(out),
246                )
247            }
248        }
249    };
250    #[derive(serde::Serialize, serde::Deserialize)]
251    #[derive(Default, Debug, PartialEq, Eq, Hash)]
252    /**```solidity
253struct QuorumUpdate { uint32 fromBlockNumber; uint32 numOperators; }
254```*/
255    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
256    #[derive(Clone)]
257    pub struct QuorumUpdate {
258        #[allow(missing_docs)]
259        pub fromBlockNumber: u32,
260        #[allow(missing_docs)]
261        pub numOperators: u32,
262    }
263    #[allow(
264        non_camel_case_types,
265        non_snake_case,
266        clippy::pub_underscore_fields,
267        clippy::style
268    )]
269    const _: () = {
270        use alloy::sol_types as alloy_sol_types;
271        #[doc(hidden)]
272        type UnderlyingSolTuple<'a> = (
273            alloy::sol_types::sol_data::Uint<32>,
274            alloy::sol_types::sol_data::Uint<32>,
275        );
276        #[doc(hidden)]
277        type UnderlyingRustTuple<'a> = (u32, u32);
278        #[cfg(test)]
279        #[allow(dead_code, unreachable_patterns)]
280        fn _type_assertion(
281            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
282        ) {
283            match _t {
284                alloy_sol_types::private::AssertTypeEq::<
285                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
286                >(_) => {}
287            }
288        }
289        #[automatically_derived]
290        #[doc(hidden)]
291        impl ::core::convert::From<QuorumUpdate> for UnderlyingRustTuple<'_> {
292            fn from(value: QuorumUpdate) -> Self {
293                (value.fromBlockNumber, value.numOperators)
294            }
295        }
296        #[automatically_derived]
297        #[doc(hidden)]
298        impl ::core::convert::From<UnderlyingRustTuple<'_>> for QuorumUpdate {
299            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
300                Self {
301                    fromBlockNumber: tuple.0,
302                    numOperators: tuple.1,
303                }
304            }
305        }
306        #[automatically_derived]
307        impl alloy_sol_types::SolValue for QuorumUpdate {
308            type SolType = Self;
309        }
310        #[automatically_derived]
311        impl alloy_sol_types::private::SolTypeValue<Self> for QuorumUpdate {
312            #[inline]
313            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
314                (
315                    <alloy::sol_types::sol_data::Uint<
316                        32,
317                    > as alloy_sol_types::SolType>::tokenize(&self.fromBlockNumber),
318                    <alloy::sol_types::sol_data::Uint<
319                        32,
320                    > as alloy_sol_types::SolType>::tokenize(&self.numOperators),
321                )
322            }
323            #[inline]
324            fn stv_abi_encoded_size(&self) -> usize {
325                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
326                    return size;
327                }
328                let tuple = <UnderlyingRustTuple<
329                    '_,
330                > as ::core::convert::From<Self>>::from(self.clone());
331                <UnderlyingSolTuple<
332                    '_,
333                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
334            }
335            #[inline]
336            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
337                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
338            }
339            #[inline]
340            fn stv_abi_encode_packed_to(
341                &self,
342                out: &mut alloy_sol_types::private::Vec<u8>,
343            ) {
344                let tuple = <UnderlyingRustTuple<
345                    '_,
346                > as ::core::convert::From<Self>>::from(self.clone());
347                <UnderlyingSolTuple<
348                    '_,
349                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
350            }
351            #[inline]
352            fn stv_abi_packed_encoded_size(&self) -> usize {
353                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
354                    return size;
355                }
356                let tuple = <UnderlyingRustTuple<
357                    '_,
358                > as ::core::convert::From<Self>>::from(self.clone());
359                <UnderlyingSolTuple<
360                    '_,
361                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
362            }
363        }
364        #[automatically_derived]
365        impl alloy_sol_types::SolType for QuorumUpdate {
366            type RustType = Self;
367            type Token<'a> = <UnderlyingSolTuple<
368                'a,
369            > as alloy_sol_types::SolType>::Token<'a>;
370            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
371            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
372                '_,
373            > as alloy_sol_types::SolType>::ENCODED_SIZE;
374            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
375                '_,
376            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
377            #[inline]
378            fn valid_token(token: &Self::Token<'_>) -> bool {
379                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
380            }
381            #[inline]
382            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
383                let tuple = <UnderlyingSolTuple<
384                    '_,
385                > as alloy_sol_types::SolType>::detokenize(token);
386                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
387            }
388        }
389        #[automatically_derived]
390        impl alloy_sol_types::SolStruct for QuorumUpdate {
391            const NAME: &'static str = "QuorumUpdate";
392            #[inline]
393            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
394                alloy_sol_types::private::Cow::Borrowed(
395                    "QuorumUpdate(uint32 fromBlockNumber,uint32 numOperators)",
396                )
397            }
398            #[inline]
399            fn eip712_components() -> alloy_sol_types::private::Vec<
400                alloy_sol_types::private::Cow<'static, str>,
401            > {
402                alloy_sol_types::private::Vec::new()
403            }
404            #[inline]
405            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
406                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
407            }
408            #[inline]
409            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
410                [
411                    <alloy::sol_types::sol_data::Uint<
412                        32,
413                    > as alloy_sol_types::SolType>::eip712_data_word(
414                            &self.fromBlockNumber,
415                        )
416                        .0,
417                    <alloy::sol_types::sol_data::Uint<
418                        32,
419                    > as alloy_sol_types::SolType>::eip712_data_word(&self.numOperators)
420                        .0,
421                ]
422                    .concat()
423            }
424        }
425        #[automatically_derived]
426        impl alloy_sol_types::EventTopic for QuorumUpdate {
427            #[inline]
428            fn topic_preimage_length(rust: &Self::RustType) -> usize {
429                0usize
430                    + <alloy::sol_types::sol_data::Uint<
431                        32,
432                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
433                        &rust.fromBlockNumber,
434                    )
435                    + <alloy::sol_types::sol_data::Uint<
436                        32,
437                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
438                        &rust.numOperators,
439                    )
440            }
441            #[inline]
442            fn encode_topic_preimage(
443                rust: &Self::RustType,
444                out: &mut alloy_sol_types::private::Vec<u8>,
445            ) {
446                out.reserve(
447                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
448                );
449                <alloy::sol_types::sol_data::Uint<
450                    32,
451                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
452                    &rust.fromBlockNumber,
453                    out,
454                );
455                <alloy::sol_types::sol_data::Uint<
456                    32,
457                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
458                    &rust.numOperators,
459                    out,
460                );
461            }
462            #[inline]
463            fn encode_topic(
464                rust: &Self::RustType,
465            ) -> alloy_sol_types::abi::token::WordToken {
466                let mut out = alloy_sol_types::private::Vec::new();
467                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
468                    rust,
469                    &mut out,
470                );
471                alloy_sol_types::abi::token::WordToken(
472                    alloy_sol_types::private::keccak256(out),
473                )
474            }
475        }
476    };
477    use alloy::contract as alloy_contract;
478    /**Creates a new wrapper around an on-chain [`IIndexRegistryTypes`](self) contract instance.
479
480See the [wrapper's documentation](`IIndexRegistryTypesInstance`) for more details.*/
481    #[inline]
482    pub const fn new<
483        P: alloy_contract::private::Provider<N>,
484        N: alloy_contract::private::Network,
485    >(
486        address: alloy_sol_types::private::Address,
487        provider: P,
488    ) -> IIndexRegistryTypesInstance<P, N> {
489        IIndexRegistryTypesInstance::<P, N>::new(address, provider)
490    }
491    /**A [`IIndexRegistryTypes`](self) instance.
492
493Contains type-safe methods for interacting with an on-chain instance of the
494[`IIndexRegistryTypes`](self) contract located at a given `address`, using a given
495provider `P`.
496
497If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
498documentation on how to provide it), the `deploy` and `deploy_builder` methods can
499be used to deploy a new instance of the contract.
500
501See the [module-level documentation](self) for all the available methods.*/
502    #[derive(Clone)]
503    pub struct IIndexRegistryTypesInstance<P, N = alloy_contract::private::Ethereum> {
504        address: alloy_sol_types::private::Address,
505        provider: P,
506        _network: ::core::marker::PhantomData<N>,
507    }
508    #[automatically_derived]
509    impl<P, N> ::core::fmt::Debug for IIndexRegistryTypesInstance<P, N> {
510        #[inline]
511        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
512            f.debug_tuple("IIndexRegistryTypesInstance").field(&self.address).finish()
513        }
514    }
515    /// Instantiation and getters/setters.
516    #[automatically_derived]
517    impl<
518        P: alloy_contract::private::Provider<N>,
519        N: alloy_contract::private::Network,
520    > IIndexRegistryTypesInstance<P, N> {
521        /**Creates a new wrapper around an on-chain [`IIndexRegistryTypes`](self) contract instance.
522
523See the [wrapper's documentation](`IIndexRegistryTypesInstance`) for more details.*/
524        #[inline]
525        pub const fn new(
526            address: alloy_sol_types::private::Address,
527            provider: P,
528        ) -> Self {
529            Self {
530                address,
531                provider,
532                _network: ::core::marker::PhantomData,
533            }
534        }
535        /// Returns a reference to the address.
536        #[inline]
537        pub const fn address(&self) -> &alloy_sol_types::private::Address {
538            &self.address
539        }
540        /// Sets the address.
541        #[inline]
542        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
543            self.address = address;
544        }
545        /// Sets the address and returns `self`.
546        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
547            self.set_address(address);
548            self
549        }
550        /// Returns a reference to the provider.
551        #[inline]
552        pub const fn provider(&self) -> &P {
553            &self.provider
554        }
555    }
556    impl<P: ::core::clone::Clone, N> IIndexRegistryTypesInstance<&P, N> {
557        /// Clones the provider and returns a new instance with the cloned provider.
558        #[inline]
559        pub fn with_cloned_provider(self) -> IIndexRegistryTypesInstance<P, N> {
560            IIndexRegistryTypesInstance {
561                address: self.address,
562                provider: ::core::clone::Clone::clone(&self.provider),
563                _network: ::core::marker::PhantomData,
564            }
565        }
566    }
567    /// Function calls.
568    #[automatically_derived]
569    impl<
570        P: alloy_contract::private::Provider<N>,
571        N: alloy_contract::private::Network,
572    > IIndexRegistryTypesInstance<P, N> {
573        /// Creates a new call builder using this contract instance's provider and address.
574        ///
575        /// Note that the call can be any function call, not just those defined in this
576        /// contract. Prefer using the other methods for building type-safe contract calls.
577        pub fn call_builder<C: alloy_sol_types::SolCall>(
578            &self,
579            call: &C,
580        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
581            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
582        }
583    }
584    /// Event filters.
585    #[automatically_derived]
586    impl<
587        P: alloy_contract::private::Provider<N>,
588        N: alloy_contract::private::Network,
589    > IIndexRegistryTypesInstance<P, N> {
590        /// Creates a new event filter using this contract instance's provider and address.
591        ///
592        /// Note that the type can be any event, not just those defined in this contract.
593        /// Prefer using the other methods for building type-safe event filters.
594        pub fn event_filter<E: alloy_sol_types::SolEvent>(
595            &self,
596        ) -> alloy_contract::Event<&P, E, N> {
597            alloy_contract::Event::new_sol(&self.provider, &self.address)
598        }
599    }
600}
601/**
602
603Generated by the following Solidity interface...
604```solidity
605library IIndexRegistryTypes {
606    struct OperatorUpdate {
607        uint32 fromBlockNumber;
608        bytes32 operatorId;
609    }
610    struct QuorumUpdate {
611        uint32 fromBlockNumber;
612        uint32 numOperators;
613    }
614}
615
616interface IndexRegistry {
617    error OnlyRegistryCoordinator();
618    error OperatorIdDoesNotExist();
619    error QuorumDoesNotExist();
620
621    event Initialized(uint8 version);
622    event QuorumIndexUpdate(bytes32 indexed operatorId, uint8 quorumNumber, uint32 newOperatorIndex);
623
624    constructor(address _slashingRegistryCoordinator);
625
626    function OPERATOR_DOES_NOT_EXIST_ID() external view returns (bytes32);
627    function currentOperatorIndex(uint8, bytes32) external view returns (uint32);
628    function deregisterOperator(bytes32 operatorId, bytes memory quorumNumbers) external;
629    function getLatestOperatorUpdate(uint8 quorumNumber, uint32 operatorIndex) external view returns (IIndexRegistryTypes.OperatorUpdate memory);
630    function getLatestQuorumUpdate(uint8 quorumNumber) external view returns (IIndexRegistryTypes.QuorumUpdate memory);
631    function getOperatorListAtBlockNumber(uint8 quorumNumber, uint32 blockNumber) external view returns (bytes32[] memory);
632    function getOperatorUpdateAtIndex(uint8 quorumNumber, uint32 operatorIndex, uint32 arrayIndex) external view returns (IIndexRegistryTypes.OperatorUpdate memory);
633    function getQuorumUpdateAtIndex(uint8 quorumNumber, uint32 quorumIndex) external view returns (IIndexRegistryTypes.QuorumUpdate memory);
634    function initializeQuorum(uint8 quorumNumber) external;
635    function registerOperator(bytes32 operatorId, bytes memory quorumNumbers) external returns (uint32[] memory);
636    function registryCoordinator() external view returns (address);
637    function totalOperatorsForQuorum(uint8 quorumNumber) external view returns (uint32);
638    function totalOperatorsForQuorumAtBlockNumber(uint8 quorumNumber, uint32 blockNumber) external view returns (uint32);
639}
640```
641
642...which was generated by the following JSON ABI:
643```json
644[
645  {
646    "type": "constructor",
647    "inputs": [
648      {
649        "name": "_slashingRegistryCoordinator",
650        "type": "address",
651        "internalType": "contract ISlashingRegistryCoordinator"
652      }
653    ],
654    "stateMutability": "nonpayable"
655  },
656  {
657    "type": "function",
658    "name": "OPERATOR_DOES_NOT_EXIST_ID",
659    "inputs": [],
660    "outputs": [
661      {
662        "name": "",
663        "type": "bytes32",
664        "internalType": "bytes32"
665      }
666    ],
667    "stateMutability": "view"
668  },
669  {
670    "type": "function",
671    "name": "currentOperatorIndex",
672    "inputs": [
673      {
674        "name": "",
675        "type": "uint8",
676        "internalType": "uint8"
677      },
678      {
679        "name": "",
680        "type": "bytes32",
681        "internalType": "bytes32"
682      }
683    ],
684    "outputs": [
685      {
686        "name": "",
687        "type": "uint32",
688        "internalType": "uint32"
689      }
690    ],
691    "stateMutability": "view"
692  },
693  {
694    "type": "function",
695    "name": "deregisterOperator",
696    "inputs": [
697      {
698        "name": "operatorId",
699        "type": "bytes32",
700        "internalType": "bytes32"
701      },
702      {
703        "name": "quorumNumbers",
704        "type": "bytes",
705        "internalType": "bytes"
706      }
707    ],
708    "outputs": [],
709    "stateMutability": "nonpayable"
710  },
711  {
712    "type": "function",
713    "name": "getLatestOperatorUpdate",
714    "inputs": [
715      {
716        "name": "quorumNumber",
717        "type": "uint8",
718        "internalType": "uint8"
719      },
720      {
721        "name": "operatorIndex",
722        "type": "uint32",
723        "internalType": "uint32"
724      }
725    ],
726    "outputs": [
727      {
728        "name": "",
729        "type": "tuple",
730        "internalType": "struct IIndexRegistryTypes.OperatorUpdate",
731        "components": [
732          {
733            "name": "fromBlockNumber",
734            "type": "uint32",
735            "internalType": "uint32"
736          },
737          {
738            "name": "operatorId",
739            "type": "bytes32",
740            "internalType": "bytes32"
741          }
742        ]
743      }
744    ],
745    "stateMutability": "view"
746  },
747  {
748    "type": "function",
749    "name": "getLatestQuorumUpdate",
750    "inputs": [
751      {
752        "name": "quorumNumber",
753        "type": "uint8",
754        "internalType": "uint8"
755      }
756    ],
757    "outputs": [
758      {
759        "name": "",
760        "type": "tuple",
761        "internalType": "struct IIndexRegistryTypes.QuorumUpdate",
762        "components": [
763          {
764            "name": "fromBlockNumber",
765            "type": "uint32",
766            "internalType": "uint32"
767          },
768          {
769            "name": "numOperators",
770            "type": "uint32",
771            "internalType": "uint32"
772          }
773        ]
774      }
775    ],
776    "stateMutability": "view"
777  },
778  {
779    "type": "function",
780    "name": "getOperatorListAtBlockNumber",
781    "inputs": [
782      {
783        "name": "quorumNumber",
784        "type": "uint8",
785        "internalType": "uint8"
786      },
787      {
788        "name": "blockNumber",
789        "type": "uint32",
790        "internalType": "uint32"
791      }
792    ],
793    "outputs": [
794      {
795        "name": "",
796        "type": "bytes32[]",
797        "internalType": "bytes32[]"
798      }
799    ],
800    "stateMutability": "view"
801  },
802  {
803    "type": "function",
804    "name": "getOperatorUpdateAtIndex",
805    "inputs": [
806      {
807        "name": "quorumNumber",
808        "type": "uint8",
809        "internalType": "uint8"
810      },
811      {
812        "name": "operatorIndex",
813        "type": "uint32",
814        "internalType": "uint32"
815      },
816      {
817        "name": "arrayIndex",
818        "type": "uint32",
819        "internalType": "uint32"
820      }
821    ],
822    "outputs": [
823      {
824        "name": "",
825        "type": "tuple",
826        "internalType": "struct IIndexRegistryTypes.OperatorUpdate",
827        "components": [
828          {
829            "name": "fromBlockNumber",
830            "type": "uint32",
831            "internalType": "uint32"
832          },
833          {
834            "name": "operatorId",
835            "type": "bytes32",
836            "internalType": "bytes32"
837          }
838        ]
839      }
840    ],
841    "stateMutability": "view"
842  },
843  {
844    "type": "function",
845    "name": "getQuorumUpdateAtIndex",
846    "inputs": [
847      {
848        "name": "quorumNumber",
849        "type": "uint8",
850        "internalType": "uint8"
851      },
852      {
853        "name": "quorumIndex",
854        "type": "uint32",
855        "internalType": "uint32"
856      }
857    ],
858    "outputs": [
859      {
860        "name": "",
861        "type": "tuple",
862        "internalType": "struct IIndexRegistryTypes.QuorumUpdate",
863        "components": [
864          {
865            "name": "fromBlockNumber",
866            "type": "uint32",
867            "internalType": "uint32"
868          },
869          {
870            "name": "numOperators",
871            "type": "uint32",
872            "internalType": "uint32"
873          }
874        ]
875      }
876    ],
877    "stateMutability": "view"
878  },
879  {
880    "type": "function",
881    "name": "initializeQuorum",
882    "inputs": [
883      {
884        "name": "quorumNumber",
885        "type": "uint8",
886        "internalType": "uint8"
887      }
888    ],
889    "outputs": [],
890    "stateMutability": "nonpayable"
891  },
892  {
893    "type": "function",
894    "name": "registerOperator",
895    "inputs": [
896      {
897        "name": "operatorId",
898        "type": "bytes32",
899        "internalType": "bytes32"
900      },
901      {
902        "name": "quorumNumbers",
903        "type": "bytes",
904        "internalType": "bytes"
905      }
906    ],
907    "outputs": [
908      {
909        "name": "",
910        "type": "uint32[]",
911        "internalType": "uint32[]"
912      }
913    ],
914    "stateMutability": "nonpayable"
915  },
916  {
917    "type": "function",
918    "name": "registryCoordinator",
919    "inputs": [],
920    "outputs": [
921      {
922        "name": "",
923        "type": "address",
924        "internalType": "address"
925      }
926    ],
927    "stateMutability": "view"
928  },
929  {
930    "type": "function",
931    "name": "totalOperatorsForQuorum",
932    "inputs": [
933      {
934        "name": "quorumNumber",
935        "type": "uint8",
936        "internalType": "uint8"
937      }
938    ],
939    "outputs": [
940      {
941        "name": "",
942        "type": "uint32",
943        "internalType": "uint32"
944      }
945    ],
946    "stateMutability": "view"
947  },
948  {
949    "type": "function",
950    "name": "totalOperatorsForQuorumAtBlockNumber",
951    "inputs": [
952      {
953        "name": "quorumNumber",
954        "type": "uint8",
955        "internalType": "uint8"
956      },
957      {
958        "name": "blockNumber",
959        "type": "uint32",
960        "internalType": "uint32"
961      }
962    ],
963    "outputs": [
964      {
965        "name": "",
966        "type": "uint32",
967        "internalType": "uint32"
968      }
969    ],
970    "stateMutability": "view"
971  },
972  {
973    "type": "event",
974    "name": "Initialized",
975    "inputs": [
976      {
977        "name": "version",
978        "type": "uint8",
979        "indexed": false,
980        "internalType": "uint8"
981      }
982    ],
983    "anonymous": false
984  },
985  {
986    "type": "event",
987    "name": "QuorumIndexUpdate",
988    "inputs": [
989      {
990        "name": "operatorId",
991        "type": "bytes32",
992        "indexed": true,
993        "internalType": "bytes32"
994      },
995      {
996        "name": "quorumNumber",
997        "type": "uint8",
998        "indexed": false,
999        "internalType": "uint8"
1000      },
1001      {
1002        "name": "newOperatorIndex",
1003        "type": "uint32",
1004        "indexed": false,
1005        "internalType": "uint32"
1006      }
1007    ],
1008    "anonymous": false
1009  },
1010  {
1011    "type": "error",
1012    "name": "OnlyRegistryCoordinator",
1013    "inputs": []
1014  },
1015  {
1016    "type": "error",
1017    "name": "OperatorIdDoesNotExist",
1018    "inputs": []
1019  },
1020  {
1021    "type": "error",
1022    "name": "QuorumDoesNotExist",
1023    "inputs": []
1024  }
1025]
1026```*/
1027#[allow(
1028    non_camel_case_types,
1029    non_snake_case,
1030    clippy::pub_underscore_fields,
1031    clippy::style,
1032    clippy::empty_structs_with_brackets
1033)]
1034pub mod IndexRegistry {
1035    use super::*;
1036    use alloy::sol_types as alloy_sol_types;
1037    /// The creation / init bytecode of the contract.
1038    ///
1039    /// ```text
1040    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
1041    /// ```
1042    #[rustfmt::skip]
1043    #[allow(clippy::all)]
1044    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1045        b"`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x11c8\x03\x80a\x11c\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01\x07V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\x80R\x80a\0Da\0KV[PPa\x014V[_Ta\x01\0\x90\x04`\xFF\x16\x15a\0\xB6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FInitializable: contract is initi`D\x82\x01Rfalizing`\xC8\x1B`d\x82\x01R`\x84\x01`@Q\x80\x91\x03\x90\xFD[_T`\xFF\x90\x81\x16\x14a\x01\x05W_\x80T`\xFF\x19\x16`\xFF\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x90` \x01`@Q\x80\x91\x03\x90\xA1[V[_` \x82\x84\x03\x12\x15a\x01\x17W__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x01-W__\xFD[\x93\x92PPPV[`\x80Qa\x10\x10a\x01S_9_\x81\x81a\x01X\x01Ra\x07\x8D\x01Ra\x10\x10_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xCAW_5`\xE0\x1C\x80c\x81!\x90o\x11a\0\x88W\x80c\xBD)\xB8\xCD\x11a\0cW\x80c\xBD)\xB8\xCD\x14a\x02$W\x80c\xCA\xA3\xCDv\x14a\x027W\x80c\xE2\xE6\x85\x80\x14a\x02LW\x80c\xF3A\t\"\x14a\x02|W__\xFD[\x80c\x81!\x90o\x14a\x01\xBAW\x80c\x89\x02bE\x14a\x01\xF1W\x80c\xA4\x8B\xB0\xAC\x14a\x02\x11W__\xFD[\x80b\xBF\xF0M\x14a\0\xCEW\x80c\x12\xD1\xD7M\x14a\0\xF7W\x80c&\xD9A\xF2\x14a\x01+W\x80c.\xD5\x83\xE5\x14a\x01@W\x80cm\x14\xA9\x87\x14a\x01SW\x80c{]&\xBE\x14a\x01\x92W[__\xFD[a\0\xE1a\0\xDC6`\x04a\rnV[a\x02\x8FV[`@Qa\0\xEE\x91\x90a\r\xE5V[`@Q\x80\x91\x03\x90\xF3[a\x01\na\x01\x056`\x04a\x0EUV[a\x03\x98V[`@\x80Q\x82Qc\xFF\xFF\xFF\xFF\x16\x81R` \x92\x83\x01Q\x92\x81\x01\x92\x90\x92R\x01a\0\xEEV[a\x01>a\x0196`\x04a\x0E\x86V[a\x03\xDDV[\0[a\x01\na\x01N6`\x04a\x0E\x9FV[a\x04vV[a\x01z\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\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xEEV[a\x01\xA5a\x01\xA06`\x04a\x0EUV[a\x04\xF9V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\0\xEEV[a\x01\xCDa\x01\xC86`\x04a\x0E\x86V[a\x05\x04V[`@\x80Q\x82Qc\xFF\xFF\xFF\xFF\x90\x81\x16\x82R` \x93\x84\x01Q\x16\x92\x81\x01\x92\x90\x92R\x01a\0\xEEV[a\x02\x04a\x01\xFF6`\x04a\x0EUV[a\x05JV[`@Qa\0\xEE\x91\x90a\x0E\xDFV[a\x01\xCDa\x02\x1F6`\x04a\x0EUV[a\x06*V[a\x01>a\x0226`\x04a\rnV[a\x06\x9EV[a\x02>_\x81V[`@Q\x90\x81R` \x01a\0\xEEV[a\x01\xA5a\x02Z6`\x04a\x0F\x16V[`\x01` \x90\x81R_\x92\x83R`@\x80\x84 \x90\x91R\x90\x82R\x90 Tc\xFF\xFF\xFF\xFF\x16\x81V[a\x01\xA5a\x02\x8A6`\x04a\x0E\x86V[a\x07dV[``a\x02\x99a\x07\x82V[_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x02\xB3Wa\x02\xB3a\x0F>V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x02\xDCW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x03\x8DW_\x85\x85\x83\x81\x81\x10a\x02\xFCWa\x02\xFCa\x0FRV[\x91\x90\x91\x015`\xF8\x1C_\x81\x81R`\x03` R`@\x81 T\x91\x93P\x90\x91P\x81\x90\x03a\x038W`@Qcs\x10\xCF\xF5`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x03B\x83a\x07\xCDV[\x90Pa\x03Y\x89\x84a\x03T`\x01\x85a\x0FzV[a\x08\xC4V[\x80\x85\x85\x81Q\x81\x10a\x03lWa\x03la\x0FRV[c\xFF\xFF\xFF\xFF\x92\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01RPPP`\x01\x01a\x02\xE1V[P\x90P[\x93\x92PPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\x03\xB5\x83\x83a\tLV[`@\x80Q\x80\x82\x01\x90\x91R\x81Tc\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01T` \x82\x01R\x90P[\x92\x91PPV[a\x03\xE5a\x07\x82V[`\xFF\x81\x16_\x90\x81R`\x03` R`@\x90 T\x15a\x04\x15W`@Qcs\x10\xCF\xF5`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\xFF\x16_\x90\x81R`\x03` \x90\x81R`@\x80\x83 \x81Q\x80\x83\x01\x90\x92Rc\xFF\xFF\xFF\xFFC\x81\x16\x83R\x82\x84\x01\x85\x81R\x82T`\x01\x81\x01\x84U\x92\x86R\x93\x90\x94 \x91Q\x91\x01\x80T\x92Q\x84\x16`\x01` \x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x93\x16\x91\x90\x93\x16\x17\x17\x90UV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R`\xFF\x84\x16_\x90\x81R`\x02` \x90\x81R`@\x80\x83 c\xFF\xFF\xFF\xFF\x80\x88\x16\x85R\x92R\x90\x91 \x80T\x90\x91\x84\x16\x90\x81\x10a\x04\xC1Wa\x04\xC1a\x0FRV[_\x91\x82R` \x91\x82\x90 `@\x80Q\x80\x82\x01\x90\x91R`\x02\x90\x92\x02\x01\x80Tc\xFF\xFF\xFF\xFF\x16\x82R`\x01\x01T\x91\x81\x01\x91\x90\x91R\x90P\x93\x92PPPV[_a\x03\x91\x83\x83a\t\xA1V[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\x05 \x82a\n\xD7V[`@\x80Q\x80\x82\x01\x90\x91R\x90Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x83R`\x01` \x1B\x90\x91\x04\x16` \x82\x01R\x92\x91PPV[``_a\x05W\x84\x84a\t\xA1V[\x90P_\x81c\xFF\xFF\xFF\xFF\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05yWa\x05ya\x0F>V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05\xA2W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x82c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x06!Wa\x05\xC0\x86\x82\x87a\x0B\x16V[\x82\x82\x81Q\x81\x10a\x05\xD2Wa\x05\xD2a\x0FRV[` \x02` \x01\x01\x81\x81RPP__\x1B\x82\x82\x81Q\x81\x10a\x05\xF3Wa\x05\xF3a\x0FRV[` \x02` \x01\x01Q\x03a\x06\x19W`@Qc\x7F\x12\t\x8D`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01\x01a\x05\xA7V[P\x94\x93PPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R`\xFF\x83\x16_\x90\x81R`\x03` R`@\x90 \x80Tc\xFF\xFF\xFF\xFF\x84\x16\x90\x81\x10a\x06fWa\x06fa\x0FRV[_\x91\x82R` \x91\x82\x90 `@\x80Q\x80\x82\x01\x90\x91R\x91\x01Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x83R`\x01` \x1B\x90\x91\x04\x16\x91\x81\x01\x91\x90\x91R\x93\x92PPPV[a\x06\xA6a\x07\x82V[_[\x81\x81\x10\x15a\x07^W_\x83\x83\x83\x81\x81\x10a\x06\xC3Wa\x06\xC3a\x0FRV[\x91\x90\x91\x015`\xF8\x1C_\x81\x81R`\x03` R`@\x81 T\x91\x93P\x90\x91P\x81\x90\x03a\x06\xFFW`@Qcs\x10\xCF\xF5`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\xFF\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x89\x84R\x90\x91R\x81 Tc\xFF\xFF\xFF\xFF\x16\x90a\x07,\x84a\x0B\xE9V[\x90P_a\x079\x85\x83a\x0C!V[\x90P\x80\x89\x14a\x07MWa\x07M\x81\x86\x85a\x08\xC4V[PP`\x01\x90\x93\x01\x92Pa\x06\xA8\x91PPV[PPPPV[_a\x07n\x82a\n\xD7V[T`\x01` \x1B\x90\x04c\xFF\xFF\xFF\xFF\x16\x92\x91PPV[3`\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\x07\xCBW`@QcC\x94\xDB\xDF`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[__a\x07\xD8\x83a\n\xD7V[\x80T\x90\x91P_\x90a\x07\xF7\x90`\x01` \x1B\x90\x04c\xFF\xFF\xFF\xFF\x16`\x01a\x0F\x96V[\x90Pa\x08\x04\x84\x83\x83a\x0CIV[`\xFF\x84\x16_\x90\x81R`\x02` R`@\x81 \x90a\x08!`\x01\x84a\x0FzV[c\xFF\xFF\xFF\xFF\x16\x81R` \x81\x01\x91\x90\x91R`@\x01_\x90\x81 T\x90\x03a\x03\x91W`\xFF\x84\x16_\x90\x81R`\x02` R`@\x81 \x90a\x08\\`\x01\x84a\x0FzV[c\xFF\xFF\xFF\xFF\x90\x81\x16\x82R` \x80\x83\x01\x93\x90\x93R`@\x91\x82\x01_\x90\x81 \x83Q\x80\x85\x01\x90\x94RC\x83\x16\x84R\x83\x85\x01\x82\x81R\x81T`\x01\x80\x82\x01\x84U\x92\x84R\x95\x90\x92 \x93Q`\x02\x90\x95\x02\x90\x93\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x94\x90\x92\x16\x93\x90\x93\x17\x81U\x91Q\x91\x01U\x93\x92PPPV[_a\x08\xCF\x83\x83a\tLV[\x90Pa\x08\xDD\x83\x83\x83\x87a\x0C\xE6V[`\xFF\x83\x16_\x81\x81R`\x01` \x90\x81R`@\x80\x83 \x88\x84R\x82R\x91\x82\x90 \x80Tc\xFF\xFF\xFF\xFF\x19\x16c\xFF\xFF\xFF\xFF\x87\x16\x90\x81\x17\x90\x91U\x82Q\x93\x84R\x90\x83\x01R\x85\x91\x7Fn\xE1\xE4\xF4\x07_=\x06qv\x14\r4\xE8xt$M\xD2s)L\x05\xB2!\x813\xE4\x9A+\xA6\xF6\x91\x01`@Q\x80\x91\x03\x90\xA2PPPPV[`\xFF\x82\x16_\x90\x81R`\x02` \x90\x81R`@\x80\x83 c\xFF\xFF\xFF\xFF\x85\x16\x84R\x90\x91R\x81 \x80T\x90a\t|`\x01\x83a\x0F\xB2V[\x81T\x81\x10a\t\x8CWa\t\x8Ca\x0FRV[\x90_R` _ \x90`\x02\x02\x01\x91PP\x92\x91PPV[`\xFF\x82\x16_\x90\x81R`\x03` R`@\x81 T\x80[\x80\x15a\nFW`\xFF\x85\x16_\x90\x81R`\x03` R`@\x81 a\t\xD7`\x01\x84a\x0F\xB2V[\x81T\x81\x10a\t\xE7Wa\t\xE7a\x0FRV[_\x91\x82R` \x91\x82\x90 `@\x80Q\x80\x82\x01\x90\x91R\x91\x01Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x80\x84R`\x01` \x1B\x90\x92\x04\x81\x16\x93\x83\x01\x93\x90\x93R\x90\x92P\x90\x86\x16\x10a\n3W` \x01Q\x92Pa\x03\xD7\x91PPV[P\x80a\n>\x81a\x0F\xC5V[\x91PPa\t\xB5V[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`U`$\x82\x01R\x7FIndexRegistry._operatorCountAtBl`D\x82\x01R\x7FockNumber: quorum did not exist `d\x82\x01Rt0\xBA\x103\xB4\xBB2\xB7\x10167\xB1\xB5\x907:\xB6\xB12\xB9`Y\x1B`\x84\x82\x01R`\xA4\x01`@Q\x80\x91\x03\x90\xFD[`\xFF\x81\x16_\x90\x81R`\x03` R`@\x81 \x80T\x90a\n\xF6`\x01\x83a\x0F\xB2V[\x81T\x81\x10a\x0B\x06Wa\x0B\x06a\x0FRV[\x90_R` _ \x01\x91PP\x91\x90PV[`\xFF\x83\x16_\x90\x81R`\x02` \x90\x81R`@\x80\x83 c\xFF\xFF\xFF\xFF\x86\x16\x84R\x90\x91R\x81 T\x80[\x80\x15a\x0B\xDEW`\xFF\x86\x16_\x90\x81R`\x02` \x90\x81R`@\x80\x83 c\xFF\xFF\xFF\xFF\x89\x16\x84R\x90\x91R\x81 a\x0Bn`\x01\x84a\x0F\xB2V[\x81T\x81\x10a\x0B~Wa\x0B~a\x0FRV[_\x91\x82R` \x91\x82\x90 `@\x80Q\x80\x82\x01\x90\x91R`\x02\x90\x92\x02\x01\x80Tc\xFF\xFF\xFF\xFF\x90\x81\x16\x80\x84R`\x01\x90\x92\x01T\x93\x83\x01\x93\x90\x93R\x90\x92P\x90\x86\x16\x10a\x0B\xCBW` \x01Q\x92Pa\x03\x91\x91PPV[P\x80a\x0B\xD6\x81a\x0F\xC5V[\x91PPa\x0B;V[P_\x95\x94PPPPPV[__a\x0B\xF4\x83a\n\xD7V[\x80T\x90\x91P_\x90a\x0C\x14\x90`\x01\x90`\x01` \x1B\x90\x04c\xFF\xFF\xFF\xFF\x16a\x0FzV[\x90Pa\x03\x91\x84\x83\x83a\x0CIV[__a\x0C-\x84\x84a\tLV[`\x01\x81\x01T\x90\x91Pa\x0CA\x85\x85\x84_a\x0C\xE6V[\x94\x93PPPPV[\x81Tc\xFF\xFF\xFF\xFFC\x81\x16\x91\x16\x03a\x0C~W\x81Tc\xFF\xFF\xFF\xFF\x82\x16`\x01` \x1B\x02g\xFF\xFF\xFF\xFF\0\0\0\0\x19\x90\x91\x16\x17\x82UPPPV[`\xFF\x83\x16_\x90\x81R`\x03` \x90\x81R`@\x80\x83 \x81Q\x80\x83\x01\x90\x92Rc\xFF\xFF\xFF\xFFC\x81\x16\x83R\x85\x81\x16\x83\x85\x01\x90\x81R\x82T`\x01\x81\x01\x84U\x92\x86R\x93\x90\x94 \x91Q\x91\x01\x80T\x92Q\x84\x16`\x01` \x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x93\x16\x91\x90\x93\x16\x17\x17\x90UPPPV[\x81Tc\xFF\xFF\xFF\xFFC\x81\x16\x91\x16\x03a\r\x03W`\x01\x82\x01\x81\x90Ua\x07^V[`\xFF\x93\x90\x93\x16_\x90\x81R`\x02` \x81\x81R`@\x80\x84 c\xFF\xFF\xFF\xFF\x96\x87\x16\x85R\x82R\x80\x84 \x81Q\x80\x83\x01\x90\x92RC\x87\x16\x82R\x81\x83\x01\x97\x88R\x80T`\x01\x80\x82\x01\x83U\x91\x86R\x92\x90\x94 \x90Q\x91\x90\x92\x02\x90\x91\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x91\x90\x94\x16\x17\x83U\x92Q\x91\x90\x92\x01UPV[___`@\x84\x86\x03\x12\x15a\r\x80W__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x9DW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\r\xADW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xC3W__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\r\xD4W__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\"W\x83Qc\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\r\xFEV[P\x90\x95\x94PPPPPV[\x805`\xFF\x81\x16\x81\x14a\x0E=W__\xFD[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x0E=W__\xFD[__`@\x83\x85\x03\x12\x15a\x0EfW__\xFD[a\x0Eo\x83a\x0E-V[\x91Pa\x0E}` \x84\x01a\x0EBV[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x0E\x96W__\xFD[a\x03\x91\x82a\x0E-V[___``\x84\x86\x03\x12\x15a\x0E\xB1W__\xFD[a\x0E\xBA\x84a\x0E-V[\x92Pa\x0E\xC8` \x85\x01a\x0EBV[\x91Pa\x0E\xD6`@\x85\x01a\x0EBV[\x90P\x92P\x92P\x92V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\"W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0E\xF8V[__`@\x83\x85\x03\x12\x15a\x0F'W__\xFD[a\x0F0\x83a\x0E-V[\x94` \x93\x90\x93\x015\x93PPPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[c\xFF\xFF\xFF\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xD7Wa\x03\xD7a\x0FfV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x03\xD7Wa\x03\xD7a\x0FfV[\x81\x81\x03\x81\x81\x11\x15a\x03\xD7Wa\x03\xD7a\x0FfV[_\x81a\x0F\xD3Wa\x0F\xD3a\x0FfV[P_\x19\x01\x90V\xFE\xA2dipfsX\"\x12 AS7j+\xC8\xA7I\xCE\xDF\x9A>sq\xE3>]\xA6\xB6\xFAp{\xCEQ\x14\xB2\xA4\xBE\xFF\xB4\x8C\xAFdsolcC\0\x08\x1B\x003",
1046    );
1047    /// The runtime bytecode of the contract, as deployed on the network.
1048    ///
1049    /// ```text
1050    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
1051    /// ```
1052    #[rustfmt::skip]
1053    #[allow(clippy::all)]
1054    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1055        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xCAW_5`\xE0\x1C\x80c\x81!\x90o\x11a\0\x88W\x80c\xBD)\xB8\xCD\x11a\0cW\x80c\xBD)\xB8\xCD\x14a\x02$W\x80c\xCA\xA3\xCDv\x14a\x027W\x80c\xE2\xE6\x85\x80\x14a\x02LW\x80c\xF3A\t\"\x14a\x02|W__\xFD[\x80c\x81!\x90o\x14a\x01\xBAW\x80c\x89\x02bE\x14a\x01\xF1W\x80c\xA4\x8B\xB0\xAC\x14a\x02\x11W__\xFD[\x80b\xBF\xF0M\x14a\0\xCEW\x80c\x12\xD1\xD7M\x14a\0\xF7W\x80c&\xD9A\xF2\x14a\x01+W\x80c.\xD5\x83\xE5\x14a\x01@W\x80cm\x14\xA9\x87\x14a\x01SW\x80c{]&\xBE\x14a\x01\x92W[__\xFD[a\0\xE1a\0\xDC6`\x04a\rnV[a\x02\x8FV[`@Qa\0\xEE\x91\x90a\r\xE5V[`@Q\x80\x91\x03\x90\xF3[a\x01\na\x01\x056`\x04a\x0EUV[a\x03\x98V[`@\x80Q\x82Qc\xFF\xFF\xFF\xFF\x16\x81R` \x92\x83\x01Q\x92\x81\x01\x92\x90\x92R\x01a\0\xEEV[a\x01>a\x0196`\x04a\x0E\x86V[a\x03\xDDV[\0[a\x01\na\x01N6`\x04a\x0E\x9FV[a\x04vV[a\x01z\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\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xEEV[a\x01\xA5a\x01\xA06`\x04a\x0EUV[a\x04\xF9V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\0\xEEV[a\x01\xCDa\x01\xC86`\x04a\x0E\x86V[a\x05\x04V[`@\x80Q\x82Qc\xFF\xFF\xFF\xFF\x90\x81\x16\x82R` \x93\x84\x01Q\x16\x92\x81\x01\x92\x90\x92R\x01a\0\xEEV[a\x02\x04a\x01\xFF6`\x04a\x0EUV[a\x05JV[`@Qa\0\xEE\x91\x90a\x0E\xDFV[a\x01\xCDa\x02\x1F6`\x04a\x0EUV[a\x06*V[a\x01>a\x0226`\x04a\rnV[a\x06\x9EV[a\x02>_\x81V[`@Q\x90\x81R` \x01a\0\xEEV[a\x01\xA5a\x02Z6`\x04a\x0F\x16V[`\x01` \x90\x81R_\x92\x83R`@\x80\x84 \x90\x91R\x90\x82R\x90 Tc\xFF\xFF\xFF\xFF\x16\x81V[a\x01\xA5a\x02\x8A6`\x04a\x0E\x86V[a\x07dV[``a\x02\x99a\x07\x82V[_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x02\xB3Wa\x02\xB3a\x0F>V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x02\xDCW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x03\x8DW_\x85\x85\x83\x81\x81\x10a\x02\xFCWa\x02\xFCa\x0FRV[\x91\x90\x91\x015`\xF8\x1C_\x81\x81R`\x03` R`@\x81 T\x91\x93P\x90\x91P\x81\x90\x03a\x038W`@Qcs\x10\xCF\xF5`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x03B\x83a\x07\xCDV[\x90Pa\x03Y\x89\x84a\x03T`\x01\x85a\x0FzV[a\x08\xC4V[\x80\x85\x85\x81Q\x81\x10a\x03lWa\x03la\x0FRV[c\xFF\xFF\xFF\xFF\x92\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01RPPP`\x01\x01a\x02\xE1V[P\x90P[\x93\x92PPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\x03\xB5\x83\x83a\tLV[`@\x80Q\x80\x82\x01\x90\x91R\x81Tc\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01T` \x82\x01R\x90P[\x92\x91PPV[a\x03\xE5a\x07\x82V[`\xFF\x81\x16_\x90\x81R`\x03` R`@\x90 T\x15a\x04\x15W`@Qcs\x10\xCF\xF5`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\xFF\x16_\x90\x81R`\x03` \x90\x81R`@\x80\x83 \x81Q\x80\x83\x01\x90\x92Rc\xFF\xFF\xFF\xFFC\x81\x16\x83R\x82\x84\x01\x85\x81R\x82T`\x01\x81\x01\x84U\x92\x86R\x93\x90\x94 \x91Q\x91\x01\x80T\x92Q\x84\x16`\x01` \x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x93\x16\x91\x90\x93\x16\x17\x17\x90UV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R`\xFF\x84\x16_\x90\x81R`\x02` \x90\x81R`@\x80\x83 c\xFF\xFF\xFF\xFF\x80\x88\x16\x85R\x92R\x90\x91 \x80T\x90\x91\x84\x16\x90\x81\x10a\x04\xC1Wa\x04\xC1a\x0FRV[_\x91\x82R` \x91\x82\x90 `@\x80Q\x80\x82\x01\x90\x91R`\x02\x90\x92\x02\x01\x80Tc\xFF\xFF\xFF\xFF\x16\x82R`\x01\x01T\x91\x81\x01\x91\x90\x91R\x90P\x93\x92PPPV[_a\x03\x91\x83\x83a\t\xA1V[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\x05 \x82a\n\xD7V[`@\x80Q\x80\x82\x01\x90\x91R\x90Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x83R`\x01` \x1B\x90\x91\x04\x16` \x82\x01R\x92\x91PPV[``_a\x05W\x84\x84a\t\xA1V[\x90P_\x81c\xFF\xFF\xFF\xFF\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05yWa\x05ya\x0F>V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05\xA2W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x82c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x06!Wa\x05\xC0\x86\x82\x87a\x0B\x16V[\x82\x82\x81Q\x81\x10a\x05\xD2Wa\x05\xD2a\x0FRV[` \x02` \x01\x01\x81\x81RPP__\x1B\x82\x82\x81Q\x81\x10a\x05\xF3Wa\x05\xF3a\x0FRV[` \x02` \x01\x01Q\x03a\x06\x19W`@Qc\x7F\x12\t\x8D`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01\x01a\x05\xA7V[P\x94\x93PPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R`\xFF\x83\x16_\x90\x81R`\x03` R`@\x90 \x80Tc\xFF\xFF\xFF\xFF\x84\x16\x90\x81\x10a\x06fWa\x06fa\x0FRV[_\x91\x82R` \x91\x82\x90 `@\x80Q\x80\x82\x01\x90\x91R\x91\x01Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x83R`\x01` \x1B\x90\x91\x04\x16\x91\x81\x01\x91\x90\x91R\x93\x92PPPV[a\x06\xA6a\x07\x82V[_[\x81\x81\x10\x15a\x07^W_\x83\x83\x83\x81\x81\x10a\x06\xC3Wa\x06\xC3a\x0FRV[\x91\x90\x91\x015`\xF8\x1C_\x81\x81R`\x03` R`@\x81 T\x91\x93P\x90\x91P\x81\x90\x03a\x06\xFFW`@Qcs\x10\xCF\xF5`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\xFF\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x89\x84R\x90\x91R\x81 Tc\xFF\xFF\xFF\xFF\x16\x90a\x07,\x84a\x0B\xE9V[\x90P_a\x079\x85\x83a\x0C!V[\x90P\x80\x89\x14a\x07MWa\x07M\x81\x86\x85a\x08\xC4V[PP`\x01\x90\x93\x01\x92Pa\x06\xA8\x91PPV[PPPPV[_a\x07n\x82a\n\xD7V[T`\x01` \x1B\x90\x04c\xFF\xFF\xFF\xFF\x16\x92\x91PPV[3`\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\x07\xCBW`@QcC\x94\xDB\xDF`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[__a\x07\xD8\x83a\n\xD7V[\x80T\x90\x91P_\x90a\x07\xF7\x90`\x01` \x1B\x90\x04c\xFF\xFF\xFF\xFF\x16`\x01a\x0F\x96V[\x90Pa\x08\x04\x84\x83\x83a\x0CIV[`\xFF\x84\x16_\x90\x81R`\x02` R`@\x81 \x90a\x08!`\x01\x84a\x0FzV[c\xFF\xFF\xFF\xFF\x16\x81R` \x81\x01\x91\x90\x91R`@\x01_\x90\x81 T\x90\x03a\x03\x91W`\xFF\x84\x16_\x90\x81R`\x02` R`@\x81 \x90a\x08\\`\x01\x84a\x0FzV[c\xFF\xFF\xFF\xFF\x90\x81\x16\x82R` \x80\x83\x01\x93\x90\x93R`@\x91\x82\x01_\x90\x81 \x83Q\x80\x85\x01\x90\x94RC\x83\x16\x84R\x83\x85\x01\x82\x81R\x81T`\x01\x80\x82\x01\x84U\x92\x84R\x95\x90\x92 \x93Q`\x02\x90\x95\x02\x90\x93\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x94\x90\x92\x16\x93\x90\x93\x17\x81U\x91Q\x91\x01U\x93\x92PPPV[_a\x08\xCF\x83\x83a\tLV[\x90Pa\x08\xDD\x83\x83\x83\x87a\x0C\xE6V[`\xFF\x83\x16_\x81\x81R`\x01` \x90\x81R`@\x80\x83 \x88\x84R\x82R\x91\x82\x90 \x80Tc\xFF\xFF\xFF\xFF\x19\x16c\xFF\xFF\xFF\xFF\x87\x16\x90\x81\x17\x90\x91U\x82Q\x93\x84R\x90\x83\x01R\x85\x91\x7Fn\xE1\xE4\xF4\x07_=\x06qv\x14\r4\xE8xt$M\xD2s)L\x05\xB2!\x813\xE4\x9A+\xA6\xF6\x91\x01`@Q\x80\x91\x03\x90\xA2PPPPV[`\xFF\x82\x16_\x90\x81R`\x02` \x90\x81R`@\x80\x83 c\xFF\xFF\xFF\xFF\x85\x16\x84R\x90\x91R\x81 \x80T\x90a\t|`\x01\x83a\x0F\xB2V[\x81T\x81\x10a\t\x8CWa\t\x8Ca\x0FRV[\x90_R` _ \x90`\x02\x02\x01\x91PP\x92\x91PPV[`\xFF\x82\x16_\x90\x81R`\x03` R`@\x81 T\x80[\x80\x15a\nFW`\xFF\x85\x16_\x90\x81R`\x03` R`@\x81 a\t\xD7`\x01\x84a\x0F\xB2V[\x81T\x81\x10a\t\xE7Wa\t\xE7a\x0FRV[_\x91\x82R` \x91\x82\x90 `@\x80Q\x80\x82\x01\x90\x91R\x91\x01Tc\xFF\xFF\xFF\xFF\x80\x82\x16\x80\x84R`\x01` \x1B\x90\x92\x04\x81\x16\x93\x83\x01\x93\x90\x93R\x90\x92P\x90\x86\x16\x10a\n3W` \x01Q\x92Pa\x03\xD7\x91PPV[P\x80a\n>\x81a\x0F\xC5V[\x91PPa\t\xB5V[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`U`$\x82\x01R\x7FIndexRegistry._operatorCountAtBl`D\x82\x01R\x7FockNumber: quorum did not exist `d\x82\x01Rt0\xBA\x103\xB4\xBB2\xB7\x10167\xB1\xB5\x907:\xB6\xB12\xB9`Y\x1B`\x84\x82\x01R`\xA4\x01`@Q\x80\x91\x03\x90\xFD[`\xFF\x81\x16_\x90\x81R`\x03` R`@\x81 \x80T\x90a\n\xF6`\x01\x83a\x0F\xB2V[\x81T\x81\x10a\x0B\x06Wa\x0B\x06a\x0FRV[\x90_R` _ \x01\x91PP\x91\x90PV[`\xFF\x83\x16_\x90\x81R`\x02` \x90\x81R`@\x80\x83 c\xFF\xFF\xFF\xFF\x86\x16\x84R\x90\x91R\x81 T\x80[\x80\x15a\x0B\xDEW`\xFF\x86\x16_\x90\x81R`\x02` \x90\x81R`@\x80\x83 c\xFF\xFF\xFF\xFF\x89\x16\x84R\x90\x91R\x81 a\x0Bn`\x01\x84a\x0F\xB2V[\x81T\x81\x10a\x0B~Wa\x0B~a\x0FRV[_\x91\x82R` \x91\x82\x90 `@\x80Q\x80\x82\x01\x90\x91R`\x02\x90\x92\x02\x01\x80Tc\xFF\xFF\xFF\xFF\x90\x81\x16\x80\x84R`\x01\x90\x92\x01T\x93\x83\x01\x93\x90\x93R\x90\x92P\x90\x86\x16\x10a\x0B\xCBW` \x01Q\x92Pa\x03\x91\x91PPV[P\x80a\x0B\xD6\x81a\x0F\xC5V[\x91PPa\x0B;V[P_\x95\x94PPPPPV[__a\x0B\xF4\x83a\n\xD7V[\x80T\x90\x91P_\x90a\x0C\x14\x90`\x01\x90`\x01` \x1B\x90\x04c\xFF\xFF\xFF\xFF\x16a\x0FzV[\x90Pa\x03\x91\x84\x83\x83a\x0CIV[__a\x0C-\x84\x84a\tLV[`\x01\x81\x01T\x90\x91Pa\x0CA\x85\x85\x84_a\x0C\xE6V[\x94\x93PPPPV[\x81Tc\xFF\xFF\xFF\xFFC\x81\x16\x91\x16\x03a\x0C~W\x81Tc\xFF\xFF\xFF\xFF\x82\x16`\x01` \x1B\x02g\xFF\xFF\xFF\xFF\0\0\0\0\x19\x90\x91\x16\x17\x82UPPPV[`\xFF\x83\x16_\x90\x81R`\x03` \x90\x81R`@\x80\x83 \x81Q\x80\x83\x01\x90\x92Rc\xFF\xFF\xFF\xFFC\x81\x16\x83R\x85\x81\x16\x83\x85\x01\x90\x81R\x82T`\x01\x81\x01\x84U\x92\x86R\x93\x90\x94 \x91Q\x91\x01\x80T\x92Q\x84\x16`\x01` \x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x93\x16\x91\x90\x93\x16\x17\x17\x90UPPPV[\x81Tc\xFF\xFF\xFF\xFFC\x81\x16\x91\x16\x03a\r\x03W`\x01\x82\x01\x81\x90Ua\x07^V[`\xFF\x93\x90\x93\x16_\x90\x81R`\x02` \x81\x81R`@\x80\x84 c\xFF\xFF\xFF\xFF\x96\x87\x16\x85R\x82R\x80\x84 \x81Q\x80\x83\x01\x90\x92RC\x87\x16\x82R\x81\x83\x01\x97\x88R\x80T`\x01\x80\x82\x01\x83U\x91\x86R\x92\x90\x94 \x90Q\x91\x90\x92\x02\x90\x91\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x91\x90\x94\x16\x17\x83U\x92Q\x91\x90\x92\x01UPV[___`@\x84\x86\x03\x12\x15a\r\x80W__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x9DW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\r\xADW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xC3W__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\r\xD4W__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\"W\x83Qc\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\r\xFEV[P\x90\x95\x94PPPPPV[\x805`\xFF\x81\x16\x81\x14a\x0E=W__\xFD[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x0E=W__\xFD[__`@\x83\x85\x03\x12\x15a\x0EfW__\xFD[a\x0Eo\x83a\x0E-V[\x91Pa\x0E}` \x84\x01a\x0EBV[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x0E\x96W__\xFD[a\x03\x91\x82a\x0E-V[___``\x84\x86\x03\x12\x15a\x0E\xB1W__\xFD[a\x0E\xBA\x84a\x0E-V[\x92Pa\x0E\xC8` \x85\x01a\x0EBV[\x91Pa\x0E\xD6`@\x85\x01a\x0EBV[\x90P\x92P\x92P\x92V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\"W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0E\xF8V[__`@\x83\x85\x03\x12\x15a\x0F'W__\xFD[a\x0F0\x83a\x0E-V[\x94` \x93\x90\x93\x015\x93PPPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[c\xFF\xFF\xFF\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xD7Wa\x03\xD7a\x0FfV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x03\xD7Wa\x03\xD7a\x0FfV[\x81\x81\x03\x81\x81\x11\x15a\x03\xD7Wa\x03\xD7a\x0FfV[_\x81a\x0F\xD3Wa\x0F\xD3a\x0FfV[P_\x19\x01\x90V\xFE\xA2dipfsX\"\x12 AS7j+\xC8\xA7I\xCE\xDF\x9A>sq\xE3>]\xA6\xB6\xFAp{\xCEQ\x14\xB2\xA4\xBE\xFF\xB4\x8C\xAFdsolcC\0\x08\x1B\x003",
1056    );
1057    #[derive(serde::Serialize, serde::Deserialize)]
1058    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1059    /**Custom error with signature `OnlyRegistryCoordinator()` and selector `0x8729b7be`.
1060```solidity
1061error OnlyRegistryCoordinator();
1062```*/
1063    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1064    #[derive(Clone)]
1065    pub struct OnlyRegistryCoordinator;
1066    #[allow(
1067        non_camel_case_types,
1068        non_snake_case,
1069        clippy::pub_underscore_fields,
1070        clippy::style
1071    )]
1072    const _: () = {
1073        use alloy::sol_types as alloy_sol_types;
1074        #[doc(hidden)]
1075        type UnderlyingSolTuple<'a> = ();
1076        #[doc(hidden)]
1077        type UnderlyingRustTuple<'a> = ();
1078        #[cfg(test)]
1079        #[allow(dead_code, unreachable_patterns)]
1080        fn _type_assertion(
1081            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1082        ) {
1083            match _t {
1084                alloy_sol_types::private::AssertTypeEq::<
1085                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1086                >(_) => {}
1087            }
1088        }
1089        #[automatically_derived]
1090        #[doc(hidden)]
1091        impl ::core::convert::From<OnlyRegistryCoordinator> for UnderlyingRustTuple<'_> {
1092            fn from(value: OnlyRegistryCoordinator) -> Self {
1093                ()
1094            }
1095        }
1096        #[automatically_derived]
1097        #[doc(hidden)]
1098        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyRegistryCoordinator {
1099            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1100                Self
1101            }
1102        }
1103        #[automatically_derived]
1104        impl alloy_sol_types::SolError for OnlyRegistryCoordinator {
1105            type Parameters<'a> = UnderlyingSolTuple<'a>;
1106            type Token<'a> = <Self::Parameters<
1107                'a,
1108            > as alloy_sol_types::SolType>::Token<'a>;
1109            const SIGNATURE: &'static str = "OnlyRegistryCoordinator()";
1110            const SELECTOR: [u8; 4] = [135u8, 41u8, 183u8, 190u8];
1111            #[inline]
1112            fn new<'a>(
1113                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1114            ) -> Self {
1115                tuple.into()
1116            }
1117            #[inline]
1118            fn tokenize(&self) -> Self::Token<'_> {
1119                ()
1120            }
1121            #[inline]
1122            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1123                <Self::Parameters<
1124                    '_,
1125                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1126                    .map(Self::new)
1127            }
1128        }
1129    };
1130    #[derive(serde::Serialize, serde::Deserialize)]
1131    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1132    /**Custom error with signature `OperatorIdDoesNotExist()` and selector `0xfe24131a`.
1133```solidity
1134error OperatorIdDoesNotExist();
1135```*/
1136    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1137    #[derive(Clone)]
1138    pub struct OperatorIdDoesNotExist;
1139    #[allow(
1140        non_camel_case_types,
1141        non_snake_case,
1142        clippy::pub_underscore_fields,
1143        clippy::style
1144    )]
1145    const _: () = {
1146        use alloy::sol_types as alloy_sol_types;
1147        #[doc(hidden)]
1148        type UnderlyingSolTuple<'a> = ();
1149        #[doc(hidden)]
1150        type UnderlyingRustTuple<'a> = ();
1151        #[cfg(test)]
1152        #[allow(dead_code, unreachable_patterns)]
1153        fn _type_assertion(
1154            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1155        ) {
1156            match _t {
1157                alloy_sol_types::private::AssertTypeEq::<
1158                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1159                >(_) => {}
1160            }
1161        }
1162        #[automatically_derived]
1163        #[doc(hidden)]
1164        impl ::core::convert::From<OperatorIdDoesNotExist> for UnderlyingRustTuple<'_> {
1165            fn from(value: OperatorIdDoesNotExist) -> Self {
1166                ()
1167            }
1168        }
1169        #[automatically_derived]
1170        #[doc(hidden)]
1171        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorIdDoesNotExist {
1172            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1173                Self
1174            }
1175        }
1176        #[automatically_derived]
1177        impl alloy_sol_types::SolError for OperatorIdDoesNotExist {
1178            type Parameters<'a> = UnderlyingSolTuple<'a>;
1179            type Token<'a> = <Self::Parameters<
1180                'a,
1181            > as alloy_sol_types::SolType>::Token<'a>;
1182            const SIGNATURE: &'static str = "OperatorIdDoesNotExist()";
1183            const SELECTOR: [u8; 4] = [254u8, 36u8, 19u8, 26u8];
1184            #[inline]
1185            fn new<'a>(
1186                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1187            ) -> Self {
1188                tuple.into()
1189            }
1190            #[inline]
1191            fn tokenize(&self) -> Self::Token<'_> {
1192                ()
1193            }
1194            #[inline]
1195            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1196                <Self::Parameters<
1197                    '_,
1198                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1199                    .map(Self::new)
1200            }
1201        }
1202    };
1203    #[derive(serde::Serialize, serde::Deserialize)]
1204    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1205    /**Custom error with signature `QuorumDoesNotExist()` and selector `0xe6219fea`.
1206```solidity
1207error QuorumDoesNotExist();
1208```*/
1209    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1210    #[derive(Clone)]
1211    pub struct QuorumDoesNotExist;
1212    #[allow(
1213        non_camel_case_types,
1214        non_snake_case,
1215        clippy::pub_underscore_fields,
1216        clippy::style
1217    )]
1218    const _: () = {
1219        use alloy::sol_types as alloy_sol_types;
1220        #[doc(hidden)]
1221        type UnderlyingSolTuple<'a> = ();
1222        #[doc(hidden)]
1223        type UnderlyingRustTuple<'a> = ();
1224        #[cfg(test)]
1225        #[allow(dead_code, unreachable_patterns)]
1226        fn _type_assertion(
1227            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1228        ) {
1229            match _t {
1230                alloy_sol_types::private::AssertTypeEq::<
1231                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1232                >(_) => {}
1233            }
1234        }
1235        #[automatically_derived]
1236        #[doc(hidden)]
1237        impl ::core::convert::From<QuorumDoesNotExist> for UnderlyingRustTuple<'_> {
1238            fn from(value: QuorumDoesNotExist) -> Self {
1239                ()
1240            }
1241        }
1242        #[automatically_derived]
1243        #[doc(hidden)]
1244        impl ::core::convert::From<UnderlyingRustTuple<'_>> for QuorumDoesNotExist {
1245            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1246                Self
1247            }
1248        }
1249        #[automatically_derived]
1250        impl alloy_sol_types::SolError for QuorumDoesNotExist {
1251            type Parameters<'a> = UnderlyingSolTuple<'a>;
1252            type Token<'a> = <Self::Parameters<
1253                'a,
1254            > as alloy_sol_types::SolType>::Token<'a>;
1255            const SIGNATURE: &'static str = "QuorumDoesNotExist()";
1256            const SELECTOR: [u8; 4] = [230u8, 33u8, 159u8, 234u8];
1257            #[inline]
1258            fn new<'a>(
1259                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1260            ) -> Self {
1261                tuple.into()
1262            }
1263            #[inline]
1264            fn tokenize(&self) -> Self::Token<'_> {
1265                ()
1266            }
1267            #[inline]
1268            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1269                <Self::Parameters<
1270                    '_,
1271                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1272                    .map(Self::new)
1273            }
1274        }
1275    };
1276    #[derive(serde::Serialize, serde::Deserialize)]
1277    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1278    /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`.
1279```solidity
1280event Initialized(uint8 version);
1281```*/
1282    #[allow(
1283        non_camel_case_types,
1284        non_snake_case,
1285        clippy::pub_underscore_fields,
1286        clippy::style
1287    )]
1288    #[derive(Clone)]
1289    pub struct Initialized {
1290        #[allow(missing_docs)]
1291        pub version: u8,
1292    }
1293    #[allow(
1294        non_camel_case_types,
1295        non_snake_case,
1296        clippy::pub_underscore_fields,
1297        clippy::style
1298    )]
1299    const _: () = {
1300        use alloy::sol_types as alloy_sol_types;
1301        #[automatically_derived]
1302        impl alloy_sol_types::SolEvent for Initialized {
1303            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
1304            type DataToken<'a> = <Self::DataTuple<
1305                'a,
1306            > as alloy_sol_types::SolType>::Token<'a>;
1307            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1308            const SIGNATURE: &'static str = "Initialized(uint8)";
1309            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1310                127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
1311                19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
1312                146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
1313            ]);
1314            const ANONYMOUS: bool = false;
1315            #[allow(unused_variables)]
1316            #[inline]
1317            fn new(
1318                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1319                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1320            ) -> Self {
1321                Self { version: data.0 }
1322            }
1323            #[inline]
1324            fn check_signature(
1325                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1326            ) -> alloy_sol_types::Result<()> {
1327                if topics.0 != Self::SIGNATURE_HASH {
1328                    return Err(
1329                        alloy_sol_types::Error::invalid_event_signature_hash(
1330                            Self::SIGNATURE,
1331                            topics.0,
1332                            Self::SIGNATURE_HASH,
1333                        ),
1334                    );
1335                }
1336                Ok(())
1337            }
1338            #[inline]
1339            fn tokenize_body(&self) -> Self::DataToken<'_> {
1340                (
1341                    <alloy::sol_types::sol_data::Uint<
1342                        8,
1343                    > as alloy_sol_types::SolType>::tokenize(&self.version),
1344                )
1345            }
1346            #[inline]
1347            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1348                (Self::SIGNATURE_HASH.into(),)
1349            }
1350            #[inline]
1351            fn encode_topics_raw(
1352                &self,
1353                out: &mut [alloy_sol_types::abi::token::WordToken],
1354            ) -> alloy_sol_types::Result<()> {
1355                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1356                    return Err(alloy_sol_types::Error::Overrun);
1357                }
1358                out[0usize] = alloy_sol_types::abi::token::WordToken(
1359                    Self::SIGNATURE_HASH,
1360                );
1361                Ok(())
1362            }
1363        }
1364        #[automatically_derived]
1365        impl alloy_sol_types::private::IntoLogData for Initialized {
1366            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1367                From::from(self)
1368            }
1369            fn into_log_data(self) -> alloy_sol_types::private::LogData {
1370                From::from(&self)
1371            }
1372        }
1373        #[automatically_derived]
1374        impl From<&Initialized> for alloy_sol_types::private::LogData {
1375            #[inline]
1376            fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
1377                alloy_sol_types::SolEvent::encode_log_data(this)
1378            }
1379        }
1380    };
1381    #[derive(serde::Serialize, serde::Deserialize)]
1382    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1383    /**Event with signature `QuorumIndexUpdate(bytes32,uint8,uint32)` and selector `0x6ee1e4f4075f3d067176140d34e87874244dd273294c05b2218133e49a2ba6f6`.
1384```solidity
1385event QuorumIndexUpdate(bytes32 indexed operatorId, uint8 quorumNumber, uint32 newOperatorIndex);
1386```*/
1387    #[allow(
1388        non_camel_case_types,
1389        non_snake_case,
1390        clippy::pub_underscore_fields,
1391        clippy::style
1392    )]
1393    #[derive(Clone)]
1394    pub struct QuorumIndexUpdate {
1395        #[allow(missing_docs)]
1396        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
1397        #[allow(missing_docs)]
1398        pub quorumNumber: u8,
1399        #[allow(missing_docs)]
1400        pub newOperatorIndex: u32,
1401    }
1402    #[allow(
1403        non_camel_case_types,
1404        non_snake_case,
1405        clippy::pub_underscore_fields,
1406        clippy::style
1407    )]
1408    const _: () = {
1409        use alloy::sol_types as alloy_sol_types;
1410        #[automatically_derived]
1411        impl alloy_sol_types::SolEvent for QuorumIndexUpdate {
1412            type DataTuple<'a> = (
1413                alloy::sol_types::sol_data::Uint<8>,
1414                alloy::sol_types::sol_data::Uint<32>,
1415            );
1416            type DataToken<'a> = <Self::DataTuple<
1417                'a,
1418            > as alloy_sol_types::SolType>::Token<'a>;
1419            type TopicList = (
1420                alloy_sol_types::sol_data::FixedBytes<32>,
1421                alloy::sol_types::sol_data::FixedBytes<32>,
1422            );
1423            const SIGNATURE: &'static str = "QuorumIndexUpdate(bytes32,uint8,uint32)";
1424            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1425                110u8, 225u8, 228u8, 244u8, 7u8, 95u8, 61u8, 6u8, 113u8, 118u8, 20u8,
1426                13u8, 52u8, 232u8, 120u8, 116u8, 36u8, 77u8, 210u8, 115u8, 41u8, 76u8,
1427                5u8, 178u8, 33u8, 129u8, 51u8, 228u8, 154u8, 43u8, 166u8, 246u8,
1428            ]);
1429            const ANONYMOUS: bool = false;
1430            #[allow(unused_variables)]
1431            #[inline]
1432            fn new(
1433                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1434                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1435            ) -> Self {
1436                Self {
1437                    operatorId: topics.1,
1438                    quorumNumber: data.0,
1439                    newOperatorIndex: data.1,
1440                }
1441            }
1442            #[inline]
1443            fn check_signature(
1444                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1445            ) -> alloy_sol_types::Result<()> {
1446                if topics.0 != Self::SIGNATURE_HASH {
1447                    return Err(
1448                        alloy_sol_types::Error::invalid_event_signature_hash(
1449                            Self::SIGNATURE,
1450                            topics.0,
1451                            Self::SIGNATURE_HASH,
1452                        ),
1453                    );
1454                }
1455                Ok(())
1456            }
1457            #[inline]
1458            fn tokenize_body(&self) -> Self::DataToken<'_> {
1459                (
1460                    <alloy::sol_types::sol_data::Uint<
1461                        8,
1462                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
1463                    <alloy::sol_types::sol_data::Uint<
1464                        32,
1465                    > as alloy_sol_types::SolType>::tokenize(&self.newOperatorIndex),
1466                )
1467            }
1468            #[inline]
1469            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1470                (Self::SIGNATURE_HASH.into(), self.operatorId.clone())
1471            }
1472            #[inline]
1473            fn encode_topics_raw(
1474                &self,
1475                out: &mut [alloy_sol_types::abi::token::WordToken],
1476            ) -> alloy_sol_types::Result<()> {
1477                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1478                    return Err(alloy_sol_types::Error::Overrun);
1479                }
1480                out[0usize] = alloy_sol_types::abi::token::WordToken(
1481                    Self::SIGNATURE_HASH,
1482                );
1483                out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
1484                    32,
1485                > as alloy_sol_types::EventTopic>::encode_topic(&self.operatorId);
1486                Ok(())
1487            }
1488        }
1489        #[automatically_derived]
1490        impl alloy_sol_types::private::IntoLogData for QuorumIndexUpdate {
1491            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1492                From::from(self)
1493            }
1494            fn into_log_data(self) -> alloy_sol_types::private::LogData {
1495                From::from(&self)
1496            }
1497        }
1498        #[automatically_derived]
1499        impl From<&QuorumIndexUpdate> for alloy_sol_types::private::LogData {
1500            #[inline]
1501            fn from(this: &QuorumIndexUpdate) -> alloy_sol_types::private::LogData {
1502                alloy_sol_types::SolEvent::encode_log_data(this)
1503            }
1504        }
1505    };
1506    /**Constructor`.
1507```solidity
1508constructor(address _slashingRegistryCoordinator);
1509```*/
1510    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1511    #[derive(Clone)]
1512    pub struct constructorCall {
1513        #[allow(missing_docs)]
1514        pub _slashingRegistryCoordinator: alloy::sol_types::private::Address,
1515    }
1516    const _: () = {
1517        use alloy::sol_types as alloy_sol_types;
1518        {
1519            #[doc(hidden)]
1520            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1521            #[doc(hidden)]
1522            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1523            #[cfg(test)]
1524            #[allow(dead_code, unreachable_patterns)]
1525            fn _type_assertion(
1526                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1527            ) {
1528                match _t {
1529                    alloy_sol_types::private::AssertTypeEq::<
1530                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1531                    >(_) => {}
1532                }
1533            }
1534            #[automatically_derived]
1535            #[doc(hidden)]
1536            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
1537                fn from(value: constructorCall) -> Self {
1538                    (value._slashingRegistryCoordinator,)
1539                }
1540            }
1541            #[automatically_derived]
1542            #[doc(hidden)]
1543            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
1544                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1545                    Self {
1546                        _slashingRegistryCoordinator: tuple.0,
1547                    }
1548                }
1549            }
1550        }
1551        #[automatically_derived]
1552        impl alloy_sol_types::SolConstructor for constructorCall {
1553            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1554            type Token<'a> = <Self::Parameters<
1555                'a,
1556            > as alloy_sol_types::SolType>::Token<'a>;
1557            #[inline]
1558            fn new<'a>(
1559                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1560            ) -> Self {
1561                tuple.into()
1562            }
1563            #[inline]
1564            fn tokenize(&self) -> Self::Token<'_> {
1565                (
1566                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1567                        &self._slashingRegistryCoordinator,
1568                    ),
1569                )
1570            }
1571        }
1572    };
1573    #[derive(serde::Serialize, serde::Deserialize)]
1574    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1575    /**Function with signature `OPERATOR_DOES_NOT_EXIST_ID()` and selector `0xcaa3cd76`.
1576```solidity
1577function OPERATOR_DOES_NOT_EXIST_ID() external view returns (bytes32);
1578```*/
1579    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1580    #[derive(Clone)]
1581    pub struct OPERATOR_DOES_NOT_EXIST_IDCall;
1582    #[derive(serde::Serialize, serde::Deserialize)]
1583    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1584    ///Container type for the return parameters of the [`OPERATOR_DOES_NOT_EXIST_ID()`](OPERATOR_DOES_NOT_EXIST_IDCall) function.
1585    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1586    #[derive(Clone)]
1587    pub struct OPERATOR_DOES_NOT_EXIST_IDReturn {
1588        #[allow(missing_docs)]
1589        pub _0: alloy::sol_types::private::FixedBytes<32>,
1590    }
1591    #[allow(
1592        non_camel_case_types,
1593        non_snake_case,
1594        clippy::pub_underscore_fields,
1595        clippy::style
1596    )]
1597    const _: () = {
1598        use alloy::sol_types as alloy_sol_types;
1599        {
1600            #[doc(hidden)]
1601            type UnderlyingSolTuple<'a> = ();
1602            #[doc(hidden)]
1603            type UnderlyingRustTuple<'a> = ();
1604            #[cfg(test)]
1605            #[allow(dead_code, unreachable_patterns)]
1606            fn _type_assertion(
1607                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1608            ) {
1609                match _t {
1610                    alloy_sol_types::private::AssertTypeEq::<
1611                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1612                    >(_) => {}
1613                }
1614            }
1615            #[automatically_derived]
1616            #[doc(hidden)]
1617            impl ::core::convert::From<OPERATOR_DOES_NOT_EXIST_IDCall>
1618            for UnderlyingRustTuple<'_> {
1619                fn from(value: OPERATOR_DOES_NOT_EXIST_IDCall) -> Self {
1620                    ()
1621                }
1622            }
1623            #[automatically_derived]
1624            #[doc(hidden)]
1625            impl ::core::convert::From<UnderlyingRustTuple<'_>>
1626            for OPERATOR_DOES_NOT_EXIST_IDCall {
1627                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1628                    Self
1629                }
1630            }
1631        }
1632        {
1633            #[doc(hidden)]
1634            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1635            #[doc(hidden)]
1636            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1637            #[cfg(test)]
1638            #[allow(dead_code, unreachable_patterns)]
1639            fn _type_assertion(
1640                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1641            ) {
1642                match _t {
1643                    alloy_sol_types::private::AssertTypeEq::<
1644                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1645                    >(_) => {}
1646                }
1647            }
1648            #[automatically_derived]
1649            #[doc(hidden)]
1650            impl ::core::convert::From<OPERATOR_DOES_NOT_EXIST_IDReturn>
1651            for UnderlyingRustTuple<'_> {
1652                fn from(value: OPERATOR_DOES_NOT_EXIST_IDReturn) -> Self {
1653                    (value._0,)
1654                }
1655            }
1656            #[automatically_derived]
1657            #[doc(hidden)]
1658            impl ::core::convert::From<UnderlyingRustTuple<'_>>
1659            for OPERATOR_DOES_NOT_EXIST_IDReturn {
1660                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1661                    Self { _0: tuple.0 }
1662                }
1663            }
1664        }
1665        #[automatically_derived]
1666        impl alloy_sol_types::SolCall for OPERATOR_DOES_NOT_EXIST_IDCall {
1667            type Parameters<'a> = ();
1668            type Token<'a> = <Self::Parameters<
1669                'a,
1670            > as alloy_sol_types::SolType>::Token<'a>;
1671            type Return = alloy::sol_types::private::FixedBytes<32>;
1672            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1673            type ReturnToken<'a> = <Self::ReturnTuple<
1674                'a,
1675            > as alloy_sol_types::SolType>::Token<'a>;
1676            const SIGNATURE: &'static str = "OPERATOR_DOES_NOT_EXIST_ID()";
1677            const SELECTOR: [u8; 4] = [202u8, 163u8, 205u8, 118u8];
1678            #[inline]
1679            fn new<'a>(
1680                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1681            ) -> Self {
1682                tuple.into()
1683            }
1684            #[inline]
1685            fn tokenize(&self) -> Self::Token<'_> {
1686                ()
1687            }
1688            #[inline]
1689            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1690                (
1691                    <alloy::sol_types::sol_data::FixedBytes<
1692                        32,
1693                    > as alloy_sol_types::SolType>::tokenize(ret),
1694                )
1695            }
1696            #[inline]
1697            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1698                <Self::ReturnTuple<
1699                    '_,
1700                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1701                    .map(|r| {
1702                        let r: OPERATOR_DOES_NOT_EXIST_IDReturn = r.into();
1703                        r._0
1704                    })
1705            }
1706            #[inline]
1707            fn abi_decode_returns_validate(
1708                data: &[u8],
1709            ) -> alloy_sol_types::Result<Self::Return> {
1710                <Self::ReturnTuple<
1711                    '_,
1712                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1713                    .map(|r| {
1714                        let r: OPERATOR_DOES_NOT_EXIST_IDReturn = r.into();
1715                        r._0
1716                    })
1717            }
1718        }
1719    };
1720    #[derive(serde::Serialize, serde::Deserialize)]
1721    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1722    /**Function with signature `currentOperatorIndex(uint8,bytes32)` and selector `0xe2e68580`.
1723```solidity
1724function currentOperatorIndex(uint8, bytes32) external view returns (uint32);
1725```*/
1726    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1727    #[derive(Clone)]
1728    pub struct currentOperatorIndexCall {
1729        #[allow(missing_docs)]
1730        pub _0: u8,
1731        #[allow(missing_docs)]
1732        pub _1: alloy::sol_types::private::FixedBytes<32>,
1733    }
1734    #[derive(serde::Serialize, serde::Deserialize)]
1735    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1736    ///Container type for the return parameters of the [`currentOperatorIndex(uint8,bytes32)`](currentOperatorIndexCall) function.
1737    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1738    #[derive(Clone)]
1739    pub struct currentOperatorIndexReturn {
1740        #[allow(missing_docs)]
1741        pub _0: u32,
1742    }
1743    #[allow(
1744        non_camel_case_types,
1745        non_snake_case,
1746        clippy::pub_underscore_fields,
1747        clippy::style
1748    )]
1749    const _: () = {
1750        use alloy::sol_types as alloy_sol_types;
1751        {
1752            #[doc(hidden)]
1753            type UnderlyingSolTuple<'a> = (
1754                alloy::sol_types::sol_data::Uint<8>,
1755                alloy::sol_types::sol_data::FixedBytes<32>,
1756            );
1757            #[doc(hidden)]
1758            type UnderlyingRustTuple<'a> = (
1759                u8,
1760                alloy::sol_types::private::FixedBytes<32>,
1761            );
1762            #[cfg(test)]
1763            #[allow(dead_code, unreachable_patterns)]
1764            fn _type_assertion(
1765                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1766            ) {
1767                match _t {
1768                    alloy_sol_types::private::AssertTypeEq::<
1769                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1770                    >(_) => {}
1771                }
1772            }
1773            #[automatically_derived]
1774            #[doc(hidden)]
1775            impl ::core::convert::From<currentOperatorIndexCall>
1776            for UnderlyingRustTuple<'_> {
1777                fn from(value: currentOperatorIndexCall) -> Self {
1778                    (value._0, value._1)
1779                }
1780            }
1781            #[automatically_derived]
1782            #[doc(hidden)]
1783            impl ::core::convert::From<UnderlyingRustTuple<'_>>
1784            for currentOperatorIndexCall {
1785                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1786                    Self { _0: tuple.0, _1: tuple.1 }
1787                }
1788            }
1789        }
1790        {
1791            #[doc(hidden)]
1792            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
1793            #[doc(hidden)]
1794            type UnderlyingRustTuple<'a> = (u32,);
1795            #[cfg(test)]
1796            #[allow(dead_code, unreachable_patterns)]
1797            fn _type_assertion(
1798                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1799            ) {
1800                match _t {
1801                    alloy_sol_types::private::AssertTypeEq::<
1802                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1803                    >(_) => {}
1804                }
1805            }
1806            #[automatically_derived]
1807            #[doc(hidden)]
1808            impl ::core::convert::From<currentOperatorIndexReturn>
1809            for UnderlyingRustTuple<'_> {
1810                fn from(value: currentOperatorIndexReturn) -> Self {
1811                    (value._0,)
1812                }
1813            }
1814            #[automatically_derived]
1815            #[doc(hidden)]
1816            impl ::core::convert::From<UnderlyingRustTuple<'_>>
1817            for currentOperatorIndexReturn {
1818                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1819                    Self { _0: tuple.0 }
1820                }
1821            }
1822        }
1823        #[automatically_derived]
1824        impl alloy_sol_types::SolCall for currentOperatorIndexCall {
1825            type Parameters<'a> = (
1826                alloy::sol_types::sol_data::Uint<8>,
1827                alloy::sol_types::sol_data::FixedBytes<32>,
1828            );
1829            type Token<'a> = <Self::Parameters<
1830                'a,
1831            > as alloy_sol_types::SolType>::Token<'a>;
1832            type Return = u32;
1833            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
1834            type ReturnToken<'a> = <Self::ReturnTuple<
1835                'a,
1836            > as alloy_sol_types::SolType>::Token<'a>;
1837            const SIGNATURE: &'static str = "currentOperatorIndex(uint8,bytes32)";
1838            const SELECTOR: [u8; 4] = [226u8, 230u8, 133u8, 128u8];
1839            #[inline]
1840            fn new<'a>(
1841                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1842            ) -> Self {
1843                tuple.into()
1844            }
1845            #[inline]
1846            fn tokenize(&self) -> Self::Token<'_> {
1847                (
1848                    <alloy::sol_types::sol_data::Uint<
1849                        8,
1850                    > as alloy_sol_types::SolType>::tokenize(&self._0),
1851                    <alloy::sol_types::sol_data::FixedBytes<
1852                        32,
1853                    > as alloy_sol_types::SolType>::tokenize(&self._1),
1854                )
1855            }
1856            #[inline]
1857            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1858                (
1859                    <alloy::sol_types::sol_data::Uint<
1860                        32,
1861                    > as alloy_sol_types::SolType>::tokenize(ret),
1862                )
1863            }
1864            #[inline]
1865            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1866                <Self::ReturnTuple<
1867                    '_,
1868                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1869                    .map(|r| {
1870                        let r: currentOperatorIndexReturn = r.into();
1871                        r._0
1872                    })
1873            }
1874            #[inline]
1875            fn abi_decode_returns_validate(
1876                data: &[u8],
1877            ) -> alloy_sol_types::Result<Self::Return> {
1878                <Self::ReturnTuple<
1879                    '_,
1880                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1881                    .map(|r| {
1882                        let r: currentOperatorIndexReturn = r.into();
1883                        r._0
1884                    })
1885            }
1886        }
1887    };
1888    #[derive(serde::Serialize, serde::Deserialize)]
1889    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1890    /**Function with signature `deregisterOperator(bytes32,bytes)` and selector `0xbd29b8cd`.
1891```solidity
1892function deregisterOperator(bytes32 operatorId, bytes memory quorumNumbers) external;
1893```*/
1894    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1895    #[derive(Clone)]
1896    pub struct deregisterOperatorCall {
1897        #[allow(missing_docs)]
1898        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
1899        #[allow(missing_docs)]
1900        pub quorumNumbers: alloy::sol_types::private::Bytes,
1901    }
1902    ///Container type for the return parameters of the [`deregisterOperator(bytes32,bytes)`](deregisterOperatorCall) function.
1903    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1904    #[derive(Clone)]
1905    pub struct deregisterOperatorReturn {}
1906    #[allow(
1907        non_camel_case_types,
1908        non_snake_case,
1909        clippy::pub_underscore_fields,
1910        clippy::style
1911    )]
1912    const _: () = {
1913        use alloy::sol_types as alloy_sol_types;
1914        {
1915            #[doc(hidden)]
1916            type UnderlyingSolTuple<'a> = (
1917                alloy::sol_types::sol_data::FixedBytes<32>,
1918                alloy::sol_types::sol_data::Bytes,
1919            );
1920            #[doc(hidden)]
1921            type UnderlyingRustTuple<'a> = (
1922                alloy::sol_types::private::FixedBytes<32>,
1923                alloy::sol_types::private::Bytes,
1924            );
1925            #[cfg(test)]
1926            #[allow(dead_code, unreachable_patterns)]
1927            fn _type_assertion(
1928                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1929            ) {
1930                match _t {
1931                    alloy_sol_types::private::AssertTypeEq::<
1932                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1933                    >(_) => {}
1934                }
1935            }
1936            #[automatically_derived]
1937            #[doc(hidden)]
1938            impl ::core::convert::From<deregisterOperatorCall>
1939            for UnderlyingRustTuple<'_> {
1940                fn from(value: deregisterOperatorCall) -> Self {
1941                    (value.operatorId, value.quorumNumbers)
1942                }
1943            }
1944            #[automatically_derived]
1945            #[doc(hidden)]
1946            impl ::core::convert::From<UnderlyingRustTuple<'_>>
1947            for deregisterOperatorCall {
1948                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1949                    Self {
1950                        operatorId: tuple.0,
1951                        quorumNumbers: tuple.1,
1952                    }
1953                }
1954            }
1955        }
1956        {
1957            #[doc(hidden)]
1958            type UnderlyingSolTuple<'a> = ();
1959            #[doc(hidden)]
1960            type UnderlyingRustTuple<'a> = ();
1961            #[cfg(test)]
1962            #[allow(dead_code, unreachable_patterns)]
1963            fn _type_assertion(
1964                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1965            ) {
1966                match _t {
1967                    alloy_sol_types::private::AssertTypeEq::<
1968                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1969                    >(_) => {}
1970                }
1971            }
1972            #[automatically_derived]
1973            #[doc(hidden)]
1974            impl ::core::convert::From<deregisterOperatorReturn>
1975            for UnderlyingRustTuple<'_> {
1976                fn from(value: deregisterOperatorReturn) -> Self {
1977                    ()
1978                }
1979            }
1980            #[automatically_derived]
1981            #[doc(hidden)]
1982            impl ::core::convert::From<UnderlyingRustTuple<'_>>
1983            for deregisterOperatorReturn {
1984                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1985                    Self {}
1986                }
1987            }
1988        }
1989        impl deregisterOperatorReturn {
1990            fn _tokenize(
1991                &self,
1992            ) -> <deregisterOperatorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1993                ()
1994            }
1995        }
1996        #[automatically_derived]
1997        impl alloy_sol_types::SolCall for deregisterOperatorCall {
1998            type Parameters<'a> = (
1999                alloy::sol_types::sol_data::FixedBytes<32>,
2000                alloy::sol_types::sol_data::Bytes,
2001            );
2002            type Token<'a> = <Self::Parameters<
2003                'a,
2004            > as alloy_sol_types::SolType>::Token<'a>;
2005            type Return = deregisterOperatorReturn;
2006            type ReturnTuple<'a> = ();
2007            type ReturnToken<'a> = <Self::ReturnTuple<
2008                'a,
2009            > as alloy_sol_types::SolType>::Token<'a>;
2010            const SIGNATURE: &'static str = "deregisterOperator(bytes32,bytes)";
2011            const SELECTOR: [u8; 4] = [189u8, 41u8, 184u8, 205u8];
2012            #[inline]
2013            fn new<'a>(
2014                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2015            ) -> Self {
2016                tuple.into()
2017            }
2018            #[inline]
2019            fn tokenize(&self) -> Self::Token<'_> {
2020                (
2021                    <alloy::sol_types::sol_data::FixedBytes<
2022                        32,
2023                    > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
2024                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2025                        &self.quorumNumbers,
2026                    ),
2027                )
2028            }
2029            #[inline]
2030            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2031                deregisterOperatorReturn::_tokenize(ret)
2032            }
2033            #[inline]
2034            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2035                <Self::ReturnTuple<
2036                    '_,
2037                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2038                    .map(Into::into)
2039            }
2040            #[inline]
2041            fn abi_decode_returns_validate(
2042                data: &[u8],
2043            ) -> alloy_sol_types::Result<Self::Return> {
2044                <Self::ReturnTuple<
2045                    '_,
2046                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2047                    .map(Into::into)
2048            }
2049        }
2050    };
2051    #[derive(serde::Serialize, serde::Deserialize)]
2052    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2053    /**Function with signature `getLatestOperatorUpdate(uint8,uint32)` and selector `0x12d1d74d`.
2054```solidity
2055function getLatestOperatorUpdate(uint8 quorumNumber, uint32 operatorIndex) external view returns (IIndexRegistryTypes.OperatorUpdate memory);
2056```*/
2057    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2058    #[derive(Clone)]
2059    pub struct getLatestOperatorUpdateCall {
2060        #[allow(missing_docs)]
2061        pub quorumNumber: u8,
2062        #[allow(missing_docs)]
2063        pub operatorIndex: u32,
2064    }
2065    #[derive(serde::Serialize, serde::Deserialize)]
2066    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2067    ///Container type for the return parameters of the [`getLatestOperatorUpdate(uint8,uint32)`](getLatestOperatorUpdateCall) function.
2068    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2069    #[derive(Clone)]
2070    pub struct getLatestOperatorUpdateReturn {
2071        #[allow(missing_docs)]
2072        pub _0: <IIndexRegistryTypes::OperatorUpdate as alloy::sol_types::SolType>::RustType,
2073    }
2074    #[allow(
2075        non_camel_case_types,
2076        non_snake_case,
2077        clippy::pub_underscore_fields,
2078        clippy::style
2079    )]
2080    const _: () = {
2081        use alloy::sol_types as alloy_sol_types;
2082        {
2083            #[doc(hidden)]
2084            type UnderlyingSolTuple<'a> = (
2085                alloy::sol_types::sol_data::Uint<8>,
2086                alloy::sol_types::sol_data::Uint<32>,
2087            );
2088            #[doc(hidden)]
2089            type UnderlyingRustTuple<'a> = (u8, u32);
2090            #[cfg(test)]
2091            #[allow(dead_code, unreachable_patterns)]
2092            fn _type_assertion(
2093                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2094            ) {
2095                match _t {
2096                    alloy_sol_types::private::AssertTypeEq::<
2097                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2098                    >(_) => {}
2099                }
2100            }
2101            #[automatically_derived]
2102            #[doc(hidden)]
2103            impl ::core::convert::From<getLatestOperatorUpdateCall>
2104            for UnderlyingRustTuple<'_> {
2105                fn from(value: getLatestOperatorUpdateCall) -> Self {
2106                    (value.quorumNumber, value.operatorIndex)
2107                }
2108            }
2109            #[automatically_derived]
2110            #[doc(hidden)]
2111            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2112            for getLatestOperatorUpdateCall {
2113                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2114                    Self {
2115                        quorumNumber: tuple.0,
2116                        operatorIndex: tuple.1,
2117                    }
2118                }
2119            }
2120        }
2121        {
2122            #[doc(hidden)]
2123            type UnderlyingSolTuple<'a> = (IIndexRegistryTypes::OperatorUpdate,);
2124            #[doc(hidden)]
2125            type UnderlyingRustTuple<'a> = (
2126                <IIndexRegistryTypes::OperatorUpdate as alloy::sol_types::SolType>::RustType,
2127            );
2128            #[cfg(test)]
2129            #[allow(dead_code, unreachable_patterns)]
2130            fn _type_assertion(
2131                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2132            ) {
2133                match _t {
2134                    alloy_sol_types::private::AssertTypeEq::<
2135                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2136                    >(_) => {}
2137                }
2138            }
2139            #[automatically_derived]
2140            #[doc(hidden)]
2141            impl ::core::convert::From<getLatestOperatorUpdateReturn>
2142            for UnderlyingRustTuple<'_> {
2143                fn from(value: getLatestOperatorUpdateReturn) -> Self {
2144                    (value._0,)
2145                }
2146            }
2147            #[automatically_derived]
2148            #[doc(hidden)]
2149            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2150            for getLatestOperatorUpdateReturn {
2151                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2152                    Self { _0: tuple.0 }
2153                }
2154            }
2155        }
2156        #[automatically_derived]
2157        impl alloy_sol_types::SolCall for getLatestOperatorUpdateCall {
2158            type Parameters<'a> = (
2159                alloy::sol_types::sol_data::Uint<8>,
2160                alloy::sol_types::sol_data::Uint<32>,
2161            );
2162            type Token<'a> = <Self::Parameters<
2163                'a,
2164            > as alloy_sol_types::SolType>::Token<'a>;
2165            type Return = <IIndexRegistryTypes::OperatorUpdate as alloy::sol_types::SolType>::RustType;
2166            type ReturnTuple<'a> = (IIndexRegistryTypes::OperatorUpdate,);
2167            type ReturnToken<'a> = <Self::ReturnTuple<
2168                'a,
2169            > as alloy_sol_types::SolType>::Token<'a>;
2170            const SIGNATURE: &'static str = "getLatestOperatorUpdate(uint8,uint32)";
2171            const SELECTOR: [u8; 4] = [18u8, 209u8, 215u8, 77u8];
2172            #[inline]
2173            fn new<'a>(
2174                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2175            ) -> Self {
2176                tuple.into()
2177            }
2178            #[inline]
2179            fn tokenize(&self) -> Self::Token<'_> {
2180                (
2181                    <alloy::sol_types::sol_data::Uint<
2182                        8,
2183                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
2184                    <alloy::sol_types::sol_data::Uint<
2185                        32,
2186                    > as alloy_sol_types::SolType>::tokenize(&self.operatorIndex),
2187                )
2188            }
2189            #[inline]
2190            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2191                (
2192                    <IIndexRegistryTypes::OperatorUpdate as alloy_sol_types::SolType>::tokenize(
2193                        ret,
2194                    ),
2195                )
2196            }
2197            #[inline]
2198            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2199                <Self::ReturnTuple<
2200                    '_,
2201                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2202                    .map(|r| {
2203                        let r: getLatestOperatorUpdateReturn = r.into();
2204                        r._0
2205                    })
2206            }
2207            #[inline]
2208            fn abi_decode_returns_validate(
2209                data: &[u8],
2210            ) -> alloy_sol_types::Result<Self::Return> {
2211                <Self::ReturnTuple<
2212                    '_,
2213                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2214                    .map(|r| {
2215                        let r: getLatestOperatorUpdateReturn = r.into();
2216                        r._0
2217                    })
2218            }
2219        }
2220    };
2221    #[derive(serde::Serialize, serde::Deserialize)]
2222    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2223    /**Function with signature `getLatestQuorumUpdate(uint8)` and selector `0x8121906f`.
2224```solidity
2225function getLatestQuorumUpdate(uint8 quorumNumber) external view returns (IIndexRegistryTypes.QuorumUpdate memory);
2226```*/
2227    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2228    #[derive(Clone)]
2229    pub struct getLatestQuorumUpdateCall {
2230        #[allow(missing_docs)]
2231        pub quorumNumber: u8,
2232    }
2233    #[derive(serde::Serialize, serde::Deserialize)]
2234    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2235    ///Container type for the return parameters of the [`getLatestQuorumUpdate(uint8)`](getLatestQuorumUpdateCall) function.
2236    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2237    #[derive(Clone)]
2238    pub struct getLatestQuorumUpdateReturn {
2239        #[allow(missing_docs)]
2240        pub _0: <IIndexRegistryTypes::QuorumUpdate as alloy::sol_types::SolType>::RustType,
2241    }
2242    #[allow(
2243        non_camel_case_types,
2244        non_snake_case,
2245        clippy::pub_underscore_fields,
2246        clippy::style
2247    )]
2248    const _: () = {
2249        use alloy::sol_types as alloy_sol_types;
2250        {
2251            #[doc(hidden)]
2252            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
2253            #[doc(hidden)]
2254            type UnderlyingRustTuple<'a> = (u8,);
2255            #[cfg(test)]
2256            #[allow(dead_code, unreachable_patterns)]
2257            fn _type_assertion(
2258                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2259            ) {
2260                match _t {
2261                    alloy_sol_types::private::AssertTypeEq::<
2262                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2263                    >(_) => {}
2264                }
2265            }
2266            #[automatically_derived]
2267            #[doc(hidden)]
2268            impl ::core::convert::From<getLatestQuorumUpdateCall>
2269            for UnderlyingRustTuple<'_> {
2270                fn from(value: getLatestQuorumUpdateCall) -> Self {
2271                    (value.quorumNumber,)
2272                }
2273            }
2274            #[automatically_derived]
2275            #[doc(hidden)]
2276            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2277            for getLatestQuorumUpdateCall {
2278                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2279                    Self { quorumNumber: tuple.0 }
2280                }
2281            }
2282        }
2283        {
2284            #[doc(hidden)]
2285            type UnderlyingSolTuple<'a> = (IIndexRegistryTypes::QuorumUpdate,);
2286            #[doc(hidden)]
2287            type UnderlyingRustTuple<'a> = (
2288                <IIndexRegistryTypes::QuorumUpdate as alloy::sol_types::SolType>::RustType,
2289            );
2290            #[cfg(test)]
2291            #[allow(dead_code, unreachable_patterns)]
2292            fn _type_assertion(
2293                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2294            ) {
2295                match _t {
2296                    alloy_sol_types::private::AssertTypeEq::<
2297                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2298                    >(_) => {}
2299                }
2300            }
2301            #[automatically_derived]
2302            #[doc(hidden)]
2303            impl ::core::convert::From<getLatestQuorumUpdateReturn>
2304            for UnderlyingRustTuple<'_> {
2305                fn from(value: getLatestQuorumUpdateReturn) -> Self {
2306                    (value._0,)
2307                }
2308            }
2309            #[automatically_derived]
2310            #[doc(hidden)]
2311            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2312            for getLatestQuorumUpdateReturn {
2313                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2314                    Self { _0: tuple.0 }
2315                }
2316            }
2317        }
2318        #[automatically_derived]
2319        impl alloy_sol_types::SolCall for getLatestQuorumUpdateCall {
2320            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
2321            type Token<'a> = <Self::Parameters<
2322                'a,
2323            > as alloy_sol_types::SolType>::Token<'a>;
2324            type Return = <IIndexRegistryTypes::QuorumUpdate as alloy::sol_types::SolType>::RustType;
2325            type ReturnTuple<'a> = (IIndexRegistryTypes::QuorumUpdate,);
2326            type ReturnToken<'a> = <Self::ReturnTuple<
2327                'a,
2328            > as alloy_sol_types::SolType>::Token<'a>;
2329            const SIGNATURE: &'static str = "getLatestQuorumUpdate(uint8)";
2330            const SELECTOR: [u8; 4] = [129u8, 33u8, 144u8, 111u8];
2331            #[inline]
2332            fn new<'a>(
2333                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2334            ) -> Self {
2335                tuple.into()
2336            }
2337            #[inline]
2338            fn tokenize(&self) -> Self::Token<'_> {
2339                (
2340                    <alloy::sol_types::sol_data::Uint<
2341                        8,
2342                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
2343                )
2344            }
2345            #[inline]
2346            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2347                (
2348                    <IIndexRegistryTypes::QuorumUpdate as alloy_sol_types::SolType>::tokenize(
2349                        ret,
2350                    ),
2351                )
2352            }
2353            #[inline]
2354            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2355                <Self::ReturnTuple<
2356                    '_,
2357                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2358                    .map(|r| {
2359                        let r: getLatestQuorumUpdateReturn = r.into();
2360                        r._0
2361                    })
2362            }
2363            #[inline]
2364            fn abi_decode_returns_validate(
2365                data: &[u8],
2366            ) -> alloy_sol_types::Result<Self::Return> {
2367                <Self::ReturnTuple<
2368                    '_,
2369                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2370                    .map(|r| {
2371                        let r: getLatestQuorumUpdateReturn = r.into();
2372                        r._0
2373                    })
2374            }
2375        }
2376    };
2377    #[derive(serde::Serialize, serde::Deserialize)]
2378    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2379    /**Function with signature `getOperatorListAtBlockNumber(uint8,uint32)` and selector `0x89026245`.
2380```solidity
2381function getOperatorListAtBlockNumber(uint8 quorumNumber, uint32 blockNumber) external view returns (bytes32[] memory);
2382```*/
2383    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2384    #[derive(Clone)]
2385    pub struct getOperatorListAtBlockNumberCall {
2386        #[allow(missing_docs)]
2387        pub quorumNumber: u8,
2388        #[allow(missing_docs)]
2389        pub blockNumber: u32,
2390    }
2391    #[derive(serde::Serialize, serde::Deserialize)]
2392    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2393    ///Container type for the return parameters of the [`getOperatorListAtBlockNumber(uint8,uint32)`](getOperatorListAtBlockNumberCall) function.
2394    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2395    #[derive(Clone)]
2396    pub struct getOperatorListAtBlockNumberReturn {
2397        #[allow(missing_docs)]
2398        pub _0: alloy::sol_types::private::Vec<
2399            alloy::sol_types::private::FixedBytes<32>,
2400        >,
2401    }
2402    #[allow(
2403        non_camel_case_types,
2404        non_snake_case,
2405        clippy::pub_underscore_fields,
2406        clippy::style
2407    )]
2408    const _: () = {
2409        use alloy::sol_types as alloy_sol_types;
2410        {
2411            #[doc(hidden)]
2412            type UnderlyingSolTuple<'a> = (
2413                alloy::sol_types::sol_data::Uint<8>,
2414                alloy::sol_types::sol_data::Uint<32>,
2415            );
2416            #[doc(hidden)]
2417            type UnderlyingRustTuple<'a> = (u8, u32);
2418            #[cfg(test)]
2419            #[allow(dead_code, unreachable_patterns)]
2420            fn _type_assertion(
2421                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2422            ) {
2423                match _t {
2424                    alloy_sol_types::private::AssertTypeEq::<
2425                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2426                    >(_) => {}
2427                }
2428            }
2429            #[automatically_derived]
2430            #[doc(hidden)]
2431            impl ::core::convert::From<getOperatorListAtBlockNumberCall>
2432            for UnderlyingRustTuple<'_> {
2433                fn from(value: getOperatorListAtBlockNumberCall) -> Self {
2434                    (value.quorumNumber, value.blockNumber)
2435                }
2436            }
2437            #[automatically_derived]
2438            #[doc(hidden)]
2439            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2440            for getOperatorListAtBlockNumberCall {
2441                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2442                    Self {
2443                        quorumNumber: tuple.0,
2444                        blockNumber: tuple.1,
2445                    }
2446                }
2447            }
2448        }
2449        {
2450            #[doc(hidden)]
2451            type UnderlyingSolTuple<'a> = (
2452                alloy::sol_types::sol_data::Array<
2453                    alloy::sol_types::sol_data::FixedBytes<32>,
2454                >,
2455            );
2456            #[doc(hidden)]
2457            type UnderlyingRustTuple<'a> = (
2458                alloy::sol_types::private::Vec<
2459                    alloy::sol_types::private::FixedBytes<32>,
2460                >,
2461            );
2462            #[cfg(test)]
2463            #[allow(dead_code, unreachable_patterns)]
2464            fn _type_assertion(
2465                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2466            ) {
2467                match _t {
2468                    alloy_sol_types::private::AssertTypeEq::<
2469                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2470                    >(_) => {}
2471                }
2472            }
2473            #[automatically_derived]
2474            #[doc(hidden)]
2475            impl ::core::convert::From<getOperatorListAtBlockNumberReturn>
2476            for UnderlyingRustTuple<'_> {
2477                fn from(value: getOperatorListAtBlockNumberReturn) -> Self {
2478                    (value._0,)
2479                }
2480            }
2481            #[automatically_derived]
2482            #[doc(hidden)]
2483            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2484            for getOperatorListAtBlockNumberReturn {
2485                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2486                    Self { _0: tuple.0 }
2487                }
2488            }
2489        }
2490        #[automatically_derived]
2491        impl alloy_sol_types::SolCall for getOperatorListAtBlockNumberCall {
2492            type Parameters<'a> = (
2493                alloy::sol_types::sol_data::Uint<8>,
2494                alloy::sol_types::sol_data::Uint<32>,
2495            );
2496            type Token<'a> = <Self::Parameters<
2497                'a,
2498            > as alloy_sol_types::SolType>::Token<'a>;
2499            type Return = alloy::sol_types::private::Vec<
2500                alloy::sol_types::private::FixedBytes<32>,
2501            >;
2502            type ReturnTuple<'a> = (
2503                alloy::sol_types::sol_data::Array<
2504                    alloy::sol_types::sol_data::FixedBytes<32>,
2505                >,
2506            );
2507            type ReturnToken<'a> = <Self::ReturnTuple<
2508                'a,
2509            > as alloy_sol_types::SolType>::Token<'a>;
2510            const SIGNATURE: &'static str = "getOperatorListAtBlockNumber(uint8,uint32)";
2511            const SELECTOR: [u8; 4] = [137u8, 2u8, 98u8, 69u8];
2512            #[inline]
2513            fn new<'a>(
2514                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2515            ) -> Self {
2516                tuple.into()
2517            }
2518            #[inline]
2519            fn tokenize(&self) -> Self::Token<'_> {
2520                (
2521                    <alloy::sol_types::sol_data::Uint<
2522                        8,
2523                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
2524                    <alloy::sol_types::sol_data::Uint<
2525                        32,
2526                    > as alloy_sol_types::SolType>::tokenize(&self.blockNumber),
2527                )
2528            }
2529            #[inline]
2530            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2531                (
2532                    <alloy::sol_types::sol_data::Array<
2533                        alloy::sol_types::sol_data::FixedBytes<32>,
2534                    > as alloy_sol_types::SolType>::tokenize(ret),
2535                )
2536            }
2537            #[inline]
2538            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2539                <Self::ReturnTuple<
2540                    '_,
2541                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2542                    .map(|r| {
2543                        let r: getOperatorListAtBlockNumberReturn = r.into();
2544                        r._0
2545                    })
2546            }
2547            #[inline]
2548            fn abi_decode_returns_validate(
2549                data: &[u8],
2550            ) -> alloy_sol_types::Result<Self::Return> {
2551                <Self::ReturnTuple<
2552                    '_,
2553                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2554                    .map(|r| {
2555                        let r: getOperatorListAtBlockNumberReturn = r.into();
2556                        r._0
2557                    })
2558            }
2559        }
2560    };
2561    #[derive(serde::Serialize, serde::Deserialize)]
2562    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2563    /**Function with signature `getOperatorUpdateAtIndex(uint8,uint32,uint32)` and selector `0x2ed583e5`.
2564```solidity
2565function getOperatorUpdateAtIndex(uint8 quorumNumber, uint32 operatorIndex, uint32 arrayIndex) external view returns (IIndexRegistryTypes.OperatorUpdate memory);
2566```*/
2567    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2568    #[derive(Clone)]
2569    pub struct getOperatorUpdateAtIndexCall {
2570        #[allow(missing_docs)]
2571        pub quorumNumber: u8,
2572        #[allow(missing_docs)]
2573        pub operatorIndex: u32,
2574        #[allow(missing_docs)]
2575        pub arrayIndex: u32,
2576    }
2577    #[derive(serde::Serialize, serde::Deserialize)]
2578    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2579    ///Container type for the return parameters of the [`getOperatorUpdateAtIndex(uint8,uint32,uint32)`](getOperatorUpdateAtIndexCall) function.
2580    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2581    #[derive(Clone)]
2582    pub struct getOperatorUpdateAtIndexReturn {
2583        #[allow(missing_docs)]
2584        pub _0: <IIndexRegistryTypes::OperatorUpdate as alloy::sol_types::SolType>::RustType,
2585    }
2586    #[allow(
2587        non_camel_case_types,
2588        non_snake_case,
2589        clippy::pub_underscore_fields,
2590        clippy::style
2591    )]
2592    const _: () = {
2593        use alloy::sol_types as alloy_sol_types;
2594        {
2595            #[doc(hidden)]
2596            type UnderlyingSolTuple<'a> = (
2597                alloy::sol_types::sol_data::Uint<8>,
2598                alloy::sol_types::sol_data::Uint<32>,
2599                alloy::sol_types::sol_data::Uint<32>,
2600            );
2601            #[doc(hidden)]
2602            type UnderlyingRustTuple<'a> = (u8, u32, u32);
2603            #[cfg(test)]
2604            #[allow(dead_code, unreachable_patterns)]
2605            fn _type_assertion(
2606                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2607            ) {
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<getOperatorUpdateAtIndexCall>
2617            for UnderlyingRustTuple<'_> {
2618                fn from(value: getOperatorUpdateAtIndexCall) -> Self {
2619                    (value.quorumNumber, value.operatorIndex, value.arrayIndex)
2620                }
2621            }
2622            #[automatically_derived]
2623            #[doc(hidden)]
2624            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2625            for getOperatorUpdateAtIndexCall {
2626                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2627                    Self {
2628                        quorumNumber: tuple.0,
2629                        operatorIndex: tuple.1,
2630                        arrayIndex: tuple.2,
2631                    }
2632                }
2633            }
2634        }
2635        {
2636            #[doc(hidden)]
2637            type UnderlyingSolTuple<'a> = (IIndexRegistryTypes::OperatorUpdate,);
2638            #[doc(hidden)]
2639            type UnderlyingRustTuple<'a> = (
2640                <IIndexRegistryTypes::OperatorUpdate as alloy::sol_types::SolType>::RustType,
2641            );
2642            #[cfg(test)]
2643            #[allow(dead_code, unreachable_patterns)]
2644            fn _type_assertion(
2645                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2646            ) {
2647                match _t {
2648                    alloy_sol_types::private::AssertTypeEq::<
2649                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2650                    >(_) => {}
2651                }
2652            }
2653            #[automatically_derived]
2654            #[doc(hidden)]
2655            impl ::core::convert::From<getOperatorUpdateAtIndexReturn>
2656            for UnderlyingRustTuple<'_> {
2657                fn from(value: getOperatorUpdateAtIndexReturn) -> Self {
2658                    (value._0,)
2659                }
2660            }
2661            #[automatically_derived]
2662            #[doc(hidden)]
2663            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2664            for getOperatorUpdateAtIndexReturn {
2665                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2666                    Self { _0: tuple.0 }
2667                }
2668            }
2669        }
2670        #[automatically_derived]
2671        impl alloy_sol_types::SolCall for getOperatorUpdateAtIndexCall {
2672            type Parameters<'a> = (
2673                alloy::sol_types::sol_data::Uint<8>,
2674                alloy::sol_types::sol_data::Uint<32>,
2675                alloy::sol_types::sol_data::Uint<32>,
2676            );
2677            type Token<'a> = <Self::Parameters<
2678                'a,
2679            > as alloy_sol_types::SolType>::Token<'a>;
2680            type Return = <IIndexRegistryTypes::OperatorUpdate as alloy::sol_types::SolType>::RustType;
2681            type ReturnTuple<'a> = (IIndexRegistryTypes::OperatorUpdate,);
2682            type ReturnToken<'a> = <Self::ReturnTuple<
2683                'a,
2684            > as alloy_sol_types::SolType>::Token<'a>;
2685            const SIGNATURE: &'static str = "getOperatorUpdateAtIndex(uint8,uint32,uint32)";
2686            const SELECTOR: [u8; 4] = [46u8, 213u8, 131u8, 229u8];
2687            #[inline]
2688            fn new<'a>(
2689                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2690            ) -> Self {
2691                tuple.into()
2692            }
2693            #[inline]
2694            fn tokenize(&self) -> Self::Token<'_> {
2695                (
2696                    <alloy::sol_types::sol_data::Uint<
2697                        8,
2698                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
2699                    <alloy::sol_types::sol_data::Uint<
2700                        32,
2701                    > as alloy_sol_types::SolType>::tokenize(&self.operatorIndex),
2702                    <alloy::sol_types::sol_data::Uint<
2703                        32,
2704                    > as alloy_sol_types::SolType>::tokenize(&self.arrayIndex),
2705                )
2706            }
2707            #[inline]
2708            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2709                (
2710                    <IIndexRegistryTypes::OperatorUpdate as alloy_sol_types::SolType>::tokenize(
2711                        ret,
2712                    ),
2713                )
2714            }
2715            #[inline]
2716            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2717                <Self::ReturnTuple<
2718                    '_,
2719                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2720                    .map(|r| {
2721                        let r: getOperatorUpdateAtIndexReturn = r.into();
2722                        r._0
2723                    })
2724            }
2725            #[inline]
2726            fn abi_decode_returns_validate(
2727                data: &[u8],
2728            ) -> alloy_sol_types::Result<Self::Return> {
2729                <Self::ReturnTuple<
2730                    '_,
2731                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2732                    .map(|r| {
2733                        let r: getOperatorUpdateAtIndexReturn = r.into();
2734                        r._0
2735                    })
2736            }
2737        }
2738    };
2739    #[derive(serde::Serialize, serde::Deserialize)]
2740    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2741    /**Function with signature `getQuorumUpdateAtIndex(uint8,uint32)` and selector `0xa48bb0ac`.
2742```solidity
2743function getQuorumUpdateAtIndex(uint8 quorumNumber, uint32 quorumIndex) external view returns (IIndexRegistryTypes.QuorumUpdate memory);
2744```*/
2745    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2746    #[derive(Clone)]
2747    pub struct getQuorumUpdateAtIndexCall {
2748        #[allow(missing_docs)]
2749        pub quorumNumber: u8,
2750        #[allow(missing_docs)]
2751        pub quorumIndex: u32,
2752    }
2753    #[derive(serde::Serialize, serde::Deserialize)]
2754    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2755    ///Container type for the return parameters of the [`getQuorumUpdateAtIndex(uint8,uint32)`](getQuorumUpdateAtIndexCall) function.
2756    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2757    #[derive(Clone)]
2758    pub struct getQuorumUpdateAtIndexReturn {
2759        #[allow(missing_docs)]
2760        pub _0: <IIndexRegistryTypes::QuorumUpdate as alloy::sol_types::SolType>::RustType,
2761    }
2762    #[allow(
2763        non_camel_case_types,
2764        non_snake_case,
2765        clippy::pub_underscore_fields,
2766        clippy::style
2767    )]
2768    const _: () = {
2769        use alloy::sol_types as alloy_sol_types;
2770        {
2771            #[doc(hidden)]
2772            type UnderlyingSolTuple<'a> = (
2773                alloy::sol_types::sol_data::Uint<8>,
2774                alloy::sol_types::sol_data::Uint<32>,
2775            );
2776            #[doc(hidden)]
2777            type UnderlyingRustTuple<'a> = (u8, u32);
2778            #[cfg(test)]
2779            #[allow(dead_code, unreachable_patterns)]
2780            fn _type_assertion(
2781                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2782            ) {
2783                match _t {
2784                    alloy_sol_types::private::AssertTypeEq::<
2785                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2786                    >(_) => {}
2787                }
2788            }
2789            #[automatically_derived]
2790            #[doc(hidden)]
2791            impl ::core::convert::From<getQuorumUpdateAtIndexCall>
2792            for UnderlyingRustTuple<'_> {
2793                fn from(value: getQuorumUpdateAtIndexCall) -> Self {
2794                    (value.quorumNumber, value.quorumIndex)
2795                }
2796            }
2797            #[automatically_derived]
2798            #[doc(hidden)]
2799            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2800            for getQuorumUpdateAtIndexCall {
2801                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2802                    Self {
2803                        quorumNumber: tuple.0,
2804                        quorumIndex: tuple.1,
2805                    }
2806                }
2807            }
2808        }
2809        {
2810            #[doc(hidden)]
2811            type UnderlyingSolTuple<'a> = (IIndexRegistryTypes::QuorumUpdate,);
2812            #[doc(hidden)]
2813            type UnderlyingRustTuple<'a> = (
2814                <IIndexRegistryTypes::QuorumUpdate as alloy::sol_types::SolType>::RustType,
2815            );
2816            #[cfg(test)]
2817            #[allow(dead_code, unreachable_patterns)]
2818            fn _type_assertion(
2819                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2820            ) {
2821                match _t {
2822                    alloy_sol_types::private::AssertTypeEq::<
2823                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2824                    >(_) => {}
2825                }
2826            }
2827            #[automatically_derived]
2828            #[doc(hidden)]
2829            impl ::core::convert::From<getQuorumUpdateAtIndexReturn>
2830            for UnderlyingRustTuple<'_> {
2831                fn from(value: getQuorumUpdateAtIndexReturn) -> Self {
2832                    (value._0,)
2833                }
2834            }
2835            #[automatically_derived]
2836            #[doc(hidden)]
2837            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2838            for getQuorumUpdateAtIndexReturn {
2839                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2840                    Self { _0: tuple.0 }
2841                }
2842            }
2843        }
2844        #[automatically_derived]
2845        impl alloy_sol_types::SolCall for getQuorumUpdateAtIndexCall {
2846            type Parameters<'a> = (
2847                alloy::sol_types::sol_data::Uint<8>,
2848                alloy::sol_types::sol_data::Uint<32>,
2849            );
2850            type Token<'a> = <Self::Parameters<
2851                'a,
2852            > as alloy_sol_types::SolType>::Token<'a>;
2853            type Return = <IIndexRegistryTypes::QuorumUpdate as alloy::sol_types::SolType>::RustType;
2854            type ReturnTuple<'a> = (IIndexRegistryTypes::QuorumUpdate,);
2855            type ReturnToken<'a> = <Self::ReturnTuple<
2856                'a,
2857            > as alloy_sol_types::SolType>::Token<'a>;
2858            const SIGNATURE: &'static str = "getQuorumUpdateAtIndex(uint8,uint32)";
2859            const SELECTOR: [u8; 4] = [164u8, 139u8, 176u8, 172u8];
2860            #[inline]
2861            fn new<'a>(
2862                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2863            ) -> Self {
2864                tuple.into()
2865            }
2866            #[inline]
2867            fn tokenize(&self) -> Self::Token<'_> {
2868                (
2869                    <alloy::sol_types::sol_data::Uint<
2870                        8,
2871                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
2872                    <alloy::sol_types::sol_data::Uint<
2873                        32,
2874                    > as alloy_sol_types::SolType>::tokenize(&self.quorumIndex),
2875                )
2876            }
2877            #[inline]
2878            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2879                (
2880                    <IIndexRegistryTypes::QuorumUpdate as alloy_sol_types::SolType>::tokenize(
2881                        ret,
2882                    ),
2883                )
2884            }
2885            #[inline]
2886            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2887                <Self::ReturnTuple<
2888                    '_,
2889                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2890                    .map(|r| {
2891                        let r: getQuorumUpdateAtIndexReturn = r.into();
2892                        r._0
2893                    })
2894            }
2895            #[inline]
2896            fn abi_decode_returns_validate(
2897                data: &[u8],
2898            ) -> alloy_sol_types::Result<Self::Return> {
2899                <Self::ReturnTuple<
2900                    '_,
2901                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2902                    .map(|r| {
2903                        let r: getQuorumUpdateAtIndexReturn = r.into();
2904                        r._0
2905                    })
2906            }
2907        }
2908    };
2909    #[derive(serde::Serialize, serde::Deserialize)]
2910    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2911    /**Function with signature `initializeQuorum(uint8)` and selector `0x26d941f2`.
2912```solidity
2913function initializeQuorum(uint8 quorumNumber) external;
2914```*/
2915    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2916    #[derive(Clone)]
2917    pub struct initializeQuorumCall {
2918        #[allow(missing_docs)]
2919        pub quorumNumber: u8,
2920    }
2921    ///Container type for the return parameters of the [`initializeQuorum(uint8)`](initializeQuorumCall) function.
2922    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2923    #[derive(Clone)]
2924    pub struct initializeQuorumReturn {}
2925    #[allow(
2926        non_camel_case_types,
2927        non_snake_case,
2928        clippy::pub_underscore_fields,
2929        clippy::style
2930    )]
2931    const _: () = {
2932        use alloy::sol_types as alloy_sol_types;
2933        {
2934            #[doc(hidden)]
2935            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
2936            #[doc(hidden)]
2937            type UnderlyingRustTuple<'a> = (u8,);
2938            #[cfg(test)]
2939            #[allow(dead_code, unreachable_patterns)]
2940            fn _type_assertion(
2941                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2942            ) {
2943                match _t {
2944                    alloy_sol_types::private::AssertTypeEq::<
2945                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2946                    >(_) => {}
2947                }
2948            }
2949            #[automatically_derived]
2950            #[doc(hidden)]
2951            impl ::core::convert::From<initializeQuorumCall>
2952            for UnderlyingRustTuple<'_> {
2953                fn from(value: initializeQuorumCall) -> Self {
2954                    (value.quorumNumber,)
2955                }
2956            }
2957            #[automatically_derived]
2958            #[doc(hidden)]
2959            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2960            for initializeQuorumCall {
2961                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2962                    Self { quorumNumber: tuple.0 }
2963                }
2964            }
2965        }
2966        {
2967            #[doc(hidden)]
2968            type UnderlyingSolTuple<'a> = ();
2969            #[doc(hidden)]
2970            type UnderlyingRustTuple<'a> = ();
2971            #[cfg(test)]
2972            #[allow(dead_code, unreachable_patterns)]
2973            fn _type_assertion(
2974                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2975            ) {
2976                match _t {
2977                    alloy_sol_types::private::AssertTypeEq::<
2978                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2979                    >(_) => {}
2980                }
2981            }
2982            #[automatically_derived]
2983            #[doc(hidden)]
2984            impl ::core::convert::From<initializeQuorumReturn>
2985            for UnderlyingRustTuple<'_> {
2986                fn from(value: initializeQuorumReturn) -> Self {
2987                    ()
2988                }
2989            }
2990            #[automatically_derived]
2991            #[doc(hidden)]
2992            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2993            for initializeQuorumReturn {
2994                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2995                    Self {}
2996                }
2997            }
2998        }
2999        impl initializeQuorumReturn {
3000            fn _tokenize(
3001                &self,
3002            ) -> <initializeQuorumCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3003                ()
3004            }
3005        }
3006        #[automatically_derived]
3007        impl alloy_sol_types::SolCall for initializeQuorumCall {
3008            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3009            type Token<'a> = <Self::Parameters<
3010                'a,
3011            > as alloy_sol_types::SolType>::Token<'a>;
3012            type Return = initializeQuorumReturn;
3013            type ReturnTuple<'a> = ();
3014            type ReturnToken<'a> = <Self::ReturnTuple<
3015                'a,
3016            > as alloy_sol_types::SolType>::Token<'a>;
3017            const SIGNATURE: &'static str = "initializeQuorum(uint8)";
3018            const SELECTOR: [u8; 4] = [38u8, 217u8, 65u8, 242u8];
3019            #[inline]
3020            fn new<'a>(
3021                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3022            ) -> Self {
3023                tuple.into()
3024            }
3025            #[inline]
3026            fn tokenize(&self) -> Self::Token<'_> {
3027                (
3028                    <alloy::sol_types::sol_data::Uint<
3029                        8,
3030                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
3031                )
3032            }
3033            #[inline]
3034            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3035                initializeQuorumReturn::_tokenize(ret)
3036            }
3037            #[inline]
3038            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3039                <Self::ReturnTuple<
3040                    '_,
3041                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3042                    .map(Into::into)
3043            }
3044            #[inline]
3045            fn abi_decode_returns_validate(
3046                data: &[u8],
3047            ) -> alloy_sol_types::Result<Self::Return> {
3048                <Self::ReturnTuple<
3049                    '_,
3050                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3051                    .map(Into::into)
3052            }
3053        }
3054    };
3055    #[derive(serde::Serialize, serde::Deserialize)]
3056    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3057    /**Function with signature `registerOperator(bytes32,bytes)` and selector `0x00bff04d`.
3058```solidity
3059function registerOperator(bytes32 operatorId, bytes memory quorumNumbers) external returns (uint32[] memory);
3060```*/
3061    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3062    #[derive(Clone)]
3063    pub struct registerOperatorCall {
3064        #[allow(missing_docs)]
3065        pub operatorId: alloy::sol_types::private::FixedBytes<32>,
3066        #[allow(missing_docs)]
3067        pub quorumNumbers: alloy::sol_types::private::Bytes,
3068    }
3069    #[derive(serde::Serialize, serde::Deserialize)]
3070    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3071    ///Container type for the return parameters of the [`registerOperator(bytes32,bytes)`](registerOperatorCall) function.
3072    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3073    #[derive(Clone)]
3074    pub struct registerOperatorReturn {
3075        #[allow(missing_docs)]
3076        pub _0: alloy::sol_types::private::Vec<u32>,
3077    }
3078    #[allow(
3079        non_camel_case_types,
3080        non_snake_case,
3081        clippy::pub_underscore_fields,
3082        clippy::style
3083    )]
3084    const _: () = {
3085        use alloy::sol_types as alloy_sol_types;
3086        {
3087            #[doc(hidden)]
3088            type UnderlyingSolTuple<'a> = (
3089                alloy::sol_types::sol_data::FixedBytes<32>,
3090                alloy::sol_types::sol_data::Bytes,
3091            );
3092            #[doc(hidden)]
3093            type UnderlyingRustTuple<'a> = (
3094                alloy::sol_types::private::FixedBytes<32>,
3095                alloy::sol_types::private::Bytes,
3096            );
3097            #[cfg(test)]
3098            #[allow(dead_code, unreachable_patterns)]
3099            fn _type_assertion(
3100                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3101            ) {
3102                match _t {
3103                    alloy_sol_types::private::AssertTypeEq::<
3104                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3105                    >(_) => {}
3106                }
3107            }
3108            #[automatically_derived]
3109            #[doc(hidden)]
3110            impl ::core::convert::From<registerOperatorCall>
3111            for UnderlyingRustTuple<'_> {
3112                fn from(value: registerOperatorCall) -> Self {
3113                    (value.operatorId, value.quorumNumbers)
3114                }
3115            }
3116            #[automatically_derived]
3117            #[doc(hidden)]
3118            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3119            for registerOperatorCall {
3120                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3121                    Self {
3122                        operatorId: tuple.0,
3123                        quorumNumbers: tuple.1,
3124                    }
3125                }
3126            }
3127        }
3128        {
3129            #[doc(hidden)]
3130            type UnderlyingSolTuple<'a> = (
3131                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
3132            );
3133            #[doc(hidden)]
3134            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Vec<u32>,);
3135            #[cfg(test)]
3136            #[allow(dead_code, unreachable_patterns)]
3137            fn _type_assertion(
3138                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3139            ) {
3140                match _t {
3141                    alloy_sol_types::private::AssertTypeEq::<
3142                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3143                    >(_) => {}
3144                }
3145            }
3146            #[automatically_derived]
3147            #[doc(hidden)]
3148            impl ::core::convert::From<registerOperatorReturn>
3149            for UnderlyingRustTuple<'_> {
3150                fn from(value: registerOperatorReturn) -> Self {
3151                    (value._0,)
3152                }
3153            }
3154            #[automatically_derived]
3155            #[doc(hidden)]
3156            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3157            for registerOperatorReturn {
3158                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3159                    Self { _0: tuple.0 }
3160                }
3161            }
3162        }
3163        #[automatically_derived]
3164        impl alloy_sol_types::SolCall for registerOperatorCall {
3165            type Parameters<'a> = (
3166                alloy::sol_types::sol_data::FixedBytes<32>,
3167                alloy::sol_types::sol_data::Bytes,
3168            );
3169            type Token<'a> = <Self::Parameters<
3170                'a,
3171            > as alloy_sol_types::SolType>::Token<'a>;
3172            type Return = alloy::sol_types::private::Vec<u32>;
3173            type ReturnTuple<'a> = (
3174                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
3175            );
3176            type ReturnToken<'a> = <Self::ReturnTuple<
3177                'a,
3178            > as alloy_sol_types::SolType>::Token<'a>;
3179            const SIGNATURE: &'static str = "registerOperator(bytes32,bytes)";
3180            const SELECTOR: [u8; 4] = [0u8, 191u8, 240u8, 77u8];
3181            #[inline]
3182            fn new<'a>(
3183                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3184            ) -> Self {
3185                tuple.into()
3186            }
3187            #[inline]
3188            fn tokenize(&self) -> Self::Token<'_> {
3189                (
3190                    <alloy::sol_types::sol_data::FixedBytes<
3191                        32,
3192                    > as alloy_sol_types::SolType>::tokenize(&self.operatorId),
3193                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
3194                        &self.quorumNumbers,
3195                    ),
3196                )
3197            }
3198            #[inline]
3199            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3200                (
3201                    <alloy::sol_types::sol_data::Array<
3202                        alloy::sol_types::sol_data::Uint<32>,
3203                    > as alloy_sol_types::SolType>::tokenize(ret),
3204                )
3205            }
3206            #[inline]
3207            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3208                <Self::ReturnTuple<
3209                    '_,
3210                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3211                    .map(|r| {
3212                        let r: registerOperatorReturn = r.into();
3213                        r._0
3214                    })
3215            }
3216            #[inline]
3217            fn abi_decode_returns_validate(
3218                data: &[u8],
3219            ) -> alloy_sol_types::Result<Self::Return> {
3220                <Self::ReturnTuple<
3221                    '_,
3222                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3223                    .map(|r| {
3224                        let r: registerOperatorReturn = r.into();
3225                        r._0
3226                    })
3227            }
3228        }
3229    };
3230    #[derive(serde::Serialize, serde::Deserialize)]
3231    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3232    /**Function with signature `registryCoordinator()` and selector `0x6d14a987`.
3233```solidity
3234function registryCoordinator() external view returns (address);
3235```*/
3236    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3237    #[derive(Clone)]
3238    pub struct registryCoordinatorCall;
3239    #[derive(serde::Serialize, serde::Deserialize)]
3240    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3241    ///Container type for the return parameters of the [`registryCoordinator()`](registryCoordinatorCall) function.
3242    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3243    #[derive(Clone)]
3244    pub struct registryCoordinatorReturn {
3245        #[allow(missing_docs)]
3246        pub _0: alloy::sol_types::private::Address,
3247    }
3248    #[allow(
3249        non_camel_case_types,
3250        non_snake_case,
3251        clippy::pub_underscore_fields,
3252        clippy::style
3253    )]
3254    const _: () = {
3255        use alloy::sol_types as alloy_sol_types;
3256        {
3257            #[doc(hidden)]
3258            type UnderlyingSolTuple<'a> = ();
3259            #[doc(hidden)]
3260            type UnderlyingRustTuple<'a> = ();
3261            #[cfg(test)]
3262            #[allow(dead_code, unreachable_patterns)]
3263            fn _type_assertion(
3264                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3265            ) {
3266                match _t {
3267                    alloy_sol_types::private::AssertTypeEq::<
3268                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3269                    >(_) => {}
3270                }
3271            }
3272            #[automatically_derived]
3273            #[doc(hidden)]
3274            impl ::core::convert::From<registryCoordinatorCall>
3275            for UnderlyingRustTuple<'_> {
3276                fn from(value: registryCoordinatorCall) -> Self {
3277                    ()
3278                }
3279            }
3280            #[automatically_derived]
3281            #[doc(hidden)]
3282            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3283            for registryCoordinatorCall {
3284                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3285                    Self
3286                }
3287            }
3288        }
3289        {
3290            #[doc(hidden)]
3291            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3292            #[doc(hidden)]
3293            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3294            #[cfg(test)]
3295            #[allow(dead_code, unreachable_patterns)]
3296            fn _type_assertion(
3297                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3298            ) {
3299                match _t {
3300                    alloy_sol_types::private::AssertTypeEq::<
3301                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3302                    >(_) => {}
3303                }
3304            }
3305            #[automatically_derived]
3306            #[doc(hidden)]
3307            impl ::core::convert::From<registryCoordinatorReturn>
3308            for UnderlyingRustTuple<'_> {
3309                fn from(value: registryCoordinatorReturn) -> Self {
3310                    (value._0,)
3311                }
3312            }
3313            #[automatically_derived]
3314            #[doc(hidden)]
3315            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3316            for registryCoordinatorReturn {
3317                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3318                    Self { _0: tuple.0 }
3319                }
3320            }
3321        }
3322        #[automatically_derived]
3323        impl alloy_sol_types::SolCall for registryCoordinatorCall {
3324            type Parameters<'a> = ();
3325            type Token<'a> = <Self::Parameters<
3326                'a,
3327            > as alloy_sol_types::SolType>::Token<'a>;
3328            type Return = alloy::sol_types::private::Address;
3329            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3330            type ReturnToken<'a> = <Self::ReturnTuple<
3331                'a,
3332            > as alloy_sol_types::SolType>::Token<'a>;
3333            const SIGNATURE: &'static str = "registryCoordinator()";
3334            const SELECTOR: [u8; 4] = [109u8, 20u8, 169u8, 135u8];
3335            #[inline]
3336            fn new<'a>(
3337                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3338            ) -> Self {
3339                tuple.into()
3340            }
3341            #[inline]
3342            fn tokenize(&self) -> Self::Token<'_> {
3343                ()
3344            }
3345            #[inline]
3346            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3347                (
3348                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3349                        ret,
3350                    ),
3351                )
3352            }
3353            #[inline]
3354            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3355                <Self::ReturnTuple<
3356                    '_,
3357                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3358                    .map(|r| {
3359                        let r: registryCoordinatorReturn = r.into();
3360                        r._0
3361                    })
3362            }
3363            #[inline]
3364            fn abi_decode_returns_validate(
3365                data: &[u8],
3366            ) -> alloy_sol_types::Result<Self::Return> {
3367                <Self::ReturnTuple<
3368                    '_,
3369                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3370                    .map(|r| {
3371                        let r: registryCoordinatorReturn = r.into();
3372                        r._0
3373                    })
3374            }
3375        }
3376    };
3377    #[derive(serde::Serialize, serde::Deserialize)]
3378    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3379    /**Function with signature `totalOperatorsForQuorum(uint8)` and selector `0xf3410922`.
3380```solidity
3381function totalOperatorsForQuorum(uint8 quorumNumber) external view returns (uint32);
3382```*/
3383    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3384    #[derive(Clone)]
3385    pub struct totalOperatorsForQuorumCall {
3386        #[allow(missing_docs)]
3387        pub quorumNumber: u8,
3388    }
3389    #[derive(serde::Serialize, serde::Deserialize)]
3390    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3391    ///Container type for the return parameters of the [`totalOperatorsForQuorum(uint8)`](totalOperatorsForQuorumCall) function.
3392    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3393    #[derive(Clone)]
3394    pub struct totalOperatorsForQuorumReturn {
3395        #[allow(missing_docs)]
3396        pub _0: u32,
3397    }
3398    #[allow(
3399        non_camel_case_types,
3400        non_snake_case,
3401        clippy::pub_underscore_fields,
3402        clippy::style
3403    )]
3404    const _: () = {
3405        use alloy::sol_types as alloy_sol_types;
3406        {
3407            #[doc(hidden)]
3408            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3409            #[doc(hidden)]
3410            type UnderlyingRustTuple<'a> = (u8,);
3411            #[cfg(test)]
3412            #[allow(dead_code, unreachable_patterns)]
3413            fn _type_assertion(
3414                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3415            ) {
3416                match _t {
3417                    alloy_sol_types::private::AssertTypeEq::<
3418                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3419                    >(_) => {}
3420                }
3421            }
3422            #[automatically_derived]
3423            #[doc(hidden)]
3424            impl ::core::convert::From<totalOperatorsForQuorumCall>
3425            for UnderlyingRustTuple<'_> {
3426                fn from(value: totalOperatorsForQuorumCall) -> Self {
3427                    (value.quorumNumber,)
3428                }
3429            }
3430            #[automatically_derived]
3431            #[doc(hidden)]
3432            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3433            for totalOperatorsForQuorumCall {
3434                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3435                    Self { quorumNumber: tuple.0 }
3436                }
3437            }
3438        }
3439        {
3440            #[doc(hidden)]
3441            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
3442            #[doc(hidden)]
3443            type UnderlyingRustTuple<'a> = (u32,);
3444            #[cfg(test)]
3445            #[allow(dead_code, unreachable_patterns)]
3446            fn _type_assertion(
3447                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3448            ) {
3449                match _t {
3450                    alloy_sol_types::private::AssertTypeEq::<
3451                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3452                    >(_) => {}
3453                }
3454            }
3455            #[automatically_derived]
3456            #[doc(hidden)]
3457            impl ::core::convert::From<totalOperatorsForQuorumReturn>
3458            for UnderlyingRustTuple<'_> {
3459                fn from(value: totalOperatorsForQuorumReturn) -> Self {
3460                    (value._0,)
3461                }
3462            }
3463            #[automatically_derived]
3464            #[doc(hidden)]
3465            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3466            for totalOperatorsForQuorumReturn {
3467                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3468                    Self { _0: tuple.0 }
3469                }
3470            }
3471        }
3472        #[automatically_derived]
3473        impl alloy_sol_types::SolCall for totalOperatorsForQuorumCall {
3474            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
3475            type Token<'a> = <Self::Parameters<
3476                'a,
3477            > as alloy_sol_types::SolType>::Token<'a>;
3478            type Return = u32;
3479            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
3480            type ReturnToken<'a> = <Self::ReturnTuple<
3481                'a,
3482            > as alloy_sol_types::SolType>::Token<'a>;
3483            const SIGNATURE: &'static str = "totalOperatorsForQuorum(uint8)";
3484            const SELECTOR: [u8; 4] = [243u8, 65u8, 9u8, 34u8];
3485            #[inline]
3486            fn new<'a>(
3487                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3488            ) -> Self {
3489                tuple.into()
3490            }
3491            #[inline]
3492            fn tokenize(&self) -> Self::Token<'_> {
3493                (
3494                    <alloy::sol_types::sol_data::Uint<
3495                        8,
3496                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
3497                )
3498            }
3499            #[inline]
3500            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3501                (
3502                    <alloy::sol_types::sol_data::Uint<
3503                        32,
3504                    > as alloy_sol_types::SolType>::tokenize(ret),
3505                )
3506            }
3507            #[inline]
3508            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3509                <Self::ReturnTuple<
3510                    '_,
3511                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3512                    .map(|r| {
3513                        let r: totalOperatorsForQuorumReturn = r.into();
3514                        r._0
3515                    })
3516            }
3517            #[inline]
3518            fn abi_decode_returns_validate(
3519                data: &[u8],
3520            ) -> alloy_sol_types::Result<Self::Return> {
3521                <Self::ReturnTuple<
3522                    '_,
3523                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3524                    .map(|r| {
3525                        let r: totalOperatorsForQuorumReturn = r.into();
3526                        r._0
3527                    })
3528            }
3529        }
3530    };
3531    #[derive(serde::Serialize, serde::Deserialize)]
3532    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3533    /**Function with signature `totalOperatorsForQuorumAtBlockNumber(uint8,uint32)` and selector `0x7b5d26be`.
3534```solidity
3535function totalOperatorsForQuorumAtBlockNumber(uint8 quorumNumber, uint32 blockNumber) external view returns (uint32);
3536```*/
3537    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3538    #[derive(Clone)]
3539    pub struct totalOperatorsForQuorumAtBlockNumberCall {
3540        #[allow(missing_docs)]
3541        pub quorumNumber: u8,
3542        #[allow(missing_docs)]
3543        pub blockNumber: u32,
3544    }
3545    #[derive(serde::Serialize, serde::Deserialize)]
3546    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3547    ///Container type for the return parameters of the [`totalOperatorsForQuorumAtBlockNumber(uint8,uint32)`](totalOperatorsForQuorumAtBlockNumberCall) function.
3548    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3549    #[derive(Clone)]
3550    pub struct totalOperatorsForQuorumAtBlockNumberReturn {
3551        #[allow(missing_docs)]
3552        pub _0: u32,
3553    }
3554    #[allow(
3555        non_camel_case_types,
3556        non_snake_case,
3557        clippy::pub_underscore_fields,
3558        clippy::style
3559    )]
3560    const _: () = {
3561        use alloy::sol_types as alloy_sol_types;
3562        {
3563            #[doc(hidden)]
3564            type UnderlyingSolTuple<'a> = (
3565                alloy::sol_types::sol_data::Uint<8>,
3566                alloy::sol_types::sol_data::Uint<32>,
3567            );
3568            #[doc(hidden)]
3569            type UnderlyingRustTuple<'a> = (u8, u32);
3570            #[cfg(test)]
3571            #[allow(dead_code, unreachable_patterns)]
3572            fn _type_assertion(
3573                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3574            ) {
3575                match _t {
3576                    alloy_sol_types::private::AssertTypeEq::<
3577                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3578                    >(_) => {}
3579                }
3580            }
3581            #[automatically_derived]
3582            #[doc(hidden)]
3583            impl ::core::convert::From<totalOperatorsForQuorumAtBlockNumberCall>
3584            for UnderlyingRustTuple<'_> {
3585                fn from(value: totalOperatorsForQuorumAtBlockNumberCall) -> Self {
3586                    (value.quorumNumber, value.blockNumber)
3587                }
3588            }
3589            #[automatically_derived]
3590            #[doc(hidden)]
3591            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3592            for totalOperatorsForQuorumAtBlockNumberCall {
3593                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3594                    Self {
3595                        quorumNumber: tuple.0,
3596                        blockNumber: tuple.1,
3597                    }
3598                }
3599            }
3600        }
3601        {
3602            #[doc(hidden)]
3603            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
3604            #[doc(hidden)]
3605            type UnderlyingRustTuple<'a> = (u32,);
3606            #[cfg(test)]
3607            #[allow(dead_code, unreachable_patterns)]
3608            fn _type_assertion(
3609                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3610            ) {
3611                match _t {
3612                    alloy_sol_types::private::AssertTypeEq::<
3613                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3614                    >(_) => {}
3615                }
3616            }
3617            #[automatically_derived]
3618            #[doc(hidden)]
3619            impl ::core::convert::From<totalOperatorsForQuorumAtBlockNumberReturn>
3620            for UnderlyingRustTuple<'_> {
3621                fn from(value: totalOperatorsForQuorumAtBlockNumberReturn) -> Self {
3622                    (value._0,)
3623                }
3624            }
3625            #[automatically_derived]
3626            #[doc(hidden)]
3627            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3628            for totalOperatorsForQuorumAtBlockNumberReturn {
3629                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3630                    Self { _0: tuple.0 }
3631                }
3632            }
3633        }
3634        #[automatically_derived]
3635        impl alloy_sol_types::SolCall for totalOperatorsForQuorumAtBlockNumberCall {
3636            type Parameters<'a> = (
3637                alloy::sol_types::sol_data::Uint<8>,
3638                alloy::sol_types::sol_data::Uint<32>,
3639            );
3640            type Token<'a> = <Self::Parameters<
3641                'a,
3642            > as alloy_sol_types::SolType>::Token<'a>;
3643            type Return = u32;
3644            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
3645            type ReturnToken<'a> = <Self::ReturnTuple<
3646                'a,
3647            > as alloy_sol_types::SolType>::Token<'a>;
3648            const SIGNATURE: &'static str = "totalOperatorsForQuorumAtBlockNumber(uint8,uint32)";
3649            const SELECTOR: [u8; 4] = [123u8, 93u8, 38u8, 190u8];
3650            #[inline]
3651            fn new<'a>(
3652                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3653            ) -> Self {
3654                tuple.into()
3655            }
3656            #[inline]
3657            fn tokenize(&self) -> Self::Token<'_> {
3658                (
3659                    <alloy::sol_types::sol_data::Uint<
3660                        8,
3661                    > as alloy_sol_types::SolType>::tokenize(&self.quorumNumber),
3662                    <alloy::sol_types::sol_data::Uint<
3663                        32,
3664                    > as alloy_sol_types::SolType>::tokenize(&self.blockNumber),
3665                )
3666            }
3667            #[inline]
3668            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3669                (
3670                    <alloy::sol_types::sol_data::Uint<
3671                        32,
3672                    > as alloy_sol_types::SolType>::tokenize(ret),
3673                )
3674            }
3675            #[inline]
3676            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3677                <Self::ReturnTuple<
3678                    '_,
3679                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3680                    .map(|r| {
3681                        let r: totalOperatorsForQuorumAtBlockNumberReturn = r.into();
3682                        r._0
3683                    })
3684            }
3685            #[inline]
3686            fn abi_decode_returns_validate(
3687                data: &[u8],
3688            ) -> alloy_sol_types::Result<Self::Return> {
3689                <Self::ReturnTuple<
3690                    '_,
3691                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3692                    .map(|r| {
3693                        let r: totalOperatorsForQuorumAtBlockNumberReturn = r.into();
3694                        r._0
3695                    })
3696            }
3697        }
3698    };
3699    ///Container for all the [`IndexRegistry`](self) function calls.
3700    #[derive(serde::Serialize, serde::Deserialize)]
3701    #[derive()]
3702    pub enum IndexRegistryCalls {
3703        #[allow(missing_docs)]
3704        OPERATOR_DOES_NOT_EXIST_ID(OPERATOR_DOES_NOT_EXIST_IDCall),
3705        #[allow(missing_docs)]
3706        currentOperatorIndex(currentOperatorIndexCall),
3707        #[allow(missing_docs)]
3708        deregisterOperator(deregisterOperatorCall),
3709        #[allow(missing_docs)]
3710        getLatestOperatorUpdate(getLatestOperatorUpdateCall),
3711        #[allow(missing_docs)]
3712        getLatestQuorumUpdate(getLatestQuorumUpdateCall),
3713        #[allow(missing_docs)]
3714        getOperatorListAtBlockNumber(getOperatorListAtBlockNumberCall),
3715        #[allow(missing_docs)]
3716        getOperatorUpdateAtIndex(getOperatorUpdateAtIndexCall),
3717        #[allow(missing_docs)]
3718        getQuorumUpdateAtIndex(getQuorumUpdateAtIndexCall),
3719        #[allow(missing_docs)]
3720        initializeQuorum(initializeQuorumCall),
3721        #[allow(missing_docs)]
3722        registerOperator(registerOperatorCall),
3723        #[allow(missing_docs)]
3724        registryCoordinator(registryCoordinatorCall),
3725        #[allow(missing_docs)]
3726        totalOperatorsForQuorum(totalOperatorsForQuorumCall),
3727        #[allow(missing_docs)]
3728        totalOperatorsForQuorumAtBlockNumber(totalOperatorsForQuorumAtBlockNumberCall),
3729    }
3730    #[automatically_derived]
3731    impl IndexRegistryCalls {
3732        /// All the selectors of this enum.
3733        ///
3734        /// Note that the selectors might not be in the same order as the variants.
3735        /// No guarantees are made about the order of the selectors.
3736        ///
3737        /// Prefer using `SolInterface` methods instead.
3738        pub const SELECTORS: &'static [[u8; 4usize]] = &[
3739            [0u8, 191u8, 240u8, 77u8],
3740            [18u8, 209u8, 215u8, 77u8],
3741            [38u8, 217u8, 65u8, 242u8],
3742            [46u8, 213u8, 131u8, 229u8],
3743            [109u8, 20u8, 169u8, 135u8],
3744            [123u8, 93u8, 38u8, 190u8],
3745            [129u8, 33u8, 144u8, 111u8],
3746            [137u8, 2u8, 98u8, 69u8],
3747            [164u8, 139u8, 176u8, 172u8],
3748            [189u8, 41u8, 184u8, 205u8],
3749            [202u8, 163u8, 205u8, 118u8],
3750            [226u8, 230u8, 133u8, 128u8],
3751            [243u8, 65u8, 9u8, 34u8],
3752        ];
3753    }
3754    #[automatically_derived]
3755    impl alloy_sol_types::SolInterface for IndexRegistryCalls {
3756        const NAME: &'static str = "IndexRegistryCalls";
3757        const MIN_DATA_LENGTH: usize = 0usize;
3758        const COUNT: usize = 13usize;
3759        #[inline]
3760        fn selector(&self) -> [u8; 4] {
3761            match self {
3762                Self::OPERATOR_DOES_NOT_EXIST_ID(_) => {
3763                    <OPERATOR_DOES_NOT_EXIST_IDCall as alloy_sol_types::SolCall>::SELECTOR
3764                }
3765                Self::currentOperatorIndex(_) => {
3766                    <currentOperatorIndexCall as alloy_sol_types::SolCall>::SELECTOR
3767                }
3768                Self::deregisterOperator(_) => {
3769                    <deregisterOperatorCall as alloy_sol_types::SolCall>::SELECTOR
3770                }
3771                Self::getLatestOperatorUpdate(_) => {
3772                    <getLatestOperatorUpdateCall as alloy_sol_types::SolCall>::SELECTOR
3773                }
3774                Self::getLatestQuorumUpdate(_) => {
3775                    <getLatestQuorumUpdateCall as alloy_sol_types::SolCall>::SELECTOR
3776                }
3777                Self::getOperatorListAtBlockNumber(_) => {
3778                    <getOperatorListAtBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
3779                }
3780                Self::getOperatorUpdateAtIndex(_) => {
3781                    <getOperatorUpdateAtIndexCall as alloy_sol_types::SolCall>::SELECTOR
3782                }
3783                Self::getQuorumUpdateAtIndex(_) => {
3784                    <getQuorumUpdateAtIndexCall as alloy_sol_types::SolCall>::SELECTOR
3785                }
3786                Self::initializeQuorum(_) => {
3787                    <initializeQuorumCall as alloy_sol_types::SolCall>::SELECTOR
3788                }
3789                Self::registerOperator(_) => {
3790                    <registerOperatorCall as alloy_sol_types::SolCall>::SELECTOR
3791                }
3792                Self::registryCoordinator(_) => {
3793                    <registryCoordinatorCall as alloy_sol_types::SolCall>::SELECTOR
3794                }
3795                Self::totalOperatorsForQuorum(_) => {
3796                    <totalOperatorsForQuorumCall as alloy_sol_types::SolCall>::SELECTOR
3797                }
3798                Self::totalOperatorsForQuorumAtBlockNumber(_) => {
3799                    <totalOperatorsForQuorumAtBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
3800                }
3801            }
3802        }
3803        #[inline]
3804        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
3805            Self::SELECTORS.get(i).copied()
3806        }
3807        #[inline]
3808        fn valid_selector(selector: [u8; 4]) -> bool {
3809            Self::SELECTORS.binary_search(&selector).is_ok()
3810        }
3811        #[inline]
3812        #[allow(non_snake_case)]
3813        fn abi_decode_raw(
3814            selector: [u8; 4],
3815            data: &[u8],
3816        ) -> alloy_sol_types::Result<Self> {
3817            static DECODE_SHIMS: &[fn(
3818                &[u8],
3819            ) -> alloy_sol_types::Result<IndexRegistryCalls>] = &[
3820                {
3821                    fn registerOperator(
3822                        data: &[u8],
3823                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3824                        <registerOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
3825                                data,
3826                            )
3827                            .map(IndexRegistryCalls::registerOperator)
3828                    }
3829                    registerOperator
3830                },
3831                {
3832                    fn getLatestOperatorUpdate(
3833                        data: &[u8],
3834                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3835                        <getLatestOperatorUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
3836                                data,
3837                            )
3838                            .map(IndexRegistryCalls::getLatestOperatorUpdate)
3839                    }
3840                    getLatestOperatorUpdate
3841                },
3842                {
3843                    fn initializeQuorum(
3844                        data: &[u8],
3845                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3846                        <initializeQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw(
3847                                data,
3848                            )
3849                            .map(IndexRegistryCalls::initializeQuorum)
3850                    }
3851                    initializeQuorum
3852                },
3853                {
3854                    fn getOperatorUpdateAtIndex(
3855                        data: &[u8],
3856                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3857                        <getOperatorUpdateAtIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(
3858                                data,
3859                            )
3860                            .map(IndexRegistryCalls::getOperatorUpdateAtIndex)
3861                    }
3862                    getOperatorUpdateAtIndex
3863                },
3864                {
3865                    fn registryCoordinator(
3866                        data: &[u8],
3867                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3868                        <registryCoordinatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
3869                                data,
3870                            )
3871                            .map(IndexRegistryCalls::registryCoordinator)
3872                    }
3873                    registryCoordinator
3874                },
3875                {
3876                    fn totalOperatorsForQuorumAtBlockNumber(
3877                        data: &[u8],
3878                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3879                        <totalOperatorsForQuorumAtBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
3880                                data,
3881                            )
3882                            .map(
3883                                IndexRegistryCalls::totalOperatorsForQuorumAtBlockNumber,
3884                            )
3885                    }
3886                    totalOperatorsForQuorumAtBlockNumber
3887                },
3888                {
3889                    fn getLatestQuorumUpdate(
3890                        data: &[u8],
3891                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3892                        <getLatestQuorumUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
3893                                data,
3894                            )
3895                            .map(IndexRegistryCalls::getLatestQuorumUpdate)
3896                    }
3897                    getLatestQuorumUpdate
3898                },
3899                {
3900                    fn getOperatorListAtBlockNumber(
3901                        data: &[u8],
3902                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3903                        <getOperatorListAtBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
3904                                data,
3905                            )
3906                            .map(IndexRegistryCalls::getOperatorListAtBlockNumber)
3907                    }
3908                    getOperatorListAtBlockNumber
3909                },
3910                {
3911                    fn getQuorumUpdateAtIndex(
3912                        data: &[u8],
3913                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3914                        <getQuorumUpdateAtIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(
3915                                data,
3916                            )
3917                            .map(IndexRegistryCalls::getQuorumUpdateAtIndex)
3918                    }
3919                    getQuorumUpdateAtIndex
3920                },
3921                {
3922                    fn deregisterOperator(
3923                        data: &[u8],
3924                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3925                        <deregisterOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
3926                                data,
3927                            )
3928                            .map(IndexRegistryCalls::deregisterOperator)
3929                    }
3930                    deregisterOperator
3931                },
3932                {
3933                    fn OPERATOR_DOES_NOT_EXIST_ID(
3934                        data: &[u8],
3935                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3936                        <OPERATOR_DOES_NOT_EXIST_IDCall as alloy_sol_types::SolCall>::abi_decode_raw(
3937                                data,
3938                            )
3939                            .map(IndexRegistryCalls::OPERATOR_DOES_NOT_EXIST_ID)
3940                    }
3941                    OPERATOR_DOES_NOT_EXIST_ID
3942                },
3943                {
3944                    fn currentOperatorIndex(
3945                        data: &[u8],
3946                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3947                        <currentOperatorIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(
3948                                data,
3949                            )
3950                            .map(IndexRegistryCalls::currentOperatorIndex)
3951                    }
3952                    currentOperatorIndex
3953                },
3954                {
3955                    fn totalOperatorsForQuorum(
3956                        data: &[u8],
3957                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3958                        <totalOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw(
3959                                data,
3960                            )
3961                            .map(IndexRegistryCalls::totalOperatorsForQuorum)
3962                    }
3963                    totalOperatorsForQuorum
3964                },
3965            ];
3966            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3967                return Err(
3968                    alloy_sol_types::Error::unknown_selector(
3969                        <Self as alloy_sol_types::SolInterface>::NAME,
3970                        selector,
3971                    ),
3972                );
3973            };
3974            DECODE_SHIMS[idx](data)
3975        }
3976        #[inline]
3977        #[allow(non_snake_case)]
3978        fn abi_decode_raw_validate(
3979            selector: [u8; 4],
3980            data: &[u8],
3981        ) -> alloy_sol_types::Result<Self> {
3982            static DECODE_VALIDATE_SHIMS: &[fn(
3983                &[u8],
3984            ) -> alloy_sol_types::Result<IndexRegistryCalls>] = &[
3985                {
3986                    fn registerOperator(
3987                        data: &[u8],
3988                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
3989                        <registerOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3990                                data,
3991                            )
3992                            .map(IndexRegistryCalls::registerOperator)
3993                    }
3994                    registerOperator
3995                },
3996                {
3997                    fn getLatestOperatorUpdate(
3998                        data: &[u8],
3999                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4000                        <getLatestOperatorUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4001                                data,
4002                            )
4003                            .map(IndexRegistryCalls::getLatestOperatorUpdate)
4004                    }
4005                    getLatestOperatorUpdate
4006                },
4007                {
4008                    fn initializeQuorum(
4009                        data: &[u8],
4010                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4011                        <initializeQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4012                                data,
4013                            )
4014                            .map(IndexRegistryCalls::initializeQuorum)
4015                    }
4016                    initializeQuorum
4017                },
4018                {
4019                    fn getOperatorUpdateAtIndex(
4020                        data: &[u8],
4021                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4022                        <getOperatorUpdateAtIndexCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4023                                data,
4024                            )
4025                            .map(IndexRegistryCalls::getOperatorUpdateAtIndex)
4026                    }
4027                    getOperatorUpdateAtIndex
4028                },
4029                {
4030                    fn registryCoordinator(
4031                        data: &[u8],
4032                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4033                        <registryCoordinatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4034                                data,
4035                            )
4036                            .map(IndexRegistryCalls::registryCoordinator)
4037                    }
4038                    registryCoordinator
4039                },
4040                {
4041                    fn totalOperatorsForQuorumAtBlockNumber(
4042                        data: &[u8],
4043                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4044                        <totalOperatorsForQuorumAtBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4045                                data,
4046                            )
4047                            .map(
4048                                IndexRegistryCalls::totalOperatorsForQuorumAtBlockNumber,
4049                            )
4050                    }
4051                    totalOperatorsForQuorumAtBlockNumber
4052                },
4053                {
4054                    fn getLatestQuorumUpdate(
4055                        data: &[u8],
4056                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4057                        <getLatestQuorumUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4058                                data,
4059                            )
4060                            .map(IndexRegistryCalls::getLatestQuorumUpdate)
4061                    }
4062                    getLatestQuorumUpdate
4063                },
4064                {
4065                    fn getOperatorListAtBlockNumber(
4066                        data: &[u8],
4067                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4068                        <getOperatorListAtBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4069                                data,
4070                            )
4071                            .map(IndexRegistryCalls::getOperatorListAtBlockNumber)
4072                    }
4073                    getOperatorListAtBlockNumber
4074                },
4075                {
4076                    fn getQuorumUpdateAtIndex(
4077                        data: &[u8],
4078                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4079                        <getQuorumUpdateAtIndexCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4080                                data,
4081                            )
4082                            .map(IndexRegistryCalls::getQuorumUpdateAtIndex)
4083                    }
4084                    getQuorumUpdateAtIndex
4085                },
4086                {
4087                    fn deregisterOperator(
4088                        data: &[u8],
4089                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4090                        <deregisterOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4091                                data,
4092                            )
4093                            .map(IndexRegistryCalls::deregisterOperator)
4094                    }
4095                    deregisterOperator
4096                },
4097                {
4098                    fn OPERATOR_DOES_NOT_EXIST_ID(
4099                        data: &[u8],
4100                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4101                        <OPERATOR_DOES_NOT_EXIST_IDCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4102                                data,
4103                            )
4104                            .map(IndexRegistryCalls::OPERATOR_DOES_NOT_EXIST_ID)
4105                    }
4106                    OPERATOR_DOES_NOT_EXIST_ID
4107                },
4108                {
4109                    fn currentOperatorIndex(
4110                        data: &[u8],
4111                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4112                        <currentOperatorIndexCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4113                                data,
4114                            )
4115                            .map(IndexRegistryCalls::currentOperatorIndex)
4116                    }
4117                    currentOperatorIndex
4118                },
4119                {
4120                    fn totalOperatorsForQuorum(
4121                        data: &[u8],
4122                    ) -> alloy_sol_types::Result<IndexRegistryCalls> {
4123                        <totalOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4124                                data,
4125                            )
4126                            .map(IndexRegistryCalls::totalOperatorsForQuorum)
4127                    }
4128                    totalOperatorsForQuorum
4129                },
4130            ];
4131            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4132                return Err(
4133                    alloy_sol_types::Error::unknown_selector(
4134                        <Self as alloy_sol_types::SolInterface>::NAME,
4135                        selector,
4136                    ),
4137                );
4138            };
4139            DECODE_VALIDATE_SHIMS[idx](data)
4140        }
4141        #[inline]
4142        fn abi_encoded_size(&self) -> usize {
4143            match self {
4144                Self::OPERATOR_DOES_NOT_EXIST_ID(inner) => {
4145                    <OPERATOR_DOES_NOT_EXIST_IDCall as alloy_sol_types::SolCall>::abi_encoded_size(
4146                        inner,
4147                    )
4148                }
4149                Self::currentOperatorIndex(inner) => {
4150                    <currentOperatorIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
4151                        inner,
4152                    )
4153                }
4154                Self::deregisterOperator(inner) => {
4155                    <deregisterOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
4156                        inner,
4157                    )
4158                }
4159                Self::getLatestOperatorUpdate(inner) => {
4160                    <getLatestOperatorUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
4161                        inner,
4162                    )
4163                }
4164                Self::getLatestQuorumUpdate(inner) => {
4165                    <getLatestQuorumUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
4166                        inner,
4167                    )
4168                }
4169                Self::getOperatorListAtBlockNumber(inner) => {
4170                    <getOperatorListAtBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
4171                        inner,
4172                    )
4173                }
4174                Self::getOperatorUpdateAtIndex(inner) => {
4175                    <getOperatorUpdateAtIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
4176                        inner,
4177                    )
4178                }
4179                Self::getQuorumUpdateAtIndex(inner) => {
4180                    <getQuorumUpdateAtIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
4181                        inner,
4182                    )
4183                }
4184                Self::initializeQuorum(inner) => {
4185                    <initializeQuorumCall as alloy_sol_types::SolCall>::abi_encoded_size(
4186                        inner,
4187                    )
4188                }
4189                Self::registerOperator(inner) => {
4190                    <registerOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
4191                        inner,
4192                    )
4193                }
4194                Self::registryCoordinator(inner) => {
4195                    <registryCoordinatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
4196                        inner,
4197                    )
4198                }
4199                Self::totalOperatorsForQuorum(inner) => {
4200                    <totalOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_encoded_size(
4201                        inner,
4202                    )
4203                }
4204                Self::totalOperatorsForQuorumAtBlockNumber(inner) => {
4205                    <totalOperatorsForQuorumAtBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
4206                        inner,
4207                    )
4208                }
4209            }
4210        }
4211        #[inline]
4212        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4213            match self {
4214                Self::OPERATOR_DOES_NOT_EXIST_ID(inner) => {
4215                    <OPERATOR_DOES_NOT_EXIST_IDCall as alloy_sol_types::SolCall>::abi_encode_raw(
4216                        inner,
4217                        out,
4218                    )
4219                }
4220                Self::currentOperatorIndex(inner) => {
4221                    <currentOperatorIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
4222                        inner,
4223                        out,
4224                    )
4225                }
4226                Self::deregisterOperator(inner) => {
4227                    <deregisterOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
4228                        inner,
4229                        out,
4230                    )
4231                }
4232                Self::getLatestOperatorUpdate(inner) => {
4233                    <getLatestOperatorUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
4234                        inner,
4235                        out,
4236                    )
4237                }
4238                Self::getLatestQuorumUpdate(inner) => {
4239                    <getLatestQuorumUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
4240                        inner,
4241                        out,
4242                    )
4243                }
4244                Self::getOperatorListAtBlockNumber(inner) => {
4245                    <getOperatorListAtBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
4246                        inner,
4247                        out,
4248                    )
4249                }
4250                Self::getOperatorUpdateAtIndex(inner) => {
4251                    <getOperatorUpdateAtIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
4252                        inner,
4253                        out,
4254                    )
4255                }
4256                Self::getQuorumUpdateAtIndex(inner) => {
4257                    <getQuorumUpdateAtIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
4258                        inner,
4259                        out,
4260                    )
4261                }
4262                Self::initializeQuorum(inner) => {
4263                    <initializeQuorumCall as alloy_sol_types::SolCall>::abi_encode_raw(
4264                        inner,
4265                        out,
4266                    )
4267                }
4268                Self::registerOperator(inner) => {
4269                    <registerOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
4270                        inner,
4271                        out,
4272                    )
4273                }
4274                Self::registryCoordinator(inner) => {
4275                    <registryCoordinatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
4276                        inner,
4277                        out,
4278                    )
4279                }
4280                Self::totalOperatorsForQuorum(inner) => {
4281                    <totalOperatorsForQuorumCall as alloy_sol_types::SolCall>::abi_encode_raw(
4282                        inner,
4283                        out,
4284                    )
4285                }
4286                Self::totalOperatorsForQuorumAtBlockNumber(inner) => {
4287                    <totalOperatorsForQuorumAtBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
4288                        inner,
4289                        out,
4290                    )
4291                }
4292            }
4293        }
4294    }
4295    ///Container for all the [`IndexRegistry`](self) custom errors.
4296    #[derive(serde::Serialize, serde::Deserialize)]
4297    #[derive(Debug, PartialEq, Eq, Hash)]
4298    pub enum IndexRegistryErrors {
4299        #[allow(missing_docs)]
4300        OnlyRegistryCoordinator(OnlyRegistryCoordinator),
4301        #[allow(missing_docs)]
4302        OperatorIdDoesNotExist(OperatorIdDoesNotExist),
4303        #[allow(missing_docs)]
4304        QuorumDoesNotExist(QuorumDoesNotExist),
4305    }
4306    #[automatically_derived]
4307    impl IndexRegistryErrors {
4308        /// All the selectors of this enum.
4309        ///
4310        /// Note that the selectors might not be in the same order as the variants.
4311        /// No guarantees are made about the order of the selectors.
4312        ///
4313        /// Prefer using `SolInterface` methods instead.
4314        pub const SELECTORS: &'static [[u8; 4usize]] = &[
4315            [135u8, 41u8, 183u8, 190u8],
4316            [230u8, 33u8, 159u8, 234u8],
4317            [254u8, 36u8, 19u8, 26u8],
4318        ];
4319    }
4320    #[automatically_derived]
4321    impl alloy_sol_types::SolInterface for IndexRegistryErrors {
4322        const NAME: &'static str = "IndexRegistryErrors";
4323        const MIN_DATA_LENGTH: usize = 0usize;
4324        const COUNT: usize = 3usize;
4325        #[inline]
4326        fn selector(&self) -> [u8; 4] {
4327            match self {
4328                Self::OnlyRegistryCoordinator(_) => {
4329                    <OnlyRegistryCoordinator as alloy_sol_types::SolError>::SELECTOR
4330                }
4331                Self::OperatorIdDoesNotExist(_) => {
4332                    <OperatorIdDoesNotExist as alloy_sol_types::SolError>::SELECTOR
4333                }
4334                Self::QuorumDoesNotExist(_) => {
4335                    <QuorumDoesNotExist as alloy_sol_types::SolError>::SELECTOR
4336                }
4337            }
4338        }
4339        #[inline]
4340        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4341            Self::SELECTORS.get(i).copied()
4342        }
4343        #[inline]
4344        fn valid_selector(selector: [u8; 4]) -> bool {
4345            Self::SELECTORS.binary_search(&selector).is_ok()
4346        }
4347        #[inline]
4348        #[allow(non_snake_case)]
4349        fn abi_decode_raw(
4350            selector: [u8; 4],
4351            data: &[u8],
4352        ) -> alloy_sol_types::Result<Self> {
4353            static DECODE_SHIMS: &[fn(
4354                &[u8],
4355            ) -> alloy_sol_types::Result<IndexRegistryErrors>] = &[
4356                {
4357                    fn OnlyRegistryCoordinator(
4358                        data: &[u8],
4359                    ) -> alloy_sol_types::Result<IndexRegistryErrors> {
4360                        <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_decode_raw(
4361                                data,
4362                            )
4363                            .map(IndexRegistryErrors::OnlyRegistryCoordinator)
4364                    }
4365                    OnlyRegistryCoordinator
4366                },
4367                {
4368                    fn QuorumDoesNotExist(
4369                        data: &[u8],
4370                    ) -> alloy_sol_types::Result<IndexRegistryErrors> {
4371                        <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw(
4372                                data,
4373                            )
4374                            .map(IndexRegistryErrors::QuorumDoesNotExist)
4375                    }
4376                    QuorumDoesNotExist
4377                },
4378                {
4379                    fn OperatorIdDoesNotExist(
4380                        data: &[u8],
4381                    ) -> alloy_sol_types::Result<IndexRegistryErrors> {
4382                        <OperatorIdDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw(
4383                                data,
4384                            )
4385                            .map(IndexRegistryErrors::OperatorIdDoesNotExist)
4386                    }
4387                    OperatorIdDoesNotExist
4388                },
4389            ];
4390            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4391                return Err(
4392                    alloy_sol_types::Error::unknown_selector(
4393                        <Self as alloy_sol_types::SolInterface>::NAME,
4394                        selector,
4395                    ),
4396                );
4397            };
4398            DECODE_SHIMS[idx](data)
4399        }
4400        #[inline]
4401        #[allow(non_snake_case)]
4402        fn abi_decode_raw_validate(
4403            selector: [u8; 4],
4404            data: &[u8],
4405        ) -> alloy_sol_types::Result<Self> {
4406            static DECODE_VALIDATE_SHIMS: &[fn(
4407                &[u8],
4408            ) -> alloy_sol_types::Result<IndexRegistryErrors>] = &[
4409                {
4410                    fn OnlyRegistryCoordinator(
4411                        data: &[u8],
4412                    ) -> alloy_sol_types::Result<IndexRegistryErrors> {
4413                        <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_decode_raw_validate(
4414                                data,
4415                            )
4416                            .map(IndexRegistryErrors::OnlyRegistryCoordinator)
4417                    }
4418                    OnlyRegistryCoordinator
4419                },
4420                {
4421                    fn QuorumDoesNotExist(
4422                        data: &[u8],
4423                    ) -> alloy_sol_types::Result<IndexRegistryErrors> {
4424                        <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw_validate(
4425                                data,
4426                            )
4427                            .map(IndexRegistryErrors::QuorumDoesNotExist)
4428                    }
4429                    QuorumDoesNotExist
4430                },
4431                {
4432                    fn OperatorIdDoesNotExist(
4433                        data: &[u8],
4434                    ) -> alloy_sol_types::Result<IndexRegistryErrors> {
4435                        <OperatorIdDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw_validate(
4436                                data,
4437                            )
4438                            .map(IndexRegistryErrors::OperatorIdDoesNotExist)
4439                    }
4440                    OperatorIdDoesNotExist
4441                },
4442            ];
4443            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4444                return Err(
4445                    alloy_sol_types::Error::unknown_selector(
4446                        <Self as alloy_sol_types::SolInterface>::NAME,
4447                        selector,
4448                    ),
4449                );
4450            };
4451            DECODE_VALIDATE_SHIMS[idx](data)
4452        }
4453        #[inline]
4454        fn abi_encoded_size(&self) -> usize {
4455            match self {
4456                Self::OnlyRegistryCoordinator(inner) => {
4457                    <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_encoded_size(
4458                        inner,
4459                    )
4460                }
4461                Self::OperatorIdDoesNotExist(inner) => {
4462                    <OperatorIdDoesNotExist as alloy_sol_types::SolError>::abi_encoded_size(
4463                        inner,
4464                    )
4465                }
4466                Self::QuorumDoesNotExist(inner) => {
4467                    <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_encoded_size(
4468                        inner,
4469                    )
4470                }
4471            }
4472        }
4473        #[inline]
4474        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4475            match self {
4476                Self::OnlyRegistryCoordinator(inner) => {
4477                    <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_encode_raw(
4478                        inner,
4479                        out,
4480                    )
4481                }
4482                Self::OperatorIdDoesNotExist(inner) => {
4483                    <OperatorIdDoesNotExist as alloy_sol_types::SolError>::abi_encode_raw(
4484                        inner,
4485                        out,
4486                    )
4487                }
4488                Self::QuorumDoesNotExist(inner) => {
4489                    <QuorumDoesNotExist as alloy_sol_types::SolError>::abi_encode_raw(
4490                        inner,
4491                        out,
4492                    )
4493                }
4494            }
4495        }
4496    }
4497    ///Container for all the [`IndexRegistry`](self) events.
4498    #[derive(serde::Serialize, serde::Deserialize)]
4499    #[derive(Debug, PartialEq, Eq, Hash)]
4500    pub enum IndexRegistryEvents {
4501        #[allow(missing_docs)]
4502        Initialized(Initialized),
4503        #[allow(missing_docs)]
4504        QuorumIndexUpdate(QuorumIndexUpdate),
4505    }
4506    #[automatically_derived]
4507    impl IndexRegistryEvents {
4508        /// All the selectors of this enum.
4509        ///
4510        /// Note that the selectors might not be in the same order as the variants.
4511        /// No guarantees are made about the order of the selectors.
4512        ///
4513        /// Prefer using `SolInterface` methods instead.
4514        pub const SELECTORS: &'static [[u8; 32usize]] = &[
4515            [
4516                110u8, 225u8, 228u8, 244u8, 7u8, 95u8, 61u8, 6u8, 113u8, 118u8, 20u8,
4517                13u8, 52u8, 232u8, 120u8, 116u8, 36u8, 77u8, 210u8, 115u8, 41u8, 76u8,
4518                5u8, 178u8, 33u8, 129u8, 51u8, 228u8, 154u8, 43u8, 166u8, 246u8,
4519            ],
4520            [
4521                127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
4522                19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
4523                146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
4524            ],
4525        ];
4526    }
4527    #[automatically_derived]
4528    impl alloy_sol_types::SolEventInterface for IndexRegistryEvents {
4529        const NAME: &'static str = "IndexRegistryEvents";
4530        const COUNT: usize = 2usize;
4531        fn decode_raw_log(
4532            topics: &[alloy_sol_types::Word],
4533            data: &[u8],
4534        ) -> alloy_sol_types::Result<Self> {
4535            match topics.first().copied() {
4536                Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4537                    <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
4538                            topics,
4539                            data,
4540                        )
4541                        .map(Self::Initialized)
4542                }
4543                Some(
4544                    <QuorumIndexUpdate as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
4545                ) => {
4546                    <QuorumIndexUpdate as alloy_sol_types::SolEvent>::decode_raw_log(
4547                            topics,
4548                            data,
4549                        )
4550                        .map(Self::QuorumIndexUpdate)
4551                }
4552                _ => {
4553                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
4554                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
4555                        log: alloy_sol_types::private::Box::new(
4556                            alloy_sol_types::private::LogData::new_unchecked(
4557                                topics.to_vec(),
4558                                data.to_vec().into(),
4559                            ),
4560                        ),
4561                    })
4562                }
4563            }
4564        }
4565    }
4566    #[automatically_derived]
4567    impl alloy_sol_types::private::IntoLogData for IndexRegistryEvents {
4568        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4569            match self {
4570                Self::Initialized(inner) => {
4571                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
4572                }
4573                Self::QuorumIndexUpdate(inner) => {
4574                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
4575                }
4576            }
4577        }
4578        fn into_log_data(self) -> alloy_sol_types::private::LogData {
4579            match self {
4580                Self::Initialized(inner) => {
4581                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
4582                }
4583                Self::QuorumIndexUpdate(inner) => {
4584                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
4585                }
4586            }
4587        }
4588    }
4589    use alloy::contract as alloy_contract;
4590    /**Creates a new wrapper around an on-chain [`IndexRegistry`](self) contract instance.
4591
4592See the [wrapper's documentation](`IndexRegistryInstance`) for more details.*/
4593    #[inline]
4594    pub const fn new<
4595        P: alloy_contract::private::Provider<N>,
4596        N: alloy_contract::private::Network,
4597    >(
4598        address: alloy_sol_types::private::Address,
4599        provider: P,
4600    ) -> IndexRegistryInstance<P, N> {
4601        IndexRegistryInstance::<P, N>::new(address, provider)
4602    }
4603    /**Deploys this contract using the given `provider` and constructor arguments, if any.
4604
4605Returns a new instance of the contract, if the deployment was successful.
4606
4607For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
4608    #[inline]
4609    pub fn deploy<
4610        P: alloy_contract::private::Provider<N>,
4611        N: alloy_contract::private::Network,
4612    >(
4613        provider: P,
4614        _slashingRegistryCoordinator: alloy::sol_types::private::Address,
4615    ) -> impl ::core::future::Future<
4616        Output = alloy_contract::Result<IndexRegistryInstance<P, N>>,
4617    > {
4618        IndexRegistryInstance::<P, N>::deploy(provider, _slashingRegistryCoordinator)
4619    }
4620    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
4621and constructor arguments, if any.
4622
4623This is a simple wrapper around creating a `RawCallBuilder` with the data set to
4624the bytecode concatenated with the constructor's ABI-encoded arguments.*/
4625    #[inline]
4626    pub fn deploy_builder<
4627        P: alloy_contract::private::Provider<N>,
4628        N: alloy_contract::private::Network,
4629    >(
4630        provider: P,
4631        _slashingRegistryCoordinator: alloy::sol_types::private::Address,
4632    ) -> alloy_contract::RawCallBuilder<P, N> {
4633        IndexRegistryInstance::<
4634            P,
4635            N,
4636        >::deploy_builder(provider, _slashingRegistryCoordinator)
4637    }
4638    /**A [`IndexRegistry`](self) instance.
4639
4640Contains type-safe methods for interacting with an on-chain instance of the
4641[`IndexRegistry`](self) contract located at a given `address`, using a given
4642provider `P`.
4643
4644If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
4645documentation on how to provide it), the `deploy` and `deploy_builder` methods can
4646be used to deploy a new instance of the contract.
4647
4648See the [module-level documentation](self) for all the available methods.*/
4649    #[derive(Clone)]
4650    pub struct IndexRegistryInstance<P, N = alloy_contract::private::Ethereum> {
4651        address: alloy_sol_types::private::Address,
4652        provider: P,
4653        _network: ::core::marker::PhantomData<N>,
4654    }
4655    #[automatically_derived]
4656    impl<P, N> ::core::fmt::Debug for IndexRegistryInstance<P, N> {
4657        #[inline]
4658        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4659            f.debug_tuple("IndexRegistryInstance").field(&self.address).finish()
4660        }
4661    }
4662    /// Instantiation and getters/setters.
4663    #[automatically_derived]
4664    impl<
4665        P: alloy_contract::private::Provider<N>,
4666        N: alloy_contract::private::Network,
4667    > IndexRegistryInstance<P, N> {
4668        /**Creates a new wrapper around an on-chain [`IndexRegistry`](self) contract instance.
4669
4670See the [wrapper's documentation](`IndexRegistryInstance`) for more details.*/
4671        #[inline]
4672        pub const fn new(
4673            address: alloy_sol_types::private::Address,
4674            provider: P,
4675        ) -> Self {
4676            Self {
4677                address,
4678                provider,
4679                _network: ::core::marker::PhantomData,
4680            }
4681        }
4682        /**Deploys this contract using the given `provider` and constructor arguments, if any.
4683
4684Returns a new instance of the contract, if the deployment was successful.
4685
4686For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
4687        #[inline]
4688        pub async fn deploy(
4689            provider: P,
4690            _slashingRegistryCoordinator: alloy::sol_types::private::Address,
4691        ) -> alloy_contract::Result<IndexRegistryInstance<P, N>> {
4692            let call_builder = Self::deploy_builder(
4693                provider,
4694                _slashingRegistryCoordinator,
4695            );
4696            let contract_address = call_builder.deploy().await?;
4697            Ok(Self::new(contract_address, call_builder.provider))
4698        }
4699        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
4700and constructor arguments, if any.
4701
4702This is a simple wrapper around creating a `RawCallBuilder` with the data set to
4703the bytecode concatenated with the constructor's ABI-encoded arguments.*/
4704        #[inline]
4705        pub fn deploy_builder(
4706            provider: P,
4707            _slashingRegistryCoordinator: alloy::sol_types::private::Address,
4708        ) -> alloy_contract::RawCallBuilder<P, N> {
4709            alloy_contract::RawCallBuilder::new_raw_deploy(
4710                provider,
4711                [
4712                    &BYTECODE[..],
4713                    &alloy_sol_types::SolConstructor::abi_encode(
4714                        &constructorCall {
4715                            _slashingRegistryCoordinator,
4716                        },
4717                    )[..],
4718                ]
4719                    .concat()
4720                    .into(),
4721            )
4722        }
4723        /// Returns a reference to the address.
4724        #[inline]
4725        pub const fn address(&self) -> &alloy_sol_types::private::Address {
4726            &self.address
4727        }
4728        /// Sets the address.
4729        #[inline]
4730        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
4731            self.address = address;
4732        }
4733        /// Sets the address and returns `self`.
4734        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
4735            self.set_address(address);
4736            self
4737        }
4738        /// Returns a reference to the provider.
4739        #[inline]
4740        pub const fn provider(&self) -> &P {
4741            &self.provider
4742        }
4743    }
4744    impl<P: ::core::clone::Clone, N> IndexRegistryInstance<&P, N> {
4745        /// Clones the provider and returns a new instance with the cloned provider.
4746        #[inline]
4747        pub fn with_cloned_provider(self) -> IndexRegistryInstance<P, N> {
4748            IndexRegistryInstance {
4749                address: self.address,
4750                provider: ::core::clone::Clone::clone(&self.provider),
4751                _network: ::core::marker::PhantomData,
4752            }
4753        }
4754    }
4755    /// Function calls.
4756    #[automatically_derived]
4757    impl<
4758        P: alloy_contract::private::Provider<N>,
4759        N: alloy_contract::private::Network,
4760    > IndexRegistryInstance<P, N> {
4761        /// Creates a new call builder using this contract instance's provider and address.
4762        ///
4763        /// Note that the call can be any function call, not just those defined in this
4764        /// contract. Prefer using the other methods for building type-safe contract calls.
4765        pub fn call_builder<C: alloy_sol_types::SolCall>(
4766            &self,
4767            call: &C,
4768        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
4769            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
4770        }
4771        ///Creates a new call builder for the [`OPERATOR_DOES_NOT_EXIST_ID`] function.
4772        pub fn OPERATOR_DOES_NOT_EXIST_ID(
4773            &self,
4774        ) -> alloy_contract::SolCallBuilder<&P, OPERATOR_DOES_NOT_EXIST_IDCall, N> {
4775            self.call_builder(&OPERATOR_DOES_NOT_EXIST_IDCall)
4776        }
4777        ///Creates a new call builder for the [`currentOperatorIndex`] function.
4778        pub fn currentOperatorIndex(
4779            &self,
4780            _0: u8,
4781            _1: alloy::sol_types::private::FixedBytes<32>,
4782        ) -> alloy_contract::SolCallBuilder<&P, currentOperatorIndexCall, N> {
4783            self.call_builder(&currentOperatorIndexCall { _0, _1 })
4784        }
4785        ///Creates a new call builder for the [`deregisterOperator`] function.
4786        pub fn deregisterOperator(
4787            &self,
4788            operatorId: alloy::sol_types::private::FixedBytes<32>,
4789            quorumNumbers: alloy::sol_types::private::Bytes,
4790        ) -> alloy_contract::SolCallBuilder<&P, deregisterOperatorCall, N> {
4791            self.call_builder(
4792                &deregisterOperatorCall {
4793                    operatorId,
4794                    quorumNumbers,
4795                },
4796            )
4797        }
4798        ///Creates a new call builder for the [`getLatestOperatorUpdate`] function.
4799        pub fn getLatestOperatorUpdate(
4800            &self,
4801            quorumNumber: u8,
4802            operatorIndex: u32,
4803        ) -> alloy_contract::SolCallBuilder<&P, getLatestOperatorUpdateCall, N> {
4804            self.call_builder(
4805                &getLatestOperatorUpdateCall {
4806                    quorumNumber,
4807                    operatorIndex,
4808                },
4809            )
4810        }
4811        ///Creates a new call builder for the [`getLatestQuorumUpdate`] function.
4812        pub fn getLatestQuorumUpdate(
4813            &self,
4814            quorumNumber: u8,
4815        ) -> alloy_contract::SolCallBuilder<&P, getLatestQuorumUpdateCall, N> {
4816            self.call_builder(
4817                &getLatestQuorumUpdateCall {
4818                    quorumNumber,
4819                },
4820            )
4821        }
4822        ///Creates a new call builder for the [`getOperatorListAtBlockNumber`] function.
4823        pub fn getOperatorListAtBlockNumber(
4824            &self,
4825            quorumNumber: u8,
4826            blockNumber: u32,
4827        ) -> alloy_contract::SolCallBuilder<&P, getOperatorListAtBlockNumberCall, N> {
4828            self.call_builder(
4829                &getOperatorListAtBlockNumberCall {
4830                    quorumNumber,
4831                    blockNumber,
4832                },
4833            )
4834        }
4835        ///Creates a new call builder for the [`getOperatorUpdateAtIndex`] function.
4836        pub fn getOperatorUpdateAtIndex(
4837            &self,
4838            quorumNumber: u8,
4839            operatorIndex: u32,
4840            arrayIndex: u32,
4841        ) -> alloy_contract::SolCallBuilder<&P, getOperatorUpdateAtIndexCall, N> {
4842            self.call_builder(
4843                &getOperatorUpdateAtIndexCall {
4844                    quorumNumber,
4845                    operatorIndex,
4846                    arrayIndex,
4847                },
4848            )
4849        }
4850        ///Creates a new call builder for the [`getQuorumUpdateAtIndex`] function.
4851        pub fn getQuorumUpdateAtIndex(
4852            &self,
4853            quorumNumber: u8,
4854            quorumIndex: u32,
4855        ) -> alloy_contract::SolCallBuilder<&P, getQuorumUpdateAtIndexCall, N> {
4856            self.call_builder(
4857                &getQuorumUpdateAtIndexCall {
4858                    quorumNumber,
4859                    quorumIndex,
4860                },
4861            )
4862        }
4863        ///Creates a new call builder for the [`initializeQuorum`] function.
4864        pub fn initializeQuorum(
4865            &self,
4866            quorumNumber: u8,
4867        ) -> alloy_contract::SolCallBuilder<&P, initializeQuorumCall, N> {
4868            self.call_builder(
4869                &initializeQuorumCall {
4870                    quorumNumber,
4871                },
4872            )
4873        }
4874        ///Creates a new call builder for the [`registerOperator`] function.
4875        pub fn registerOperator(
4876            &self,
4877            operatorId: alloy::sol_types::private::FixedBytes<32>,
4878            quorumNumbers: alloy::sol_types::private::Bytes,
4879        ) -> alloy_contract::SolCallBuilder<&P, registerOperatorCall, N> {
4880            self.call_builder(
4881                &registerOperatorCall {
4882                    operatorId,
4883                    quorumNumbers,
4884                },
4885            )
4886        }
4887        ///Creates a new call builder for the [`registryCoordinator`] function.
4888        pub fn registryCoordinator(
4889            &self,
4890        ) -> alloy_contract::SolCallBuilder<&P, registryCoordinatorCall, N> {
4891            self.call_builder(&registryCoordinatorCall)
4892        }
4893        ///Creates a new call builder for the [`totalOperatorsForQuorum`] function.
4894        pub fn totalOperatorsForQuorum(
4895            &self,
4896            quorumNumber: u8,
4897        ) -> alloy_contract::SolCallBuilder<&P, totalOperatorsForQuorumCall, N> {
4898            self.call_builder(
4899                &totalOperatorsForQuorumCall {
4900                    quorumNumber,
4901                },
4902            )
4903        }
4904        ///Creates a new call builder for the [`totalOperatorsForQuorumAtBlockNumber`] function.
4905        pub fn totalOperatorsForQuorumAtBlockNumber(
4906            &self,
4907            quorumNumber: u8,
4908            blockNumber: u32,
4909        ) -> alloy_contract::SolCallBuilder<
4910            &P,
4911            totalOperatorsForQuorumAtBlockNumberCall,
4912            N,
4913        > {
4914            self.call_builder(
4915                &totalOperatorsForQuorumAtBlockNumberCall {
4916                    quorumNumber,
4917                    blockNumber,
4918                },
4919            )
4920        }
4921    }
4922    /// Event filters.
4923    #[automatically_derived]
4924    impl<
4925        P: alloy_contract::private::Provider<N>,
4926        N: alloy_contract::private::Network,
4927    > IndexRegistryInstance<P, N> {
4928        /// Creates a new event filter using this contract instance's provider and address.
4929        ///
4930        /// Note that the type can be any event, not just those defined in this contract.
4931        /// Prefer using the other methods for building type-safe event filters.
4932        pub fn event_filter<E: alloy_sol_types::SolEvent>(
4933            &self,
4934        ) -> alloy_contract::Event<&P, E, N> {
4935            alloy_contract::Event::new_sol(&self.provider, &self.address)
4936        }
4937        ///Creates a new event filter for the [`Initialized`] event.
4938        pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
4939            self.event_filter::<Initialized>()
4940        }
4941        ///Creates a new event filter for the [`QuorumIndexUpdate`] event.
4942        pub fn QuorumIndexUpdate_filter(
4943            &self,
4944        ) -> alloy_contract::Event<&P, QuorumIndexUpdate, N> {
4945            self.event_filter::<QuorumIndexUpdate>()
4946        }
4947    }
4948}
eigenlayer_contract_deployer/bindings/core/index_registry.rs

eigenlayer_contract_deployer/bindings/core/
index_registry.rs
