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

eigenlayer_contract_deployer/bindings/core/
indexregistry.rs
