eigen_utils/rewardsv2/middleware/
service_manager_base.rs

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

eigen_utils/rewardsv2/middleware/
service_manager_base.rs
