fluence_marketplace_api_draft/
idealv2.rs

1///Module containing a contract's types and functions.
2/**
3
4```solidity
5library Common {
6    struct CIDV1 { bytes4 prefixes; bytes32 hash; }
7}
8```*/
9#[allow(
10    non_camel_case_types,
11    non_snake_case,
12    clippy::pub_underscore_fields,
13    clippy::style,
14    clippy::empty_structs_with_brackets
15)]
16pub mod Common {
17    use super::*;
18    use alloy::sol_types as alloy_sol_types;
19    /**```solidity
20struct CIDV1 { bytes4 prefixes; bytes32 hash; }
21```*/
22    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
23    #[derive(Clone)]
24    pub struct CIDV1 {
25        #[allow(missing_docs)]
26        pub prefixes: alloy::sol_types::private::FixedBytes<4>,
27        #[allow(missing_docs)]
28        pub hash: alloy::sol_types::private::FixedBytes<32>,
29    }
30    #[allow(
31        non_camel_case_types,
32        non_snake_case,
33        clippy::pub_underscore_fields,
34        clippy::style
35    )]
36    const _: () = {
37        use alloy::sol_types as alloy_sol_types;
38        #[doc(hidden)]
39        type UnderlyingSolTuple<'a> = (
40            alloy::sol_types::sol_data::FixedBytes<4>,
41            alloy::sol_types::sol_data::FixedBytes<32>,
42        );
43        #[doc(hidden)]
44        type UnderlyingRustTuple<'a> = (
45            alloy::sol_types::private::FixedBytes<4>,
46            alloy::sol_types::private::FixedBytes<32>,
47        );
48        #[cfg(test)]
49        #[allow(dead_code, unreachable_patterns)]
50        fn _type_assertion(
51            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
52        ) {
53            match _t {
54                alloy_sol_types::private::AssertTypeEq::<
55                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
56                >(_) => {}
57            }
58        }
59        #[automatically_derived]
60        #[doc(hidden)]
61        impl ::core::convert::From<CIDV1> for UnderlyingRustTuple<'_> {
62            fn from(value: CIDV1) -> Self {
63                (value.prefixes, value.hash)
64            }
65        }
66        #[automatically_derived]
67        #[doc(hidden)]
68        impl ::core::convert::From<UnderlyingRustTuple<'_>> for CIDV1 {
69            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
70                Self {
71                    prefixes: tuple.0,
72                    hash: tuple.1,
73                }
74            }
75        }
76        #[automatically_derived]
77        impl alloy_sol_types::SolValue for CIDV1 {
78            type SolType = Self;
79        }
80        #[automatically_derived]
81        impl alloy_sol_types::private::SolTypeValue<Self> for CIDV1 {
82            #[inline]
83            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
84                (
85                    <alloy::sol_types::sol_data::FixedBytes<
86                        4,
87                    > as alloy_sol_types::SolType>::tokenize(&self.prefixes),
88                    <alloy::sol_types::sol_data::FixedBytes<
89                        32,
90                    > as alloy_sol_types::SolType>::tokenize(&self.hash),
91                )
92            }
93            #[inline]
94            fn stv_abi_encoded_size(&self) -> usize {
95                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
96                    return size;
97                }
98                let tuple = <UnderlyingRustTuple<
99                    '_,
100                > as ::core::convert::From<Self>>::from(self.clone());
101                <UnderlyingSolTuple<
102                    '_,
103                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
104            }
105            #[inline]
106            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
107                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
108            }
109            #[inline]
110            fn stv_abi_encode_packed_to(
111                &self,
112                out: &mut alloy_sol_types::private::Vec<u8>,
113            ) {
114                let tuple = <UnderlyingRustTuple<
115                    '_,
116                > as ::core::convert::From<Self>>::from(self.clone());
117                <UnderlyingSolTuple<
118                    '_,
119                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
120            }
121            #[inline]
122            fn stv_abi_packed_encoded_size(&self) -> usize {
123                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
124                    return size;
125                }
126                let tuple = <UnderlyingRustTuple<
127                    '_,
128                > as ::core::convert::From<Self>>::from(self.clone());
129                <UnderlyingSolTuple<
130                    '_,
131                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
132            }
133        }
134        #[automatically_derived]
135        impl alloy_sol_types::SolType for CIDV1 {
136            type RustType = Self;
137            type Token<'a> = <UnderlyingSolTuple<
138                'a,
139            > as alloy_sol_types::SolType>::Token<'a>;
140            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
141            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
142                '_,
143            > as alloy_sol_types::SolType>::ENCODED_SIZE;
144            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
145                '_,
146            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
147            #[inline]
148            fn valid_token(token: &Self::Token<'_>) -> bool {
149                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
150            }
151            #[inline]
152            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
153                let tuple = <UnderlyingSolTuple<
154                    '_,
155                > as alloy_sol_types::SolType>::detokenize(token);
156                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
157            }
158        }
159        #[automatically_derived]
160        impl alloy_sol_types::SolStruct for CIDV1 {
161            const NAME: &'static str = "CIDV1";
162            #[inline]
163            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
164                alloy_sol_types::private::Cow::Borrowed(
165                    "CIDV1(bytes4 prefixes,bytes32 hash)",
166                )
167            }
168            #[inline]
169            fn eip712_components() -> alloy_sol_types::private::Vec<
170                alloy_sol_types::private::Cow<'static, str>,
171            > {
172                alloy_sol_types::private::Vec::new()
173            }
174            #[inline]
175            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
176                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
177            }
178            #[inline]
179            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
180                [
181                    <alloy::sol_types::sol_data::FixedBytes<
182                        4,
183                    > as alloy_sol_types::SolType>::eip712_data_word(&self.prefixes)
184                        .0,
185                    <alloy::sol_types::sol_data::FixedBytes<
186                        32,
187                    > as alloy_sol_types::SolType>::eip712_data_word(&self.hash)
188                        .0,
189                ]
190                    .concat()
191            }
192        }
193        #[automatically_derived]
194        impl alloy_sol_types::EventTopic for CIDV1 {
195            #[inline]
196            fn topic_preimage_length(rust: &Self::RustType) -> usize {
197                0usize
198                    + <alloy::sol_types::sol_data::FixedBytes<
199                        4,
200                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
201                        &rust.prefixes,
202                    )
203                    + <alloy::sol_types::sol_data::FixedBytes<
204                        32,
205                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.hash)
206            }
207            #[inline]
208            fn encode_topic_preimage(
209                rust: &Self::RustType,
210                out: &mut alloy_sol_types::private::Vec<u8>,
211            ) {
212                out.reserve(
213                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
214                );
215                <alloy::sol_types::sol_data::FixedBytes<
216                    4,
217                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
218                    &rust.prefixes,
219                    out,
220                );
221                <alloy::sol_types::sol_data::FixedBytes<
222                    32,
223                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
224                    &rust.hash,
225                    out,
226                );
227            }
228            #[inline]
229            fn encode_topic(
230                rust: &Self::RustType,
231            ) -> alloy_sol_types::abi::token::WordToken {
232                let mut out = alloy_sol_types::private::Vec::new();
233                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
234                    rust,
235                    &mut out,
236                );
237                alloy_sol_types::abi::token::WordToken(
238                    alloy_sol_types::private::keccak256(out),
239                )
240            }
241        }
242    };
243    use alloy::contract as alloy_contract;
244    /**Creates a new wrapper around an on-chain [`Common`](self) contract instance.
245
246See the [wrapper's documentation](`CommonInstance`) for more details.*/
247    #[inline]
248    pub const fn new<
249        T: alloy_contract::private::Transport + ::core::clone::Clone,
250        P: alloy_contract::private::Provider<T, N>,
251        N: alloy_contract::private::Network,
252    >(
253        address: alloy_sol_types::private::Address,
254        provider: P,
255    ) -> CommonInstance<T, P, N> {
256        CommonInstance::<T, P, N>::new(address, provider)
257    }
258    /**A [`Common`](self) instance.
259
260Contains type-safe methods for interacting with an on-chain instance of the
261[`Common`](self) contract located at a given `address`, using a given
262provider `P`.
263
264If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
265documentation on how to provide it), the `deploy` and `deploy_builder` methods can
266be used to deploy a new instance of the contract.
267
268See the [module-level documentation](self) for all the available methods.*/
269    #[derive(Clone)]
270    pub struct CommonInstance<T, P, N = alloy_contract::private::Ethereum> {
271        address: alloy_sol_types::private::Address,
272        provider: P,
273        _network_transport: ::core::marker::PhantomData<(N, T)>,
274    }
275    #[automatically_derived]
276    impl<T, P, N> ::core::fmt::Debug for CommonInstance<T, P, N> {
277        #[inline]
278        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
279            f.debug_tuple("CommonInstance").field(&self.address).finish()
280        }
281    }
282    /// Instantiation and getters/setters.
283    #[automatically_derived]
284    impl<
285        T: alloy_contract::private::Transport + ::core::clone::Clone,
286        P: alloy_contract::private::Provider<T, N>,
287        N: alloy_contract::private::Network,
288    > CommonInstance<T, P, N> {
289        /**Creates a new wrapper around an on-chain [`Common`](self) contract instance.
290
291See the [wrapper's documentation](`CommonInstance`) for more details.*/
292        #[inline]
293        pub const fn new(
294            address: alloy_sol_types::private::Address,
295            provider: P,
296        ) -> Self {
297            Self {
298                address,
299                provider,
300                _network_transport: ::core::marker::PhantomData,
301            }
302        }
303        /// Returns a reference to the address.
304        #[inline]
305        pub const fn address(&self) -> &alloy_sol_types::private::Address {
306            &self.address
307        }
308        /// Sets the address.
309        #[inline]
310        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
311            self.address = address;
312        }
313        /// Sets the address and returns `self`.
314        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
315            self.set_address(address);
316            self
317        }
318        /// Returns a reference to the provider.
319        #[inline]
320        pub const fn provider(&self) -> &P {
321            &self.provider
322        }
323    }
324    impl<T, P: ::core::clone::Clone, N> CommonInstance<T, &P, N> {
325        /// Clones the provider and returns a new instance with the cloned provider.
326        #[inline]
327        pub fn with_cloned_provider(self) -> CommonInstance<T, P, N> {
328            CommonInstance {
329                address: self.address,
330                provider: ::core::clone::Clone::clone(&self.provider),
331                _network_transport: ::core::marker::PhantomData,
332            }
333        }
334    }
335    /// Function calls.
336    #[automatically_derived]
337    impl<
338        T: alloy_contract::private::Transport + ::core::clone::Clone,
339        P: alloy_contract::private::Provider<T, N>,
340        N: alloy_contract::private::Network,
341    > CommonInstance<T, P, N> {
342        /// Creates a new call builder using this contract instance's provider and address.
343        ///
344        /// Note that the call can be any function call, not just those defined in this
345        /// contract. Prefer using the other methods for building type-safe contract calls.
346        pub fn call_builder<C: alloy_sol_types::SolCall>(
347            &self,
348            call: &C,
349        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
350            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
351        }
352    }
353    /// Event filters.
354    #[automatically_derived]
355    impl<
356        T: alloy_contract::private::Transport + ::core::clone::Clone,
357        P: alloy_contract::private::Provider<T, N>,
358        N: alloy_contract::private::Network,
359    > CommonInstance<T, P, N> {
360        /// Creates a new event filter using this contract instance's provider and address.
361        ///
362        /// Note that the type can be any event, not just those defined in this contract.
363        /// Prefer using the other methods for building type-safe event filters.
364        pub fn event_filter<E: alloy_sol_types::SolEvent>(
365            &self,
366        ) -> alloy_contract::Event<T, &P, E, N> {
367            alloy_contract::Event::new_sol(&self.provider, &self.address)
368        }
369    }
370}
371///Module containing a contract's types and functions.
372/**
373
374```solidity
375library IBalanceKeeper {
376    type DealDepositReason is uint8;
377}
378```*/
379#[allow(
380    non_camel_case_types,
381    non_snake_case,
382    clippy::pub_underscore_fields,
383    clippy::style,
384    clippy::empty_structs_with_brackets
385)]
386pub mod IBalanceKeeper {
387    use super::*;
388    use alloy::sol_types as alloy_sol_types;
389    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
390    #[derive(Clone)]
391    pub struct DealDepositReason(u8);
392    const _: () = {
393        use alloy::sol_types as alloy_sol_types;
394        #[automatically_derived]
395        impl alloy_sol_types::private::SolTypeValue<DealDepositReason> for u8 {
396            #[inline]
397            fn stv_to_tokens(
398                &self,
399            ) -> <alloy::sol_types::sol_data::Uint<
400                8,
401            > as alloy_sol_types::SolType>::Token<'_> {
402                alloy_sol_types::private::SolTypeValue::<
403                    alloy::sol_types::sol_data::Uint<8>,
404                >::stv_to_tokens(self)
405            }
406            #[inline]
407            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
408                <alloy::sol_types::sol_data::Uint<
409                    8,
410                > as alloy_sol_types::SolType>::tokenize(self)
411                    .0
412            }
413            #[inline]
414            fn stv_abi_encode_packed_to(
415                &self,
416                out: &mut alloy_sol_types::private::Vec<u8>,
417            ) {
418                <alloy::sol_types::sol_data::Uint<
419                    8,
420                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
421            }
422            #[inline]
423            fn stv_abi_packed_encoded_size(&self) -> usize {
424                <alloy::sol_types::sol_data::Uint<
425                    8,
426                > as alloy_sol_types::SolType>::abi_encoded_size(self)
427            }
428        }
429        #[automatically_derived]
430        impl DealDepositReason {
431            /// The Solidity type name.
432            pub const NAME: &'static str = stringify!(@ name);
433            /// Convert from the underlying value type.
434            #[inline]
435            pub const fn from(value: u8) -> Self {
436                Self(value)
437            }
438            /// Return the underlying value.
439            #[inline]
440            pub const fn into(self) -> u8 {
441                self.0
442            }
443            /// Return the single encoding of this value, delegating to the
444            /// underlying type.
445            #[inline]
446            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
447                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
448            }
449            /// Return the packed encoding of this value, delegating to the
450            /// underlying type.
451            #[inline]
452            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
453                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
454            }
455        }
456        #[automatically_derived]
457        impl alloy_sol_types::SolType for DealDepositReason {
458            type RustType = u8;
459            type Token<'a> = <alloy::sol_types::sol_data::Uint<
460                8,
461            > as alloy_sol_types::SolType>::Token<'a>;
462            const SOL_NAME: &'static str = Self::NAME;
463            const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
464                8,
465            > as alloy_sol_types::SolType>::ENCODED_SIZE;
466            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
467                8,
468            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
469            #[inline]
470            fn valid_token(token: &Self::Token<'_>) -> bool {
471                Self::type_check(token).is_ok()
472            }
473            #[inline]
474            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
475                <alloy::sol_types::sol_data::Uint<
476                    8,
477                > as alloy_sol_types::SolType>::type_check(token)
478            }
479            #[inline]
480            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
481                <alloy::sol_types::sol_data::Uint<
482                    8,
483                > as alloy_sol_types::SolType>::detokenize(token)
484            }
485        }
486        #[automatically_derived]
487        impl alloy_sol_types::EventTopic for DealDepositReason {
488            #[inline]
489            fn topic_preimage_length(rust: &Self::RustType) -> usize {
490                <alloy::sol_types::sol_data::Uint<
491                    8,
492                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
493            }
494            #[inline]
495            fn encode_topic_preimage(
496                rust: &Self::RustType,
497                out: &mut alloy_sol_types::private::Vec<u8>,
498            ) {
499                <alloy::sol_types::sol_data::Uint<
500                    8,
501                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
502            }
503            #[inline]
504            fn encode_topic(
505                rust: &Self::RustType,
506            ) -> alloy_sol_types::abi::token::WordToken {
507                <alloy::sol_types::sol_data::Uint<
508                    8,
509                > as alloy_sol_types::EventTopic>::encode_topic(rust)
510            }
511        }
512    };
513    use alloy::contract as alloy_contract;
514    /**Creates a new wrapper around an on-chain [`IBalanceKeeper`](self) contract instance.
515
516See the [wrapper's documentation](`IBalanceKeeperInstance`) for more details.*/
517    #[inline]
518    pub const fn new<
519        T: alloy_contract::private::Transport + ::core::clone::Clone,
520        P: alloy_contract::private::Provider<T, N>,
521        N: alloy_contract::private::Network,
522    >(
523        address: alloy_sol_types::private::Address,
524        provider: P,
525    ) -> IBalanceKeeperInstance<T, P, N> {
526        IBalanceKeeperInstance::<T, P, N>::new(address, provider)
527    }
528    /**A [`IBalanceKeeper`](self) instance.
529
530Contains type-safe methods for interacting with an on-chain instance of the
531[`IBalanceKeeper`](self) contract located at a given `address`, using a given
532provider `P`.
533
534If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
535documentation on how to provide it), the `deploy` and `deploy_builder` methods can
536be used to deploy a new instance of the contract.
537
538See the [module-level documentation](self) for all the available methods.*/
539    #[derive(Clone)]
540    pub struct IBalanceKeeperInstance<T, P, N = alloy_contract::private::Ethereum> {
541        address: alloy_sol_types::private::Address,
542        provider: P,
543        _network_transport: ::core::marker::PhantomData<(N, T)>,
544    }
545    #[automatically_derived]
546    impl<T, P, N> ::core::fmt::Debug for IBalanceKeeperInstance<T, P, N> {
547        #[inline]
548        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
549            f.debug_tuple("IBalanceKeeperInstance").field(&self.address).finish()
550        }
551    }
552    /// Instantiation and getters/setters.
553    #[automatically_derived]
554    impl<
555        T: alloy_contract::private::Transport + ::core::clone::Clone,
556        P: alloy_contract::private::Provider<T, N>,
557        N: alloy_contract::private::Network,
558    > IBalanceKeeperInstance<T, P, N> {
559        /**Creates a new wrapper around an on-chain [`IBalanceKeeper`](self) contract instance.
560
561See the [wrapper's documentation](`IBalanceKeeperInstance`) for more details.*/
562        #[inline]
563        pub const fn new(
564            address: alloy_sol_types::private::Address,
565            provider: P,
566        ) -> Self {
567            Self {
568                address,
569                provider,
570                _network_transport: ::core::marker::PhantomData,
571            }
572        }
573        /// Returns a reference to the address.
574        #[inline]
575        pub const fn address(&self) -> &alloy_sol_types::private::Address {
576            &self.address
577        }
578        /// Sets the address.
579        #[inline]
580        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
581            self.address = address;
582        }
583        /// Sets the address and returns `self`.
584        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
585            self.set_address(address);
586            self
587        }
588        /// Returns a reference to the provider.
589        #[inline]
590        pub const fn provider(&self) -> &P {
591            &self.provider
592        }
593    }
594    impl<T, P: ::core::clone::Clone, N> IBalanceKeeperInstance<T, &P, N> {
595        /// Clones the provider and returns a new instance with the cloned provider.
596        #[inline]
597        pub fn with_cloned_provider(self) -> IBalanceKeeperInstance<T, P, N> {
598            IBalanceKeeperInstance {
599                address: self.address,
600                provider: ::core::clone::Clone::clone(&self.provider),
601                _network_transport: ::core::marker::PhantomData,
602            }
603        }
604    }
605    /// Function calls.
606    #[automatically_derived]
607    impl<
608        T: alloy_contract::private::Transport + ::core::clone::Clone,
609        P: alloy_contract::private::Provider<T, N>,
610        N: alloy_contract::private::Network,
611    > IBalanceKeeperInstance<T, P, N> {
612        /// Creates a new call builder using this contract instance's provider and address.
613        ///
614        /// Note that the call can be any function call, not just those defined in this
615        /// contract. Prefer using the other methods for building type-safe contract calls.
616        pub fn call_builder<C: alloy_sol_types::SolCall>(
617            &self,
618            call: &C,
619        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
620            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
621        }
622    }
623    /// Event filters.
624    #[automatically_derived]
625    impl<
626        T: alloy_contract::private::Transport + ::core::clone::Clone,
627        P: alloy_contract::private::Provider<T, N>,
628        N: alloy_contract::private::Network,
629    > IBalanceKeeperInstance<T, P, N> {
630        /// Creates a new event filter using this contract instance's provider and address.
631        ///
632        /// Note that the type can be any event, not just those defined in this contract.
633        /// Prefer using the other methods for building type-safe event filters.
634        pub fn event_filter<E: alloy_sol_types::SolEvent>(
635            &self,
636        ) -> alloy_contract::Event<T, &P, E, N> {
637            alloy_contract::Event::new_sol(&self.provider, &self.address)
638        }
639    }
640}
641///Module containing a contract's types and functions.
642/**
643
644```solidity
645library IConfigV2 {
646    type AccessTypeV2 is uint8;
647}
648```*/
649#[allow(
650    non_camel_case_types,
651    non_snake_case,
652    clippy::pub_underscore_fields,
653    clippy::style,
654    clippy::empty_structs_with_brackets
655)]
656pub mod IConfigV2 {
657    use super::*;
658    use alloy::sol_types as alloy_sol_types;
659    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
660    #[derive(Clone)]
661    pub struct AccessTypeV2(u8);
662    const _: () = {
663        use alloy::sol_types as alloy_sol_types;
664        #[automatically_derived]
665        impl alloy_sol_types::private::SolTypeValue<AccessTypeV2> for u8 {
666            #[inline]
667            fn stv_to_tokens(
668                &self,
669            ) -> <alloy::sol_types::sol_data::Uint<
670                8,
671            > as alloy_sol_types::SolType>::Token<'_> {
672                alloy_sol_types::private::SolTypeValue::<
673                    alloy::sol_types::sol_data::Uint<8>,
674                >::stv_to_tokens(self)
675            }
676            #[inline]
677            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
678                <alloy::sol_types::sol_data::Uint<
679                    8,
680                > as alloy_sol_types::SolType>::tokenize(self)
681                    .0
682            }
683            #[inline]
684            fn stv_abi_encode_packed_to(
685                &self,
686                out: &mut alloy_sol_types::private::Vec<u8>,
687            ) {
688                <alloy::sol_types::sol_data::Uint<
689                    8,
690                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
691            }
692            #[inline]
693            fn stv_abi_packed_encoded_size(&self) -> usize {
694                <alloy::sol_types::sol_data::Uint<
695                    8,
696                > as alloy_sol_types::SolType>::abi_encoded_size(self)
697            }
698        }
699        #[automatically_derived]
700        impl AccessTypeV2 {
701            /// The Solidity type name.
702            pub const NAME: &'static str = stringify!(@ name);
703            /// Convert from the underlying value type.
704            #[inline]
705            pub const fn from(value: u8) -> Self {
706                Self(value)
707            }
708            /// Return the underlying value.
709            #[inline]
710            pub const fn into(self) -> u8 {
711                self.0
712            }
713            /// Return the single encoding of this value, delegating to the
714            /// underlying type.
715            #[inline]
716            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
717                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
718            }
719            /// Return the packed encoding of this value, delegating to the
720            /// underlying type.
721            #[inline]
722            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
723                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
724            }
725        }
726        #[automatically_derived]
727        impl alloy_sol_types::SolType for AccessTypeV2 {
728            type RustType = u8;
729            type Token<'a> = <alloy::sol_types::sol_data::Uint<
730                8,
731            > as alloy_sol_types::SolType>::Token<'a>;
732            const SOL_NAME: &'static str = Self::NAME;
733            const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
734                8,
735            > as alloy_sol_types::SolType>::ENCODED_SIZE;
736            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
737                8,
738            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
739            #[inline]
740            fn valid_token(token: &Self::Token<'_>) -> bool {
741                Self::type_check(token).is_ok()
742            }
743            #[inline]
744            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
745                <alloy::sol_types::sol_data::Uint<
746                    8,
747                > as alloy_sol_types::SolType>::type_check(token)
748            }
749            #[inline]
750            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
751                <alloy::sol_types::sol_data::Uint<
752                    8,
753                > as alloy_sol_types::SolType>::detokenize(token)
754            }
755        }
756        #[automatically_derived]
757        impl alloy_sol_types::EventTopic for AccessTypeV2 {
758            #[inline]
759            fn topic_preimage_length(rust: &Self::RustType) -> usize {
760                <alloy::sol_types::sol_data::Uint<
761                    8,
762                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
763            }
764            #[inline]
765            fn encode_topic_preimage(
766                rust: &Self::RustType,
767                out: &mut alloy_sol_types::private::Vec<u8>,
768            ) {
769                <alloy::sol_types::sol_data::Uint<
770                    8,
771                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
772            }
773            #[inline]
774            fn encode_topic(
775                rust: &Self::RustType,
776            ) -> alloy_sol_types::abi::token::WordToken {
777                <alloy::sol_types::sol_data::Uint<
778                    8,
779                > as alloy_sol_types::EventTopic>::encode_topic(rust)
780            }
781        }
782    };
783    use alloy::contract as alloy_contract;
784    /**Creates a new wrapper around an on-chain [`IConfigV2`](self) contract instance.
785
786See the [wrapper's documentation](`IConfigV2Instance`) for more details.*/
787    #[inline]
788    pub const fn new<
789        T: alloy_contract::private::Transport + ::core::clone::Clone,
790        P: alloy_contract::private::Provider<T, N>,
791        N: alloy_contract::private::Network,
792    >(
793        address: alloy_sol_types::private::Address,
794        provider: P,
795    ) -> IConfigV2Instance<T, P, N> {
796        IConfigV2Instance::<T, P, N>::new(address, provider)
797    }
798    /**A [`IConfigV2`](self) instance.
799
800Contains type-safe methods for interacting with an on-chain instance of the
801[`IConfigV2`](self) contract located at a given `address`, using a given
802provider `P`.
803
804If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
805documentation on how to provide it), the `deploy` and `deploy_builder` methods can
806be used to deploy a new instance of the contract.
807
808See the [module-level documentation](self) for all the available methods.*/
809    #[derive(Clone)]
810    pub struct IConfigV2Instance<T, P, N = alloy_contract::private::Ethereum> {
811        address: alloy_sol_types::private::Address,
812        provider: P,
813        _network_transport: ::core::marker::PhantomData<(N, T)>,
814    }
815    #[automatically_derived]
816    impl<T, P, N> ::core::fmt::Debug for IConfigV2Instance<T, P, N> {
817        #[inline]
818        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
819            f.debug_tuple("IConfigV2Instance").field(&self.address).finish()
820        }
821    }
822    /// Instantiation and getters/setters.
823    #[automatically_derived]
824    impl<
825        T: alloy_contract::private::Transport + ::core::clone::Clone,
826        P: alloy_contract::private::Provider<T, N>,
827        N: alloy_contract::private::Network,
828    > IConfigV2Instance<T, P, N> {
829        /**Creates a new wrapper around an on-chain [`IConfigV2`](self) contract instance.
830
831See the [wrapper's documentation](`IConfigV2Instance`) for more details.*/
832        #[inline]
833        pub const fn new(
834            address: alloy_sol_types::private::Address,
835            provider: P,
836        ) -> Self {
837            Self {
838                address,
839                provider,
840                _network_transport: ::core::marker::PhantomData,
841            }
842        }
843        /// Returns a reference to the address.
844        #[inline]
845        pub const fn address(&self) -> &alloy_sol_types::private::Address {
846            &self.address
847        }
848        /// Sets the address.
849        #[inline]
850        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
851            self.address = address;
852        }
853        /// Sets the address and returns `self`.
854        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
855            self.set_address(address);
856            self
857        }
858        /// Returns a reference to the provider.
859        #[inline]
860        pub const fn provider(&self) -> &P {
861            &self.provider
862        }
863    }
864    impl<T, P: ::core::clone::Clone, N> IConfigV2Instance<T, &P, N> {
865        /// Clones the provider and returns a new instance with the cloned provider.
866        #[inline]
867        pub fn with_cloned_provider(self) -> IConfigV2Instance<T, P, N> {
868            IConfigV2Instance {
869                address: self.address,
870                provider: ::core::clone::Clone::clone(&self.provider),
871                _network_transport: ::core::marker::PhantomData,
872            }
873        }
874    }
875    /// Function calls.
876    #[automatically_derived]
877    impl<
878        T: alloy_contract::private::Transport + ::core::clone::Clone,
879        P: alloy_contract::private::Provider<T, N>,
880        N: alloy_contract::private::Network,
881    > IConfigV2Instance<T, P, N> {
882        /// Creates a new call builder using this contract instance's provider and address.
883        ///
884        /// Note that the call can be any function call, not just those defined in this
885        /// contract. Prefer using the other methods for building type-safe contract calls.
886        pub fn call_builder<C: alloy_sol_types::SolCall>(
887            &self,
888            call: &C,
889        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
890            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
891        }
892    }
893    /// Event filters.
894    #[automatically_derived]
895    impl<
896        T: alloy_contract::private::Transport + ::core::clone::Clone,
897        P: alloy_contract::private::Provider<T, N>,
898        N: alloy_contract::private::Network,
899    > IConfigV2Instance<T, P, N> {
900        /// Creates a new event filter using this contract instance's provider and address.
901        ///
902        /// Note that the type can be any event, not just those defined in this contract.
903        /// Prefer using the other methods for building type-safe event filters.
904        pub fn event_filter<E: alloy_sol_types::SolEvent>(
905            &self,
906        ) -> alloy_contract::Event<T, &P, E, N> {
907            alloy_contract::Event::new_sol(&self.provider, &self.address)
908        }
909    }
910}
911///Module containing a contract's types and functions.
912/**
913
914```solidity
915library IOfferV2 {
916    type ResourceType is uint8;
917    struct ResourceRequirement { bytes32 resourceId; ResourceType ty; uint256 quantity; }
918}
919```*/
920#[allow(
921    non_camel_case_types,
922    non_snake_case,
923    clippy::pub_underscore_fields,
924    clippy::style,
925    clippy::empty_structs_with_brackets
926)]
927pub mod IOfferV2 {
928    use super::*;
929    use alloy::sol_types as alloy_sol_types;
930    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
931    #[derive(Clone)]
932    pub struct ResourceType(u8);
933    const _: () = {
934        use alloy::sol_types as alloy_sol_types;
935        #[automatically_derived]
936        impl alloy_sol_types::private::SolTypeValue<ResourceType> for u8 {
937            #[inline]
938            fn stv_to_tokens(
939                &self,
940            ) -> <alloy::sol_types::sol_data::Uint<
941                8,
942            > as alloy_sol_types::SolType>::Token<'_> {
943                alloy_sol_types::private::SolTypeValue::<
944                    alloy::sol_types::sol_data::Uint<8>,
945                >::stv_to_tokens(self)
946            }
947            #[inline]
948            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
949                <alloy::sol_types::sol_data::Uint<
950                    8,
951                > as alloy_sol_types::SolType>::tokenize(self)
952                    .0
953            }
954            #[inline]
955            fn stv_abi_encode_packed_to(
956                &self,
957                out: &mut alloy_sol_types::private::Vec<u8>,
958            ) {
959                <alloy::sol_types::sol_data::Uint<
960                    8,
961                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
962            }
963            #[inline]
964            fn stv_abi_packed_encoded_size(&self) -> usize {
965                <alloy::sol_types::sol_data::Uint<
966                    8,
967                > as alloy_sol_types::SolType>::abi_encoded_size(self)
968            }
969        }
970        #[automatically_derived]
971        impl ResourceType {
972            /// The Solidity type name.
973            pub const NAME: &'static str = stringify!(@ name);
974            /// Convert from the underlying value type.
975            #[inline]
976            pub const fn from(value: u8) -> Self {
977                Self(value)
978            }
979            /// Return the underlying value.
980            #[inline]
981            pub const fn into(self) -> u8 {
982                self.0
983            }
984            /// Return the single encoding of this value, delegating to the
985            /// underlying type.
986            #[inline]
987            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
988                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
989            }
990            /// Return the packed encoding of this value, delegating to the
991            /// underlying type.
992            #[inline]
993            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
994                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
995            }
996        }
997        #[automatically_derived]
998        impl alloy_sol_types::SolType for ResourceType {
999            type RustType = u8;
1000            type Token<'a> = <alloy::sol_types::sol_data::Uint<
1001                8,
1002            > as alloy_sol_types::SolType>::Token<'a>;
1003            const SOL_NAME: &'static str = Self::NAME;
1004            const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
1005                8,
1006            > as alloy_sol_types::SolType>::ENCODED_SIZE;
1007            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
1008                8,
1009            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1010            #[inline]
1011            fn valid_token(token: &Self::Token<'_>) -> bool {
1012                Self::type_check(token).is_ok()
1013            }
1014            #[inline]
1015            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
1016                <alloy::sol_types::sol_data::Uint<
1017                    8,
1018                > as alloy_sol_types::SolType>::type_check(token)
1019            }
1020            #[inline]
1021            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1022                <alloy::sol_types::sol_data::Uint<
1023                    8,
1024                > as alloy_sol_types::SolType>::detokenize(token)
1025            }
1026        }
1027        #[automatically_derived]
1028        impl alloy_sol_types::EventTopic for ResourceType {
1029            #[inline]
1030            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1031                <alloy::sol_types::sol_data::Uint<
1032                    8,
1033                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
1034            }
1035            #[inline]
1036            fn encode_topic_preimage(
1037                rust: &Self::RustType,
1038                out: &mut alloy_sol_types::private::Vec<u8>,
1039            ) {
1040                <alloy::sol_types::sol_data::Uint<
1041                    8,
1042                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
1043            }
1044            #[inline]
1045            fn encode_topic(
1046                rust: &Self::RustType,
1047            ) -> alloy_sol_types::abi::token::WordToken {
1048                <alloy::sol_types::sol_data::Uint<
1049                    8,
1050                > as alloy_sol_types::EventTopic>::encode_topic(rust)
1051            }
1052        }
1053    };
1054    /**```solidity
1055struct ResourceRequirement { bytes32 resourceId; ResourceType ty; uint256 quantity; }
1056```*/
1057    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1058    #[derive(Clone)]
1059    pub struct ResourceRequirement {
1060        #[allow(missing_docs)]
1061        pub resourceId: alloy::sol_types::private::FixedBytes<32>,
1062        #[allow(missing_docs)]
1063        pub ty: <ResourceType as alloy::sol_types::SolType>::RustType,
1064        #[allow(missing_docs)]
1065        pub quantity: alloy::sol_types::private::primitives::aliases::U256,
1066    }
1067    #[allow(
1068        non_camel_case_types,
1069        non_snake_case,
1070        clippy::pub_underscore_fields,
1071        clippy::style
1072    )]
1073    const _: () = {
1074        use alloy::sol_types as alloy_sol_types;
1075        #[doc(hidden)]
1076        type UnderlyingSolTuple<'a> = (
1077            alloy::sol_types::sol_data::FixedBytes<32>,
1078            ResourceType,
1079            alloy::sol_types::sol_data::Uint<256>,
1080        );
1081        #[doc(hidden)]
1082        type UnderlyingRustTuple<'a> = (
1083            alloy::sol_types::private::FixedBytes<32>,
1084            <ResourceType as alloy::sol_types::SolType>::RustType,
1085            alloy::sol_types::private::primitives::aliases::U256,
1086        );
1087        #[cfg(test)]
1088        #[allow(dead_code, unreachable_patterns)]
1089        fn _type_assertion(
1090            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1091        ) {
1092            match _t {
1093                alloy_sol_types::private::AssertTypeEq::<
1094                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1095                >(_) => {}
1096            }
1097        }
1098        #[automatically_derived]
1099        #[doc(hidden)]
1100        impl ::core::convert::From<ResourceRequirement> for UnderlyingRustTuple<'_> {
1101            fn from(value: ResourceRequirement) -> Self {
1102                (value.resourceId, value.ty, value.quantity)
1103            }
1104        }
1105        #[automatically_derived]
1106        #[doc(hidden)]
1107        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ResourceRequirement {
1108            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1109                Self {
1110                    resourceId: tuple.0,
1111                    ty: tuple.1,
1112                    quantity: tuple.2,
1113                }
1114            }
1115        }
1116        #[automatically_derived]
1117        impl alloy_sol_types::SolValue for ResourceRequirement {
1118            type SolType = Self;
1119        }
1120        #[automatically_derived]
1121        impl alloy_sol_types::private::SolTypeValue<Self> for ResourceRequirement {
1122            #[inline]
1123            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1124                (
1125                    <alloy::sol_types::sol_data::FixedBytes<
1126                        32,
1127                    > as alloy_sol_types::SolType>::tokenize(&self.resourceId),
1128                    <ResourceType as alloy_sol_types::SolType>::tokenize(&self.ty),
1129                    <alloy::sol_types::sol_data::Uint<
1130                        256,
1131                    > as alloy_sol_types::SolType>::tokenize(&self.quantity),
1132                )
1133            }
1134            #[inline]
1135            fn stv_abi_encoded_size(&self) -> usize {
1136                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1137                    return size;
1138                }
1139                let tuple = <UnderlyingRustTuple<
1140                    '_,
1141                > as ::core::convert::From<Self>>::from(self.clone());
1142                <UnderlyingSolTuple<
1143                    '_,
1144                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1145            }
1146            #[inline]
1147            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1148                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1149            }
1150            #[inline]
1151            fn stv_abi_encode_packed_to(
1152                &self,
1153                out: &mut alloy_sol_types::private::Vec<u8>,
1154            ) {
1155                let tuple = <UnderlyingRustTuple<
1156                    '_,
1157                > as ::core::convert::From<Self>>::from(self.clone());
1158                <UnderlyingSolTuple<
1159                    '_,
1160                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1161            }
1162            #[inline]
1163            fn stv_abi_packed_encoded_size(&self) -> usize {
1164                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1165                    return size;
1166                }
1167                let tuple = <UnderlyingRustTuple<
1168                    '_,
1169                > as ::core::convert::From<Self>>::from(self.clone());
1170                <UnderlyingSolTuple<
1171                    '_,
1172                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1173            }
1174        }
1175        #[automatically_derived]
1176        impl alloy_sol_types::SolType for ResourceRequirement {
1177            type RustType = Self;
1178            type Token<'a> = <UnderlyingSolTuple<
1179                'a,
1180            > as alloy_sol_types::SolType>::Token<'a>;
1181            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1182            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1183                '_,
1184            > as alloy_sol_types::SolType>::ENCODED_SIZE;
1185            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1186                '_,
1187            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1188            #[inline]
1189            fn valid_token(token: &Self::Token<'_>) -> bool {
1190                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1191            }
1192            #[inline]
1193            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1194                let tuple = <UnderlyingSolTuple<
1195                    '_,
1196                > as alloy_sol_types::SolType>::detokenize(token);
1197                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1198            }
1199        }
1200        #[automatically_derived]
1201        impl alloy_sol_types::SolStruct for ResourceRequirement {
1202            const NAME: &'static str = "ResourceRequirement";
1203            #[inline]
1204            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1205                alloy_sol_types::private::Cow::Borrowed(
1206                    "ResourceRequirement(bytes32 resourceId,uint8 ty,uint256 quantity)",
1207                )
1208            }
1209            #[inline]
1210            fn eip712_components() -> alloy_sol_types::private::Vec<
1211                alloy_sol_types::private::Cow<'static, str>,
1212            > {
1213                alloy_sol_types::private::Vec::new()
1214            }
1215            #[inline]
1216            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1217                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1218            }
1219            #[inline]
1220            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1221                [
1222                    <alloy::sol_types::sol_data::FixedBytes<
1223                        32,
1224                    > as alloy_sol_types::SolType>::eip712_data_word(&self.resourceId)
1225                        .0,
1226                    <ResourceType as alloy_sol_types::SolType>::eip712_data_word(
1227                            &self.ty,
1228                        )
1229                        .0,
1230                    <alloy::sol_types::sol_data::Uint<
1231                        256,
1232                    > as alloy_sol_types::SolType>::eip712_data_word(&self.quantity)
1233                        .0,
1234                ]
1235                    .concat()
1236            }
1237        }
1238        #[automatically_derived]
1239        impl alloy_sol_types::EventTopic for ResourceRequirement {
1240            #[inline]
1241            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1242                0usize
1243                    + <alloy::sol_types::sol_data::FixedBytes<
1244                        32,
1245                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1246                        &rust.resourceId,
1247                    )
1248                    + <ResourceType as alloy_sol_types::EventTopic>::topic_preimage_length(
1249                        &rust.ty,
1250                    )
1251                    + <alloy::sol_types::sol_data::Uint<
1252                        256,
1253                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1254                        &rust.quantity,
1255                    )
1256            }
1257            #[inline]
1258            fn encode_topic_preimage(
1259                rust: &Self::RustType,
1260                out: &mut alloy_sol_types::private::Vec<u8>,
1261            ) {
1262                out.reserve(
1263                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1264                );
1265                <alloy::sol_types::sol_data::FixedBytes<
1266                    32,
1267                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1268                    &rust.resourceId,
1269                    out,
1270                );
1271                <ResourceType as alloy_sol_types::EventTopic>::encode_topic_preimage(
1272                    &rust.ty,
1273                    out,
1274                );
1275                <alloy::sol_types::sol_data::Uint<
1276                    256,
1277                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1278                    &rust.quantity,
1279                    out,
1280                );
1281            }
1282            #[inline]
1283            fn encode_topic(
1284                rust: &Self::RustType,
1285            ) -> alloy_sol_types::abi::token::WordToken {
1286                let mut out = alloy_sol_types::private::Vec::new();
1287                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1288                    rust,
1289                    &mut out,
1290                );
1291                alloy_sol_types::abi::token::WordToken(
1292                    alloy_sol_types::private::keccak256(out),
1293                )
1294            }
1295        }
1296    };
1297    use alloy::contract as alloy_contract;
1298    /**Creates a new wrapper around an on-chain [`IOfferV2`](self) contract instance.
1299
1300See the [wrapper's documentation](`IOfferV2Instance`) for more details.*/
1301    #[inline]
1302    pub const fn new<
1303        T: alloy_contract::private::Transport + ::core::clone::Clone,
1304        P: alloy_contract::private::Provider<T, N>,
1305        N: alloy_contract::private::Network,
1306    >(
1307        address: alloy_sol_types::private::Address,
1308        provider: P,
1309    ) -> IOfferV2Instance<T, P, N> {
1310        IOfferV2Instance::<T, P, N>::new(address, provider)
1311    }
1312    /**A [`IOfferV2`](self) instance.
1313
1314Contains type-safe methods for interacting with an on-chain instance of the
1315[`IOfferV2`](self) contract located at a given `address`, using a given
1316provider `P`.
1317
1318If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1319documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1320be used to deploy a new instance of the contract.
1321
1322See the [module-level documentation](self) for all the available methods.*/
1323    #[derive(Clone)]
1324    pub struct IOfferV2Instance<T, P, N = alloy_contract::private::Ethereum> {
1325        address: alloy_sol_types::private::Address,
1326        provider: P,
1327        _network_transport: ::core::marker::PhantomData<(N, T)>,
1328    }
1329    #[automatically_derived]
1330    impl<T, P, N> ::core::fmt::Debug for IOfferV2Instance<T, P, N> {
1331        #[inline]
1332        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1333            f.debug_tuple("IOfferV2Instance").field(&self.address).finish()
1334        }
1335    }
1336    /// Instantiation and getters/setters.
1337    #[automatically_derived]
1338    impl<
1339        T: alloy_contract::private::Transport + ::core::clone::Clone,
1340        P: alloy_contract::private::Provider<T, N>,
1341        N: alloy_contract::private::Network,
1342    > IOfferV2Instance<T, P, N> {
1343        /**Creates a new wrapper around an on-chain [`IOfferV2`](self) contract instance.
1344
1345See the [wrapper's documentation](`IOfferV2Instance`) for more details.*/
1346        #[inline]
1347        pub const fn new(
1348            address: alloy_sol_types::private::Address,
1349            provider: P,
1350        ) -> Self {
1351            Self {
1352                address,
1353                provider,
1354                _network_transport: ::core::marker::PhantomData,
1355            }
1356        }
1357        /// Returns a reference to the address.
1358        #[inline]
1359        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1360            &self.address
1361        }
1362        /// Sets the address.
1363        #[inline]
1364        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1365            self.address = address;
1366        }
1367        /// Sets the address and returns `self`.
1368        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1369            self.set_address(address);
1370            self
1371        }
1372        /// Returns a reference to the provider.
1373        #[inline]
1374        pub const fn provider(&self) -> &P {
1375            &self.provider
1376        }
1377    }
1378    impl<T, P: ::core::clone::Clone, N> IOfferV2Instance<T, &P, N> {
1379        /// Clones the provider and returns a new instance with the cloned provider.
1380        #[inline]
1381        pub fn with_cloned_provider(self) -> IOfferV2Instance<T, P, N> {
1382            IOfferV2Instance {
1383                address: self.address,
1384                provider: ::core::clone::Clone::clone(&self.provider),
1385                _network_transport: ::core::marker::PhantomData,
1386            }
1387        }
1388    }
1389    /// Function calls.
1390    #[automatically_derived]
1391    impl<
1392        T: alloy_contract::private::Transport + ::core::clone::Clone,
1393        P: alloy_contract::private::Provider<T, N>,
1394        N: alloy_contract::private::Network,
1395    > IOfferV2Instance<T, P, N> {
1396        /// Creates a new call builder using this contract instance's provider and address.
1397        ///
1398        /// Note that the call can be any function call, not just those defined in this
1399        /// contract. Prefer using the other methods for building type-safe contract calls.
1400        pub fn call_builder<C: alloy_sol_types::SolCall>(
1401            &self,
1402            call: &C,
1403        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
1404            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1405        }
1406    }
1407    /// Event filters.
1408    #[automatically_derived]
1409    impl<
1410        T: alloy_contract::private::Transport + ::core::clone::Clone,
1411        P: alloy_contract::private::Provider<T, N>,
1412        N: alloy_contract::private::Network,
1413    > IOfferV2Instance<T, P, N> {
1414        /// Creates a new event filter using this contract instance's provider and address.
1415        ///
1416        /// Note that the type can be any event, not just those defined in this contract.
1417        /// Prefer using the other methods for building type-safe event filters.
1418        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1419            &self,
1420        ) -> alloy_contract::Event<T, &P, E, N> {
1421            alloy_contract::Event::new_sol(&self.provider, &self.address)
1422        }
1423    }
1424}
1425///Module containing a contract's types and functions.
1426/**
1427
1428```solidity
1429library IWorkerManagerV2 {
1430    struct WorkerDataV2 { bytes32 onchainId; }
1431}
1432```*/
1433#[allow(
1434    non_camel_case_types,
1435    non_snake_case,
1436    clippy::pub_underscore_fields,
1437    clippy::style,
1438    clippy::empty_structs_with_brackets
1439)]
1440pub mod IWorkerManagerV2 {
1441    use super::*;
1442    use alloy::sol_types as alloy_sol_types;
1443    /**```solidity
1444struct WorkerDataV2 { bytes32 onchainId; }
1445```*/
1446    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1447    #[derive(Clone)]
1448    pub struct WorkerDataV2 {
1449        #[allow(missing_docs)]
1450        pub onchainId: alloy::sol_types::private::FixedBytes<32>,
1451    }
1452    #[allow(
1453        non_camel_case_types,
1454        non_snake_case,
1455        clippy::pub_underscore_fields,
1456        clippy::style
1457    )]
1458    const _: () = {
1459        use alloy::sol_types as alloy_sol_types;
1460        #[doc(hidden)]
1461        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1462        #[doc(hidden)]
1463        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1464        #[cfg(test)]
1465        #[allow(dead_code, unreachable_patterns)]
1466        fn _type_assertion(
1467            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1468        ) {
1469            match _t {
1470                alloy_sol_types::private::AssertTypeEq::<
1471                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1472                >(_) => {}
1473            }
1474        }
1475        #[automatically_derived]
1476        #[doc(hidden)]
1477        impl ::core::convert::From<WorkerDataV2> for UnderlyingRustTuple<'_> {
1478            fn from(value: WorkerDataV2) -> Self {
1479                (value.onchainId,)
1480            }
1481        }
1482        #[automatically_derived]
1483        #[doc(hidden)]
1484        impl ::core::convert::From<UnderlyingRustTuple<'_>> for WorkerDataV2 {
1485            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1486                Self { onchainId: tuple.0 }
1487            }
1488        }
1489        #[automatically_derived]
1490        impl alloy_sol_types::SolValue for WorkerDataV2 {
1491            type SolType = Self;
1492        }
1493        #[automatically_derived]
1494        impl alloy_sol_types::private::SolTypeValue<Self> for WorkerDataV2 {
1495            #[inline]
1496            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1497                (
1498                    <alloy::sol_types::sol_data::FixedBytes<
1499                        32,
1500                    > as alloy_sol_types::SolType>::tokenize(&self.onchainId),
1501                )
1502            }
1503            #[inline]
1504            fn stv_abi_encoded_size(&self) -> usize {
1505                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1506                    return size;
1507                }
1508                let tuple = <UnderlyingRustTuple<
1509                    '_,
1510                > as ::core::convert::From<Self>>::from(self.clone());
1511                <UnderlyingSolTuple<
1512                    '_,
1513                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1514            }
1515            #[inline]
1516            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1517                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1518            }
1519            #[inline]
1520            fn stv_abi_encode_packed_to(
1521                &self,
1522                out: &mut alloy_sol_types::private::Vec<u8>,
1523            ) {
1524                let tuple = <UnderlyingRustTuple<
1525                    '_,
1526                > as ::core::convert::From<Self>>::from(self.clone());
1527                <UnderlyingSolTuple<
1528                    '_,
1529                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1530            }
1531            #[inline]
1532            fn stv_abi_packed_encoded_size(&self) -> usize {
1533                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1534                    return size;
1535                }
1536                let tuple = <UnderlyingRustTuple<
1537                    '_,
1538                > as ::core::convert::From<Self>>::from(self.clone());
1539                <UnderlyingSolTuple<
1540                    '_,
1541                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1542            }
1543        }
1544        #[automatically_derived]
1545        impl alloy_sol_types::SolType for WorkerDataV2 {
1546            type RustType = Self;
1547            type Token<'a> = <UnderlyingSolTuple<
1548                'a,
1549            > as alloy_sol_types::SolType>::Token<'a>;
1550            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1551            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1552                '_,
1553            > as alloy_sol_types::SolType>::ENCODED_SIZE;
1554            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1555                '_,
1556            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1557            #[inline]
1558            fn valid_token(token: &Self::Token<'_>) -> bool {
1559                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1560            }
1561            #[inline]
1562            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1563                let tuple = <UnderlyingSolTuple<
1564                    '_,
1565                > as alloy_sol_types::SolType>::detokenize(token);
1566                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1567            }
1568        }
1569        #[automatically_derived]
1570        impl alloy_sol_types::SolStruct for WorkerDataV2 {
1571            const NAME: &'static str = "WorkerDataV2";
1572            #[inline]
1573            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1574                alloy_sol_types::private::Cow::Borrowed(
1575                    "WorkerDataV2(bytes32 onchainId)",
1576                )
1577            }
1578            #[inline]
1579            fn eip712_components() -> alloy_sol_types::private::Vec<
1580                alloy_sol_types::private::Cow<'static, str>,
1581            > {
1582                alloy_sol_types::private::Vec::new()
1583            }
1584            #[inline]
1585            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1586                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1587            }
1588            #[inline]
1589            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1590                <alloy::sol_types::sol_data::FixedBytes<
1591                    32,
1592                > as alloy_sol_types::SolType>::eip712_data_word(&self.onchainId)
1593                    .0
1594                    .to_vec()
1595            }
1596        }
1597        #[automatically_derived]
1598        impl alloy_sol_types::EventTopic for WorkerDataV2 {
1599            #[inline]
1600            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1601                0usize
1602                    + <alloy::sol_types::sol_data::FixedBytes<
1603                        32,
1604                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1605                        &rust.onchainId,
1606                    )
1607            }
1608            #[inline]
1609            fn encode_topic_preimage(
1610                rust: &Self::RustType,
1611                out: &mut alloy_sol_types::private::Vec<u8>,
1612            ) {
1613                out.reserve(
1614                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1615                );
1616                <alloy::sol_types::sol_data::FixedBytes<
1617                    32,
1618                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1619                    &rust.onchainId,
1620                    out,
1621                );
1622            }
1623            #[inline]
1624            fn encode_topic(
1625                rust: &Self::RustType,
1626            ) -> alloy_sol_types::abi::token::WordToken {
1627                let mut out = alloy_sol_types::private::Vec::new();
1628                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1629                    rust,
1630                    &mut out,
1631                );
1632                alloy_sol_types::abi::token::WordToken(
1633                    alloy_sol_types::private::keccak256(out),
1634                )
1635            }
1636        }
1637    };
1638    use alloy::contract as alloy_contract;
1639    /**Creates a new wrapper around an on-chain [`IWorkerManagerV2`](self) contract instance.
1640
1641See the [wrapper's documentation](`IWorkerManagerV2Instance`) for more details.*/
1642    #[inline]
1643    pub const fn new<
1644        T: alloy_contract::private::Transport + ::core::clone::Clone,
1645        P: alloy_contract::private::Provider<T, N>,
1646        N: alloy_contract::private::Network,
1647    >(
1648        address: alloy_sol_types::private::Address,
1649        provider: P,
1650    ) -> IWorkerManagerV2Instance<T, P, N> {
1651        IWorkerManagerV2Instance::<T, P, N>::new(address, provider)
1652    }
1653    /**A [`IWorkerManagerV2`](self) instance.
1654
1655Contains type-safe methods for interacting with an on-chain instance of the
1656[`IWorkerManagerV2`](self) contract located at a given `address`, using a given
1657provider `P`.
1658
1659If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1660documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1661be used to deploy a new instance of the contract.
1662
1663See the [module-level documentation](self) for all the available methods.*/
1664    #[derive(Clone)]
1665    pub struct IWorkerManagerV2Instance<T, P, N = alloy_contract::private::Ethereum> {
1666        address: alloy_sol_types::private::Address,
1667        provider: P,
1668        _network_transport: ::core::marker::PhantomData<(N, T)>,
1669    }
1670    #[automatically_derived]
1671    impl<T, P, N> ::core::fmt::Debug for IWorkerManagerV2Instance<T, P, N> {
1672        #[inline]
1673        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1674            f.debug_tuple("IWorkerManagerV2Instance").field(&self.address).finish()
1675        }
1676    }
1677    /// Instantiation and getters/setters.
1678    #[automatically_derived]
1679    impl<
1680        T: alloy_contract::private::Transport + ::core::clone::Clone,
1681        P: alloy_contract::private::Provider<T, N>,
1682        N: alloy_contract::private::Network,
1683    > IWorkerManagerV2Instance<T, P, N> {
1684        /**Creates a new wrapper around an on-chain [`IWorkerManagerV2`](self) contract instance.
1685
1686See the [wrapper's documentation](`IWorkerManagerV2Instance`) for more details.*/
1687        #[inline]
1688        pub const fn new(
1689            address: alloy_sol_types::private::Address,
1690            provider: P,
1691        ) -> Self {
1692            Self {
1693                address,
1694                provider,
1695                _network_transport: ::core::marker::PhantomData,
1696            }
1697        }
1698        /// Returns a reference to the address.
1699        #[inline]
1700        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1701            &self.address
1702        }
1703        /// Sets the address.
1704        #[inline]
1705        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1706            self.address = address;
1707        }
1708        /// Sets the address and returns `self`.
1709        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1710            self.set_address(address);
1711            self
1712        }
1713        /// Returns a reference to the provider.
1714        #[inline]
1715        pub const fn provider(&self) -> &P {
1716            &self.provider
1717        }
1718    }
1719    impl<T, P: ::core::clone::Clone, N> IWorkerManagerV2Instance<T, &P, N> {
1720        /// Clones the provider and returns a new instance with the cloned provider.
1721        #[inline]
1722        pub fn with_cloned_provider(self) -> IWorkerManagerV2Instance<T, P, N> {
1723            IWorkerManagerV2Instance {
1724                address: self.address,
1725                provider: ::core::clone::Clone::clone(&self.provider),
1726                _network_transport: ::core::marker::PhantomData,
1727            }
1728        }
1729    }
1730    /// Function calls.
1731    #[automatically_derived]
1732    impl<
1733        T: alloy_contract::private::Transport + ::core::clone::Clone,
1734        P: alloy_contract::private::Provider<T, N>,
1735        N: alloy_contract::private::Network,
1736    > IWorkerManagerV2Instance<T, P, N> {
1737        /// Creates a new call builder using this contract instance's provider and address.
1738        ///
1739        /// Note that the call can be any function call, not just those defined in this
1740        /// contract. Prefer using the other methods for building type-safe contract calls.
1741        pub fn call_builder<C: alloy_sol_types::SolCall>(
1742            &self,
1743            call: &C,
1744        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
1745            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1746        }
1747    }
1748    /// Event filters.
1749    #[automatically_derived]
1750    impl<
1751        T: alloy_contract::private::Transport + ::core::clone::Clone,
1752        P: alloy_contract::private::Provider<T, N>,
1753        N: alloy_contract::private::Network,
1754    > IWorkerManagerV2Instance<T, P, N> {
1755        /// Creates a new event filter using this contract instance's provider and address.
1756        ///
1757        /// Note that the type can be any event, not just those defined in this contract.
1758        /// Prefer using the other methods for building type-safe event filters.
1759        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1760            &self,
1761        ) -> alloy_contract::Event<T, &P, E, N> {
1762            alloy_contract::Event::new_sol(&self.provider, &self.address)
1763        }
1764    }
1765}
1766/**
1767
1768Generated by the following Solidity interface...
1769```solidity
1770library Common {
1771    struct CIDV1 {
1772        bytes4 prefixes;
1773        bytes32 hash;
1774    }
1775}
1776
1777library IBalanceKeeper {
1778    type DealDepositReason is uint8;
1779}
1780
1781library IConfigV2 {
1782    type AccessTypeV2 is uint8;
1783}
1784
1785library IOfferV2 {
1786    type ResourceType is uint8;
1787    struct ResourceRequirement {
1788        bytes32 resourceId;
1789        ResourceType ty;
1790        uint256 quantity;
1791    }
1792}
1793
1794library IWorkerManagerV2 {
1795    struct WorkerDataV2 {
1796        bytes32 onchainId;
1797    }
1798}
1799
1800interface IDealV2 {
1801    type Status is uint8;
1802    struct DealRewards {
1803        uint256 providerReward;
1804        uint256 stakerReward;
1805    }
1806
1807    event AppCIDChanged(Common.CIDV1 newAppCID);
1808    event DealEnded(uint256 endedEpoch);
1809    event Deposited(uint256 amount);
1810    event MaxPaidEpochUpdated(uint256 maxPaidEpoch);
1811    event ProviderAddedToAccessList(address provider);
1812    event ProviderRemovedFromAccessList(address provider);
1813    event ProvidersAccessTypeChanged(IConfigV2.AccessTypeV2 newAccessType);
1814    event RewardWithdrawn(bytes32 onchainWorkerId, uint256 providerReward, uint256 stakerReward);
1815    event Withdrawn(uint256 amount);
1816    event WorkerIdUpdated(bytes32 onchainWorkerId, bytes32 offchainWorkerId);
1817    event WorkerJoined(bytes32 indexed peerId, bytes32 onchainId);
1818    event WorkerRemoved(bytes32 indexed peerId, bytes32 onchainId);
1819
1820    function activateWorker(bytes32 onchainWorkerId, bytes32 offchainWorkerId) external;
1821    function addProviderToAccessList(address provider) external;
1822    function addWorker(address computeProvider, IWorkerManagerV2.WorkerDataV2 memory workerData, bytes32 peerId) external;
1823    function appCID() external view returns (Common.CIDV1 memory);
1824    function changeProvidersAccessType(IConfigV2.AccessTypeV2 accessType) external;
1825    function computePeerUsed(bytes32 peerId) external view returns (bool);
1826    function creationBlock() external view returns (uint256);
1827    function depositFromOwner(uint256 amount, IBalanceKeeper.DealDepositReason reason) external;
1828    function getActivatedWorkerCount() external view returns (uint256);
1829    function getFreeBalance() external view returns (uint256);
1830    function getMaxPaidEpoch() external view returns (uint256);
1831    function getProtocolVersion() external view returns (uint256);
1832    function getRewardAmount(bytes32 onchainWorkerId) external view returns (DealRewards memory);
1833    function getStatus() external view returns (Status);
1834    function getWorkerCount() external view returns (uint256);
1835    function getWorkerCount(address provider) external view returns (uint256);
1836    function getWorkerIds() external view returns (bytes32[] memory);
1837    function initialize(address diamond_, Common.CIDV1 memory appCID_, address paymentToken_, uint256 targetWorkers_, IOfferV2.ResourceRequirement[] memory resources_, uint256 pricePerEpoch_, uint256 maxWorkersPerProvider_, IConfigV2.AccessTypeV2 providersAccessType_, address[] memory providersAccessList_, uint256 protocolVersion_, address owner_) external;
1838    function isProviderAllowed(address account) external view returns (bool);
1839    function maxWorkersPerProvider() external view returns (uint256);
1840    function paymentToken() external view returns (address);
1841    function pricePerEpoch() external view returns (uint256);
1842    function providersAccessType() external view returns (IConfigV2.AccessTypeV2);
1843    function removeProviderFromAccessList(address provider) external;
1844    function removeStaleWorkers(bytes32[] memory onchainWorkerIds) external;
1845    function removeWorker(bytes32 onchainWorkerId) external;
1846    function requiredResources() external view returns (IOfferV2.ResourceRequirement[] memory);
1847    function setAppCID(Common.CIDV1 memory appCID_) external;
1848    function stop() external;
1849    function targetWorkers() external view returns (uint256);
1850    function withdraw(uint256 amount) external;
1851    function withdrawRewards(bytes32 onchainWorkerId) external;
1852}
1853```
1854
1855...which was generated by the following JSON ABI:
1856```json
1857[
1858  {
1859    "type": "function",
1860    "name": "activateWorker",
1861    "inputs": [
1862      {
1863        "name": "onchainWorkerId",
1864        "type": "bytes32",
1865        "internalType": "bytes32"
1866      },
1867      {
1868        "name": "offchainWorkerId",
1869        "type": "bytes32",
1870        "internalType": "bytes32"
1871      }
1872    ],
1873    "outputs": [],
1874    "stateMutability": "nonpayable"
1875  },
1876  {
1877    "type": "function",
1878    "name": "addProviderToAccessList",
1879    "inputs": [
1880      {
1881        "name": "provider",
1882        "type": "address",
1883        "internalType": "address"
1884      }
1885    ],
1886    "outputs": [],
1887    "stateMutability": "nonpayable"
1888  },
1889  {
1890    "type": "function",
1891    "name": "addWorker",
1892    "inputs": [
1893      {
1894        "name": "computeProvider",
1895        "type": "address",
1896        "internalType": "address"
1897      },
1898      {
1899        "name": "workerData",
1900        "type": "tuple",
1901        "internalType": "struct IWorkerManagerV2.WorkerDataV2",
1902        "components": [
1903          {
1904            "name": "onchainId",
1905            "type": "bytes32",
1906            "internalType": "bytes32"
1907          }
1908        ]
1909      },
1910      {
1911        "name": "peerId",
1912        "type": "bytes32",
1913        "internalType": "bytes32"
1914      }
1915    ],
1916    "outputs": [],
1917    "stateMutability": "nonpayable"
1918  },
1919  {
1920    "type": "function",
1921    "name": "appCID",
1922    "inputs": [],
1923    "outputs": [
1924      {
1925        "name": "",
1926        "type": "tuple",
1927        "internalType": "struct Common.CIDV1",
1928        "components": [
1929          {
1930            "name": "prefixes",
1931            "type": "bytes4",
1932            "internalType": "bytes4"
1933          },
1934          {
1935            "name": "hash",
1936            "type": "bytes32",
1937            "internalType": "bytes32"
1938          }
1939        ]
1940      }
1941    ],
1942    "stateMutability": "view"
1943  },
1944  {
1945    "type": "function",
1946    "name": "changeProvidersAccessType",
1947    "inputs": [
1948      {
1949        "name": "accessType",
1950        "type": "uint8",
1951        "internalType": "enum IConfigV2.AccessTypeV2"
1952      }
1953    ],
1954    "outputs": [],
1955    "stateMutability": "nonpayable"
1956  },
1957  {
1958    "type": "function",
1959    "name": "computePeerUsed",
1960    "inputs": [
1961      {
1962        "name": "peerId",
1963        "type": "bytes32",
1964        "internalType": "bytes32"
1965      }
1966    ],
1967    "outputs": [
1968      {
1969        "name": "",
1970        "type": "bool",
1971        "internalType": "bool"
1972      }
1973    ],
1974    "stateMutability": "view"
1975  },
1976  {
1977    "type": "function",
1978    "name": "creationBlock",
1979    "inputs": [],
1980    "outputs": [
1981      {
1982        "name": "",
1983        "type": "uint256",
1984        "internalType": "uint256"
1985      }
1986    ],
1987    "stateMutability": "view"
1988  },
1989  {
1990    "type": "function",
1991    "name": "depositFromOwner",
1992    "inputs": [
1993      {
1994        "name": "amount",
1995        "type": "uint256",
1996        "internalType": "uint256"
1997      },
1998      {
1999        "name": "reason",
2000        "type": "uint8",
2001        "internalType": "enum IBalanceKeeper.DealDepositReason"
2002      }
2003    ],
2004    "outputs": [],
2005    "stateMutability": "nonpayable"
2006  },
2007  {
2008    "type": "function",
2009    "name": "getActivatedWorkerCount",
2010    "inputs": [],
2011    "outputs": [
2012      {
2013        "name": "",
2014        "type": "uint256",
2015        "internalType": "uint256"
2016      }
2017    ],
2018    "stateMutability": "view"
2019  },
2020  {
2021    "type": "function",
2022    "name": "getFreeBalance",
2023    "inputs": [],
2024    "outputs": [
2025      {
2026        "name": "",
2027        "type": "uint256",
2028        "internalType": "uint256"
2029      }
2030    ],
2031    "stateMutability": "view"
2032  },
2033  {
2034    "type": "function",
2035    "name": "getMaxPaidEpoch",
2036    "inputs": [],
2037    "outputs": [
2038      {
2039        "name": "",
2040        "type": "uint256",
2041        "internalType": "uint256"
2042      }
2043    ],
2044    "stateMutability": "view"
2045  },
2046  {
2047    "type": "function",
2048    "name": "getProtocolVersion",
2049    "inputs": [],
2050    "outputs": [
2051      {
2052        "name": "",
2053        "type": "uint256",
2054        "internalType": "uint256"
2055      }
2056    ],
2057    "stateMutability": "view"
2058  },
2059  {
2060    "type": "function",
2061    "name": "getRewardAmount",
2062    "inputs": [
2063      {
2064        "name": "onchainWorkerId",
2065        "type": "bytes32",
2066        "internalType": "bytes32"
2067      }
2068    ],
2069    "outputs": [
2070      {
2071        "name": "",
2072        "type": "tuple",
2073        "internalType": "struct IDealV2.DealRewards",
2074        "components": [
2075          {
2076            "name": "providerReward",
2077            "type": "uint256",
2078            "internalType": "uint256"
2079          },
2080          {
2081            "name": "stakerReward",
2082            "type": "uint256",
2083            "internalType": "uint256"
2084          }
2085        ]
2086      }
2087    ],
2088    "stateMutability": "view"
2089  },
2090  {
2091    "type": "function",
2092    "name": "getStatus",
2093    "inputs": [],
2094    "outputs": [
2095      {
2096        "name": "",
2097        "type": "uint8",
2098        "internalType": "enum IDealV2.Status"
2099      }
2100    ],
2101    "stateMutability": "view"
2102  },
2103  {
2104    "type": "function",
2105    "name": "getWorkerCount",
2106    "inputs": [],
2107    "outputs": [
2108      {
2109        "name": "",
2110        "type": "uint256",
2111        "internalType": "uint256"
2112      }
2113    ],
2114    "stateMutability": "view"
2115  },
2116  {
2117    "type": "function",
2118    "name": "getWorkerCount",
2119    "inputs": [
2120      {
2121        "name": "provider",
2122        "type": "address",
2123        "internalType": "address"
2124      }
2125    ],
2126    "outputs": [
2127      {
2128        "name": "",
2129        "type": "uint256",
2130        "internalType": "uint256"
2131      }
2132    ],
2133    "stateMutability": "view"
2134  },
2135  {
2136    "type": "function",
2137    "name": "getWorkerIds",
2138    "inputs": [],
2139    "outputs": [
2140      {
2141        "name": "",
2142        "type": "bytes32[]",
2143        "internalType": "bytes32[]"
2144      }
2145    ],
2146    "stateMutability": "view"
2147  },
2148  {
2149    "type": "function",
2150    "name": "initialize",
2151    "inputs": [
2152      {
2153        "name": "diamond_",
2154        "type": "address",
2155        "internalType": "contract IDiamond"
2156      },
2157      {
2158        "name": "appCID_",
2159        "type": "tuple",
2160        "internalType": "struct Common.CIDV1",
2161        "components": [
2162          {
2163            "name": "prefixes",
2164            "type": "bytes4",
2165            "internalType": "bytes4"
2166          },
2167          {
2168            "name": "hash",
2169            "type": "bytes32",
2170            "internalType": "bytes32"
2171          }
2172        ]
2173      },
2174      {
2175        "name": "paymentToken_",
2176        "type": "address",
2177        "internalType": "contract IERC20"
2178      },
2179      {
2180        "name": "targetWorkers_",
2181        "type": "uint256",
2182        "internalType": "uint256"
2183      },
2184      {
2185        "name": "resources_",
2186        "type": "tuple[]",
2187        "internalType": "struct IOfferV2.ResourceRequirement[]",
2188        "components": [
2189          {
2190            "name": "resourceId",
2191            "type": "bytes32",
2192            "internalType": "bytes32"
2193          },
2194          {
2195            "name": "ty",
2196            "type": "uint8",
2197            "internalType": "enum IOfferV2.ResourceType"
2198          },
2199          {
2200            "name": "quantity",
2201            "type": "uint256",
2202            "internalType": "uint256"
2203          }
2204        ]
2205      },
2206      {
2207        "name": "pricePerEpoch_",
2208        "type": "uint256",
2209        "internalType": "uint256"
2210      },
2211      {
2212        "name": "maxWorkersPerProvider_",
2213        "type": "uint256",
2214        "internalType": "uint256"
2215      },
2216      {
2217        "name": "providersAccessType_",
2218        "type": "uint8",
2219        "internalType": "enum IConfigV2.AccessTypeV2"
2220      },
2221      {
2222        "name": "providersAccessList_",
2223        "type": "address[]",
2224        "internalType": "address[]"
2225      },
2226      {
2227        "name": "protocolVersion_",
2228        "type": "uint256",
2229        "internalType": "uint256"
2230      },
2231      {
2232        "name": "owner_",
2233        "type": "address",
2234        "internalType": "address"
2235      }
2236    ],
2237    "outputs": [],
2238    "stateMutability": "nonpayable"
2239  },
2240  {
2241    "type": "function",
2242    "name": "isProviderAllowed",
2243    "inputs": [
2244      {
2245        "name": "account",
2246        "type": "address",
2247        "internalType": "address"
2248      }
2249    ],
2250    "outputs": [
2251      {
2252        "name": "",
2253        "type": "bool",
2254        "internalType": "bool"
2255      }
2256    ],
2257    "stateMutability": "view"
2258  },
2259  {
2260    "type": "function",
2261    "name": "maxWorkersPerProvider",
2262    "inputs": [],
2263    "outputs": [
2264      {
2265        "name": "",
2266        "type": "uint256",
2267        "internalType": "uint256"
2268      }
2269    ],
2270    "stateMutability": "view"
2271  },
2272  {
2273    "type": "function",
2274    "name": "paymentToken",
2275    "inputs": [],
2276    "outputs": [
2277      {
2278        "name": "",
2279        "type": "address",
2280        "internalType": "contract IERC20"
2281      }
2282    ],
2283    "stateMutability": "view"
2284  },
2285  {
2286    "type": "function",
2287    "name": "pricePerEpoch",
2288    "inputs": [],
2289    "outputs": [
2290      {
2291        "name": "",
2292        "type": "uint256",
2293        "internalType": "uint256"
2294      }
2295    ],
2296    "stateMutability": "view"
2297  },
2298  {
2299    "type": "function",
2300    "name": "providersAccessType",
2301    "inputs": [],
2302    "outputs": [
2303      {
2304        "name": "",
2305        "type": "uint8",
2306        "internalType": "enum IConfigV2.AccessTypeV2"
2307      }
2308    ],
2309    "stateMutability": "view"
2310  },
2311  {
2312    "type": "function",
2313    "name": "removeProviderFromAccessList",
2314    "inputs": [
2315      {
2316        "name": "provider",
2317        "type": "address",
2318        "internalType": "address"
2319      }
2320    ],
2321    "outputs": [],
2322    "stateMutability": "nonpayable"
2323  },
2324  {
2325    "type": "function",
2326    "name": "removeStaleWorkers",
2327    "inputs": [
2328      {
2329        "name": "onchainWorkerIds",
2330        "type": "bytes32[]",
2331        "internalType": "bytes32[]"
2332      }
2333    ],
2334    "outputs": [],
2335    "stateMutability": "nonpayable"
2336  },
2337  {
2338    "type": "function",
2339    "name": "removeWorker",
2340    "inputs": [
2341      {
2342        "name": "onchainWorkerId",
2343        "type": "bytes32",
2344        "internalType": "bytes32"
2345      }
2346    ],
2347    "outputs": [],
2348    "stateMutability": "nonpayable"
2349  },
2350  {
2351    "type": "function",
2352    "name": "requiredResources",
2353    "inputs": [],
2354    "outputs": [
2355      {
2356        "name": "",
2357        "type": "tuple[]",
2358        "internalType": "struct IOfferV2.ResourceRequirement[]",
2359        "components": [
2360          {
2361            "name": "resourceId",
2362            "type": "bytes32",
2363            "internalType": "bytes32"
2364          },
2365          {
2366            "name": "ty",
2367            "type": "uint8",
2368            "internalType": "enum IOfferV2.ResourceType"
2369          },
2370          {
2371            "name": "quantity",
2372            "type": "uint256",
2373            "internalType": "uint256"
2374          }
2375        ]
2376      }
2377    ],
2378    "stateMutability": "view"
2379  },
2380  {
2381    "type": "function",
2382    "name": "setAppCID",
2383    "inputs": [
2384      {
2385        "name": "appCID_",
2386        "type": "tuple",
2387        "internalType": "struct Common.CIDV1",
2388        "components": [
2389          {
2390            "name": "prefixes",
2391            "type": "bytes4",
2392            "internalType": "bytes4"
2393          },
2394          {
2395            "name": "hash",
2396            "type": "bytes32",
2397            "internalType": "bytes32"
2398          }
2399        ]
2400      }
2401    ],
2402    "outputs": [],
2403    "stateMutability": "nonpayable"
2404  },
2405  {
2406    "type": "function",
2407    "name": "stop",
2408    "inputs": [],
2409    "outputs": [],
2410    "stateMutability": "nonpayable"
2411  },
2412  {
2413    "type": "function",
2414    "name": "targetWorkers",
2415    "inputs": [],
2416    "outputs": [
2417      {
2418        "name": "",
2419        "type": "uint256",
2420        "internalType": "uint256"
2421      }
2422    ],
2423    "stateMutability": "view"
2424  },
2425  {
2426    "type": "function",
2427    "name": "withdraw",
2428    "inputs": [
2429      {
2430        "name": "amount",
2431        "type": "uint256",
2432        "internalType": "uint256"
2433      }
2434    ],
2435    "outputs": [],
2436    "stateMutability": "nonpayable"
2437  },
2438  {
2439    "type": "function",
2440    "name": "withdrawRewards",
2441    "inputs": [
2442      {
2443        "name": "onchainWorkerId",
2444        "type": "bytes32",
2445        "internalType": "bytes32"
2446      }
2447    ],
2448    "outputs": [],
2449    "stateMutability": "nonpayable"
2450  },
2451  {
2452    "type": "event",
2453    "name": "AppCIDChanged",
2454    "inputs": [
2455      {
2456        "name": "newAppCID",
2457        "type": "tuple",
2458        "indexed": false,
2459        "internalType": "struct Common.CIDV1",
2460        "components": [
2461          {
2462            "name": "prefixes",
2463            "type": "bytes4",
2464            "internalType": "bytes4"
2465          },
2466          {
2467            "name": "hash",
2468            "type": "bytes32",
2469            "internalType": "bytes32"
2470          }
2471        ]
2472      }
2473    ],
2474    "anonymous": false
2475  },
2476  {
2477    "type": "event",
2478    "name": "DealEnded",
2479    "inputs": [
2480      {
2481        "name": "endedEpoch",
2482        "type": "uint256",
2483        "indexed": false,
2484        "internalType": "uint256"
2485      }
2486    ],
2487    "anonymous": false
2488  },
2489  {
2490    "type": "event",
2491    "name": "Deposited",
2492    "inputs": [
2493      {
2494        "name": "amount",
2495        "type": "uint256",
2496        "indexed": false,
2497        "internalType": "uint256"
2498      }
2499    ],
2500    "anonymous": false
2501  },
2502  {
2503    "type": "event",
2504    "name": "MaxPaidEpochUpdated",
2505    "inputs": [
2506      {
2507        "name": "maxPaidEpoch",
2508        "type": "uint256",
2509        "indexed": false,
2510        "internalType": "uint256"
2511      }
2512    ],
2513    "anonymous": false
2514  },
2515  {
2516    "type": "event",
2517    "name": "ProviderAddedToAccessList",
2518    "inputs": [
2519      {
2520        "name": "provider",
2521        "type": "address",
2522        "indexed": false,
2523        "internalType": "address"
2524      }
2525    ],
2526    "anonymous": false
2527  },
2528  {
2529    "type": "event",
2530    "name": "ProviderRemovedFromAccessList",
2531    "inputs": [
2532      {
2533        "name": "provider",
2534        "type": "address",
2535        "indexed": false,
2536        "internalType": "address"
2537      }
2538    ],
2539    "anonymous": false
2540  },
2541  {
2542    "type": "event",
2543    "name": "ProvidersAccessTypeChanged",
2544    "inputs": [
2545      {
2546        "name": "newAccessType",
2547        "type": "uint8",
2548        "indexed": false,
2549        "internalType": "enum IConfigV2.AccessTypeV2"
2550      }
2551    ],
2552    "anonymous": false
2553  },
2554  {
2555    "type": "event",
2556    "name": "RewardWithdrawn",
2557    "inputs": [
2558      {
2559        "name": "onchainWorkerId",
2560        "type": "bytes32",
2561        "indexed": false,
2562        "internalType": "bytes32"
2563      },
2564      {
2565        "name": "providerReward",
2566        "type": "uint256",
2567        "indexed": false,
2568        "internalType": "uint256"
2569      },
2570      {
2571        "name": "stakerReward",
2572        "type": "uint256",
2573        "indexed": false,
2574        "internalType": "uint256"
2575      }
2576    ],
2577    "anonymous": false
2578  },
2579  {
2580    "type": "event",
2581    "name": "Withdrawn",
2582    "inputs": [
2583      {
2584        "name": "amount",
2585        "type": "uint256",
2586        "indexed": false,
2587        "internalType": "uint256"
2588      }
2589    ],
2590    "anonymous": false
2591  },
2592  {
2593    "type": "event",
2594    "name": "WorkerIdUpdated",
2595    "inputs": [
2596      {
2597        "name": "onchainWorkerId",
2598        "type": "bytes32",
2599        "indexed": false,
2600        "internalType": "bytes32"
2601      },
2602      {
2603        "name": "offchainWorkerId",
2604        "type": "bytes32",
2605        "indexed": false,
2606        "internalType": "bytes32"
2607      }
2608    ],
2609    "anonymous": false
2610  },
2611  {
2612    "type": "event",
2613    "name": "WorkerJoined",
2614    "inputs": [
2615      {
2616        "name": "peerId",
2617        "type": "bytes32",
2618        "indexed": true,
2619        "internalType": "bytes32"
2620      },
2621      {
2622        "name": "onchainId",
2623        "type": "bytes32",
2624        "indexed": false,
2625        "internalType": "bytes32"
2626      }
2627    ],
2628    "anonymous": false
2629  },
2630  {
2631    "type": "event",
2632    "name": "WorkerRemoved",
2633    "inputs": [
2634      {
2635        "name": "peerId",
2636        "type": "bytes32",
2637        "indexed": true,
2638        "internalType": "bytes32"
2639      },
2640      {
2641        "name": "onchainId",
2642        "type": "bytes32",
2643        "indexed": false,
2644        "internalType": "bytes32"
2645      }
2646    ],
2647    "anonymous": false
2648  }
2649]
2650```*/
2651#[allow(
2652    non_camel_case_types,
2653    non_snake_case,
2654    clippy::pub_underscore_fields,
2655    clippy::style,
2656    clippy::empty_structs_with_brackets
2657)]
2658pub mod IDealV2 {
2659    use super::*;
2660    use alloy::sol_types as alloy_sol_types;
2661    /// The creation / init bytecode of the contract.
2662    ///
2663    /// ```text
2664    ///0x
2665    /// ```
2666    #[rustfmt::skip]
2667    #[allow(clippy::all)]
2668    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
2669        b"",
2670    );
2671    /// The runtime bytecode of the contract, as deployed on the network.
2672    ///
2673    /// ```text
2674    ///0x
2675    /// ```
2676    #[rustfmt::skip]
2677    #[allow(clippy::all)]
2678    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
2679        b"",
2680    );
2681    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2682    #[derive(Clone)]
2683    pub struct Status(u8);
2684    const _: () = {
2685        use alloy::sol_types as alloy_sol_types;
2686        #[automatically_derived]
2687        impl alloy_sol_types::private::SolTypeValue<Status> for u8 {
2688            #[inline]
2689            fn stv_to_tokens(
2690                &self,
2691            ) -> <alloy::sol_types::sol_data::Uint<
2692                8,
2693            > as alloy_sol_types::SolType>::Token<'_> {
2694                alloy_sol_types::private::SolTypeValue::<
2695                    alloy::sol_types::sol_data::Uint<8>,
2696                >::stv_to_tokens(self)
2697            }
2698            #[inline]
2699            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2700                <alloy::sol_types::sol_data::Uint<
2701                    8,
2702                > as alloy_sol_types::SolType>::tokenize(self)
2703                    .0
2704            }
2705            #[inline]
2706            fn stv_abi_encode_packed_to(
2707                &self,
2708                out: &mut alloy_sol_types::private::Vec<u8>,
2709            ) {
2710                <alloy::sol_types::sol_data::Uint<
2711                    8,
2712                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
2713            }
2714            #[inline]
2715            fn stv_abi_packed_encoded_size(&self) -> usize {
2716                <alloy::sol_types::sol_data::Uint<
2717                    8,
2718                > as alloy_sol_types::SolType>::abi_encoded_size(self)
2719            }
2720        }
2721        #[automatically_derived]
2722        impl Status {
2723            /// The Solidity type name.
2724            pub const NAME: &'static str = stringify!(@ name);
2725            /// Convert from the underlying value type.
2726            #[inline]
2727            pub const fn from(value: u8) -> Self {
2728                Self(value)
2729            }
2730            /// Return the underlying value.
2731            #[inline]
2732            pub const fn into(self) -> u8 {
2733                self.0
2734            }
2735            /// Return the single encoding of this value, delegating to the
2736            /// underlying type.
2737            #[inline]
2738            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
2739                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
2740            }
2741            /// Return the packed encoding of this value, delegating to the
2742            /// underlying type.
2743            #[inline]
2744            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
2745                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
2746            }
2747        }
2748        #[automatically_derived]
2749        impl alloy_sol_types::SolType for Status {
2750            type RustType = u8;
2751            type Token<'a> = <alloy::sol_types::sol_data::Uint<
2752                8,
2753            > as alloy_sol_types::SolType>::Token<'a>;
2754            const SOL_NAME: &'static str = Self::NAME;
2755            const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
2756                8,
2757            > as alloy_sol_types::SolType>::ENCODED_SIZE;
2758            const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
2759                8,
2760            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2761            #[inline]
2762            fn valid_token(token: &Self::Token<'_>) -> bool {
2763                Self::type_check(token).is_ok()
2764            }
2765            #[inline]
2766            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
2767                <alloy::sol_types::sol_data::Uint<
2768                    8,
2769                > as alloy_sol_types::SolType>::type_check(token)
2770            }
2771            #[inline]
2772            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2773                <alloy::sol_types::sol_data::Uint<
2774                    8,
2775                > as alloy_sol_types::SolType>::detokenize(token)
2776            }
2777        }
2778        #[automatically_derived]
2779        impl alloy_sol_types::EventTopic for Status {
2780            #[inline]
2781            fn topic_preimage_length(rust: &Self::RustType) -> usize {
2782                <alloy::sol_types::sol_data::Uint<
2783                    8,
2784                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
2785            }
2786            #[inline]
2787            fn encode_topic_preimage(
2788                rust: &Self::RustType,
2789                out: &mut alloy_sol_types::private::Vec<u8>,
2790            ) {
2791                <alloy::sol_types::sol_data::Uint<
2792                    8,
2793                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
2794            }
2795            #[inline]
2796            fn encode_topic(
2797                rust: &Self::RustType,
2798            ) -> alloy_sol_types::abi::token::WordToken {
2799                <alloy::sol_types::sol_data::Uint<
2800                    8,
2801                > as alloy_sol_types::EventTopic>::encode_topic(rust)
2802            }
2803        }
2804    };
2805    /**```solidity
2806struct DealRewards { uint256 providerReward; uint256 stakerReward; }
2807```*/
2808    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2809    #[derive(Clone)]
2810    pub struct DealRewards {
2811        #[allow(missing_docs)]
2812        pub providerReward: alloy::sol_types::private::primitives::aliases::U256,
2813        #[allow(missing_docs)]
2814        pub stakerReward: alloy::sol_types::private::primitives::aliases::U256,
2815    }
2816    #[allow(
2817        non_camel_case_types,
2818        non_snake_case,
2819        clippy::pub_underscore_fields,
2820        clippy::style
2821    )]
2822    const _: () = {
2823        use alloy::sol_types as alloy_sol_types;
2824        #[doc(hidden)]
2825        type UnderlyingSolTuple<'a> = (
2826            alloy::sol_types::sol_data::Uint<256>,
2827            alloy::sol_types::sol_data::Uint<256>,
2828        );
2829        #[doc(hidden)]
2830        type UnderlyingRustTuple<'a> = (
2831            alloy::sol_types::private::primitives::aliases::U256,
2832            alloy::sol_types::private::primitives::aliases::U256,
2833        );
2834        #[cfg(test)]
2835        #[allow(dead_code, unreachable_patterns)]
2836        fn _type_assertion(
2837            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2838        ) {
2839            match _t {
2840                alloy_sol_types::private::AssertTypeEq::<
2841                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2842                >(_) => {}
2843            }
2844        }
2845        #[automatically_derived]
2846        #[doc(hidden)]
2847        impl ::core::convert::From<DealRewards> for UnderlyingRustTuple<'_> {
2848            fn from(value: DealRewards) -> Self {
2849                (value.providerReward, value.stakerReward)
2850            }
2851        }
2852        #[automatically_derived]
2853        #[doc(hidden)]
2854        impl ::core::convert::From<UnderlyingRustTuple<'_>> for DealRewards {
2855            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2856                Self {
2857                    providerReward: tuple.0,
2858                    stakerReward: tuple.1,
2859                }
2860            }
2861        }
2862        #[automatically_derived]
2863        impl alloy_sol_types::SolValue for DealRewards {
2864            type SolType = Self;
2865        }
2866        #[automatically_derived]
2867        impl alloy_sol_types::private::SolTypeValue<Self> for DealRewards {
2868            #[inline]
2869            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
2870                (
2871                    <alloy::sol_types::sol_data::Uint<
2872                        256,
2873                    > as alloy_sol_types::SolType>::tokenize(&self.providerReward),
2874                    <alloy::sol_types::sol_data::Uint<
2875                        256,
2876                    > as alloy_sol_types::SolType>::tokenize(&self.stakerReward),
2877                )
2878            }
2879            #[inline]
2880            fn stv_abi_encoded_size(&self) -> usize {
2881                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
2882                    return size;
2883                }
2884                let tuple = <UnderlyingRustTuple<
2885                    '_,
2886                > as ::core::convert::From<Self>>::from(self.clone());
2887                <UnderlyingSolTuple<
2888                    '_,
2889                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
2890            }
2891            #[inline]
2892            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2893                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
2894            }
2895            #[inline]
2896            fn stv_abi_encode_packed_to(
2897                &self,
2898                out: &mut alloy_sol_types::private::Vec<u8>,
2899            ) {
2900                let tuple = <UnderlyingRustTuple<
2901                    '_,
2902                > as ::core::convert::From<Self>>::from(self.clone());
2903                <UnderlyingSolTuple<
2904                    '_,
2905                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
2906            }
2907            #[inline]
2908            fn stv_abi_packed_encoded_size(&self) -> usize {
2909                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
2910                    return size;
2911                }
2912                let tuple = <UnderlyingRustTuple<
2913                    '_,
2914                > as ::core::convert::From<Self>>::from(self.clone());
2915                <UnderlyingSolTuple<
2916                    '_,
2917                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
2918            }
2919        }
2920        #[automatically_derived]
2921        impl alloy_sol_types::SolType for DealRewards {
2922            type RustType = Self;
2923            type Token<'a> = <UnderlyingSolTuple<
2924                'a,
2925            > as alloy_sol_types::SolType>::Token<'a>;
2926            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
2927            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2928                '_,
2929            > as alloy_sol_types::SolType>::ENCODED_SIZE;
2930            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2931                '_,
2932            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2933            #[inline]
2934            fn valid_token(token: &Self::Token<'_>) -> bool {
2935                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
2936            }
2937            #[inline]
2938            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2939                let tuple = <UnderlyingSolTuple<
2940                    '_,
2941                > as alloy_sol_types::SolType>::detokenize(token);
2942                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
2943            }
2944        }
2945        #[automatically_derived]
2946        impl alloy_sol_types::SolStruct for DealRewards {
2947            const NAME: &'static str = "DealRewards";
2948            #[inline]
2949            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
2950                alloy_sol_types::private::Cow::Borrowed(
2951                    "DealRewards(uint256 providerReward,uint256 stakerReward)",
2952                )
2953            }
2954            #[inline]
2955            fn eip712_components() -> alloy_sol_types::private::Vec<
2956                alloy_sol_types::private::Cow<'static, str>,
2957            > {
2958                alloy_sol_types::private::Vec::new()
2959            }
2960            #[inline]
2961            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
2962                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
2963            }
2964            #[inline]
2965            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
2966                [
2967                    <alloy::sol_types::sol_data::Uint<
2968                        256,
2969                    > as alloy_sol_types::SolType>::eip712_data_word(
2970                            &self.providerReward,
2971                        )
2972                        .0,
2973                    <alloy::sol_types::sol_data::Uint<
2974                        256,
2975                    > as alloy_sol_types::SolType>::eip712_data_word(&self.stakerReward)
2976                        .0,
2977                ]
2978                    .concat()
2979            }
2980        }
2981        #[automatically_derived]
2982        impl alloy_sol_types::EventTopic for DealRewards {
2983            #[inline]
2984            fn topic_preimage_length(rust: &Self::RustType) -> usize {
2985                0usize
2986                    + <alloy::sol_types::sol_data::Uint<
2987                        256,
2988                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
2989                        &rust.providerReward,
2990                    )
2991                    + <alloy::sol_types::sol_data::Uint<
2992                        256,
2993                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
2994                        &rust.stakerReward,
2995                    )
2996            }
2997            #[inline]
2998            fn encode_topic_preimage(
2999                rust: &Self::RustType,
3000                out: &mut alloy_sol_types::private::Vec<u8>,
3001            ) {
3002                out.reserve(
3003                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
3004                );
3005                <alloy::sol_types::sol_data::Uint<
3006                    256,
3007                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
3008                    &rust.providerReward,
3009                    out,
3010                );
3011                <alloy::sol_types::sol_data::Uint<
3012                    256,
3013                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
3014                    &rust.stakerReward,
3015                    out,
3016                );
3017            }
3018            #[inline]
3019            fn encode_topic(
3020                rust: &Self::RustType,
3021            ) -> alloy_sol_types::abi::token::WordToken {
3022                let mut out = alloy_sol_types::private::Vec::new();
3023                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
3024                    rust,
3025                    &mut out,
3026                );
3027                alloy_sol_types::abi::token::WordToken(
3028                    alloy_sol_types::private::keccak256(out),
3029                )
3030            }
3031        }
3032    };
3033    /**Event with signature `AppCIDChanged((bytes4,bytes32))` and selector `0xc820a66d3bdd50a45cf12cda6dc8ec9e94fb5123edd7da736eea18316f8523a0`.
3034```solidity
3035event AppCIDChanged(Common.CIDV1 newAppCID);
3036```*/
3037    #[allow(
3038        non_camel_case_types,
3039        non_snake_case,
3040        clippy::pub_underscore_fields,
3041        clippy::style
3042    )]
3043    #[derive(Clone)]
3044    pub struct AppCIDChanged {
3045        #[allow(missing_docs)]
3046        pub newAppCID: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
3047    }
3048    #[allow(
3049        non_camel_case_types,
3050        non_snake_case,
3051        clippy::pub_underscore_fields,
3052        clippy::style
3053    )]
3054    const _: () = {
3055        use alloy::sol_types as alloy_sol_types;
3056        #[automatically_derived]
3057        impl alloy_sol_types::SolEvent for AppCIDChanged {
3058            type DataTuple<'a> = (Common::CIDV1,);
3059            type DataToken<'a> = <Self::DataTuple<
3060                'a,
3061            > as alloy_sol_types::SolType>::Token<'a>;
3062            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
3063            const SIGNATURE: &'static str = "AppCIDChanged((bytes4,bytes32))";
3064            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
3065                200u8,
3066                32u8,
3067                166u8,
3068                109u8,
3069                59u8,
3070                221u8,
3071                80u8,
3072                164u8,
3073                92u8,
3074                241u8,
3075                44u8,
3076                218u8,
3077                109u8,
3078                200u8,
3079                236u8,
3080                158u8,
3081                148u8,
3082                251u8,
3083                81u8,
3084                35u8,
3085                237u8,
3086                215u8,
3087                218u8,
3088                115u8,
3089                110u8,
3090                234u8,
3091                24u8,
3092                49u8,
3093                111u8,
3094                133u8,
3095                35u8,
3096                160u8,
3097            ]);
3098            const ANONYMOUS: bool = false;
3099            #[allow(unused_variables)]
3100            #[inline]
3101            fn new(
3102                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3103                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3104            ) -> Self {
3105                Self { newAppCID: data.0 }
3106            }
3107            #[inline]
3108            fn check_signature(
3109                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3110            ) -> alloy_sol_types::Result<()> {
3111                if topics.0 != Self::SIGNATURE_HASH {
3112                    return Err(
3113                        alloy_sol_types::Error::invalid_event_signature_hash(
3114                            Self::SIGNATURE,
3115                            topics.0,
3116                            Self::SIGNATURE_HASH,
3117                        ),
3118                    );
3119                }
3120                Ok(())
3121            }
3122            #[inline]
3123            fn tokenize_body(&self) -> Self::DataToken<'_> {
3124                (<Common::CIDV1 as alloy_sol_types::SolType>::tokenize(&self.newAppCID),)
3125            }
3126            #[inline]
3127            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3128                (Self::SIGNATURE_HASH.into(),)
3129            }
3130            #[inline]
3131            fn encode_topics_raw(
3132                &self,
3133                out: &mut [alloy_sol_types::abi::token::WordToken],
3134            ) -> alloy_sol_types::Result<()> {
3135                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3136                    return Err(alloy_sol_types::Error::Overrun);
3137                }
3138                out[0usize] = alloy_sol_types::abi::token::WordToken(
3139                    Self::SIGNATURE_HASH,
3140                );
3141                Ok(())
3142            }
3143        }
3144        #[automatically_derived]
3145        impl alloy_sol_types::private::IntoLogData for AppCIDChanged {
3146            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3147                From::from(self)
3148            }
3149            fn into_log_data(self) -> alloy_sol_types::private::LogData {
3150                From::from(&self)
3151            }
3152        }
3153        #[automatically_derived]
3154        impl From<&AppCIDChanged> for alloy_sol_types::private::LogData {
3155            #[inline]
3156            fn from(this: &AppCIDChanged) -> alloy_sol_types::private::LogData {
3157                alloy_sol_types::SolEvent::encode_log_data(this)
3158            }
3159        }
3160    };
3161    /**Event with signature `DealEnded(uint256)` and selector `0x3ad16bb58712aa329948d76146b096a4f4b85e024d99473dc50bcd358811b86c`.
3162```solidity
3163event DealEnded(uint256 endedEpoch);
3164```*/
3165    #[allow(
3166        non_camel_case_types,
3167        non_snake_case,
3168        clippy::pub_underscore_fields,
3169        clippy::style
3170    )]
3171    #[derive(Clone)]
3172    pub struct DealEnded {
3173        #[allow(missing_docs)]
3174        pub endedEpoch: alloy::sol_types::private::primitives::aliases::U256,
3175    }
3176    #[allow(
3177        non_camel_case_types,
3178        non_snake_case,
3179        clippy::pub_underscore_fields,
3180        clippy::style
3181    )]
3182    const _: () = {
3183        use alloy::sol_types as alloy_sol_types;
3184        #[automatically_derived]
3185        impl alloy_sol_types::SolEvent for DealEnded {
3186            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3187            type DataToken<'a> = <Self::DataTuple<
3188                'a,
3189            > as alloy_sol_types::SolType>::Token<'a>;
3190            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
3191            const SIGNATURE: &'static str = "DealEnded(uint256)";
3192            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
3193                58u8,
3194                209u8,
3195                107u8,
3196                181u8,
3197                135u8,
3198                18u8,
3199                170u8,
3200                50u8,
3201                153u8,
3202                72u8,
3203                215u8,
3204                97u8,
3205                70u8,
3206                176u8,
3207                150u8,
3208                164u8,
3209                244u8,
3210                184u8,
3211                94u8,
3212                2u8,
3213                77u8,
3214                153u8,
3215                71u8,
3216                61u8,
3217                197u8,
3218                11u8,
3219                205u8,
3220                53u8,
3221                136u8,
3222                17u8,
3223                184u8,
3224                108u8,
3225            ]);
3226            const ANONYMOUS: bool = false;
3227            #[allow(unused_variables)]
3228            #[inline]
3229            fn new(
3230                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3231                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3232            ) -> Self {
3233                Self { endedEpoch: data.0 }
3234            }
3235            #[inline]
3236            fn check_signature(
3237                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3238            ) -> alloy_sol_types::Result<()> {
3239                if topics.0 != Self::SIGNATURE_HASH {
3240                    return Err(
3241                        alloy_sol_types::Error::invalid_event_signature_hash(
3242                            Self::SIGNATURE,
3243                            topics.0,
3244                            Self::SIGNATURE_HASH,
3245                        ),
3246                    );
3247                }
3248                Ok(())
3249            }
3250            #[inline]
3251            fn tokenize_body(&self) -> Self::DataToken<'_> {
3252                (
3253                    <alloy::sol_types::sol_data::Uint<
3254                        256,
3255                    > as alloy_sol_types::SolType>::tokenize(&self.endedEpoch),
3256                )
3257            }
3258            #[inline]
3259            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3260                (Self::SIGNATURE_HASH.into(),)
3261            }
3262            #[inline]
3263            fn encode_topics_raw(
3264                &self,
3265                out: &mut [alloy_sol_types::abi::token::WordToken],
3266            ) -> alloy_sol_types::Result<()> {
3267                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3268                    return Err(alloy_sol_types::Error::Overrun);
3269                }
3270                out[0usize] = alloy_sol_types::abi::token::WordToken(
3271                    Self::SIGNATURE_HASH,
3272                );
3273                Ok(())
3274            }
3275        }
3276        #[automatically_derived]
3277        impl alloy_sol_types::private::IntoLogData for DealEnded {
3278            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3279                From::from(self)
3280            }
3281            fn into_log_data(self) -> alloy_sol_types::private::LogData {
3282                From::from(&self)
3283            }
3284        }
3285        #[automatically_derived]
3286        impl From<&DealEnded> for alloy_sol_types::private::LogData {
3287            #[inline]
3288            fn from(this: &DealEnded) -> alloy_sol_types::private::LogData {
3289                alloy_sol_types::SolEvent::encode_log_data(this)
3290            }
3291        }
3292    };
3293    /**Event with signature `Deposited(uint256)` and selector `0x2a89b2e3d580398d6dc2db5e0f336b52602bbaa51afa9bb5cdf59239cf0d2bea`.
3294```solidity
3295event Deposited(uint256 amount);
3296```*/
3297    #[allow(
3298        non_camel_case_types,
3299        non_snake_case,
3300        clippy::pub_underscore_fields,
3301        clippy::style
3302    )]
3303    #[derive(Clone)]
3304    pub struct Deposited {
3305        #[allow(missing_docs)]
3306        pub amount: alloy::sol_types::private::primitives::aliases::U256,
3307    }
3308    #[allow(
3309        non_camel_case_types,
3310        non_snake_case,
3311        clippy::pub_underscore_fields,
3312        clippy::style
3313    )]
3314    const _: () = {
3315        use alloy::sol_types as alloy_sol_types;
3316        #[automatically_derived]
3317        impl alloy_sol_types::SolEvent for Deposited {
3318            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3319            type DataToken<'a> = <Self::DataTuple<
3320                'a,
3321            > as alloy_sol_types::SolType>::Token<'a>;
3322            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
3323            const SIGNATURE: &'static str = "Deposited(uint256)";
3324            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
3325                42u8,
3326                137u8,
3327                178u8,
3328                227u8,
3329                213u8,
3330                128u8,
3331                57u8,
3332                141u8,
3333                109u8,
3334                194u8,
3335                219u8,
3336                94u8,
3337                15u8,
3338                51u8,
3339                107u8,
3340                82u8,
3341                96u8,
3342                43u8,
3343                186u8,
3344                165u8,
3345                26u8,
3346                250u8,
3347                155u8,
3348                181u8,
3349                205u8,
3350                245u8,
3351                146u8,
3352                57u8,
3353                207u8,
3354                13u8,
3355                43u8,
3356                234u8,
3357            ]);
3358            const ANONYMOUS: bool = false;
3359            #[allow(unused_variables)]
3360            #[inline]
3361            fn new(
3362                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3363                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3364            ) -> Self {
3365                Self { amount: data.0 }
3366            }
3367            #[inline]
3368            fn check_signature(
3369                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3370            ) -> alloy_sol_types::Result<()> {
3371                if topics.0 != Self::SIGNATURE_HASH {
3372                    return Err(
3373                        alloy_sol_types::Error::invalid_event_signature_hash(
3374                            Self::SIGNATURE,
3375                            topics.0,
3376                            Self::SIGNATURE_HASH,
3377                        ),
3378                    );
3379                }
3380                Ok(())
3381            }
3382            #[inline]
3383            fn tokenize_body(&self) -> Self::DataToken<'_> {
3384                (
3385                    <alloy::sol_types::sol_data::Uint<
3386                        256,
3387                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
3388                )
3389            }
3390            #[inline]
3391            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3392                (Self::SIGNATURE_HASH.into(),)
3393            }
3394            #[inline]
3395            fn encode_topics_raw(
3396                &self,
3397                out: &mut [alloy_sol_types::abi::token::WordToken],
3398            ) -> alloy_sol_types::Result<()> {
3399                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3400                    return Err(alloy_sol_types::Error::Overrun);
3401                }
3402                out[0usize] = alloy_sol_types::abi::token::WordToken(
3403                    Self::SIGNATURE_HASH,
3404                );
3405                Ok(())
3406            }
3407        }
3408        #[automatically_derived]
3409        impl alloy_sol_types::private::IntoLogData for Deposited {
3410            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3411                From::from(self)
3412            }
3413            fn into_log_data(self) -> alloy_sol_types::private::LogData {
3414                From::from(&self)
3415            }
3416        }
3417        #[automatically_derived]
3418        impl From<&Deposited> for alloy_sol_types::private::LogData {
3419            #[inline]
3420            fn from(this: &Deposited) -> alloy_sol_types::private::LogData {
3421                alloy_sol_types::SolEvent::encode_log_data(this)
3422            }
3423        }
3424    };
3425    /**Event with signature `MaxPaidEpochUpdated(uint256)` and selector `0xcecd349d986645e1758ec135f91f1ad20564a8bcc6c2b5a5eaca9b09841495c5`.
3426```solidity
3427event MaxPaidEpochUpdated(uint256 maxPaidEpoch);
3428```*/
3429    #[allow(
3430        non_camel_case_types,
3431        non_snake_case,
3432        clippy::pub_underscore_fields,
3433        clippy::style
3434    )]
3435    #[derive(Clone)]
3436    pub struct MaxPaidEpochUpdated {
3437        #[allow(missing_docs)]
3438        pub maxPaidEpoch: alloy::sol_types::private::primitives::aliases::U256,
3439    }
3440    #[allow(
3441        non_camel_case_types,
3442        non_snake_case,
3443        clippy::pub_underscore_fields,
3444        clippy::style
3445    )]
3446    const _: () = {
3447        use alloy::sol_types as alloy_sol_types;
3448        #[automatically_derived]
3449        impl alloy_sol_types::SolEvent for MaxPaidEpochUpdated {
3450            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3451            type DataToken<'a> = <Self::DataTuple<
3452                'a,
3453            > as alloy_sol_types::SolType>::Token<'a>;
3454            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
3455            const SIGNATURE: &'static str = "MaxPaidEpochUpdated(uint256)";
3456            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
3457                206u8,
3458                205u8,
3459                52u8,
3460                157u8,
3461                152u8,
3462                102u8,
3463                69u8,
3464                225u8,
3465                117u8,
3466                142u8,
3467                193u8,
3468                53u8,
3469                249u8,
3470                31u8,
3471                26u8,
3472                210u8,
3473                5u8,
3474                100u8,
3475                168u8,
3476                188u8,
3477                198u8,
3478                194u8,
3479                181u8,
3480                165u8,
3481                234u8,
3482                202u8,
3483                155u8,
3484                9u8,
3485                132u8,
3486                20u8,
3487                149u8,
3488                197u8,
3489            ]);
3490            const ANONYMOUS: bool = false;
3491            #[allow(unused_variables)]
3492            #[inline]
3493            fn new(
3494                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3495                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3496            ) -> Self {
3497                Self { maxPaidEpoch: data.0 }
3498            }
3499            #[inline]
3500            fn check_signature(
3501                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3502            ) -> alloy_sol_types::Result<()> {
3503                if topics.0 != Self::SIGNATURE_HASH {
3504                    return Err(
3505                        alloy_sol_types::Error::invalid_event_signature_hash(
3506                            Self::SIGNATURE,
3507                            topics.0,
3508                            Self::SIGNATURE_HASH,
3509                        ),
3510                    );
3511                }
3512                Ok(())
3513            }
3514            #[inline]
3515            fn tokenize_body(&self) -> Self::DataToken<'_> {
3516                (
3517                    <alloy::sol_types::sol_data::Uint<
3518                        256,
3519                    > as alloy_sol_types::SolType>::tokenize(&self.maxPaidEpoch),
3520                )
3521            }
3522            #[inline]
3523            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3524                (Self::SIGNATURE_HASH.into(),)
3525            }
3526            #[inline]
3527            fn encode_topics_raw(
3528                &self,
3529                out: &mut [alloy_sol_types::abi::token::WordToken],
3530            ) -> alloy_sol_types::Result<()> {
3531                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3532                    return Err(alloy_sol_types::Error::Overrun);
3533                }
3534                out[0usize] = alloy_sol_types::abi::token::WordToken(
3535                    Self::SIGNATURE_HASH,
3536                );
3537                Ok(())
3538            }
3539        }
3540        #[automatically_derived]
3541        impl alloy_sol_types::private::IntoLogData for MaxPaidEpochUpdated {
3542            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3543                From::from(self)
3544            }
3545            fn into_log_data(self) -> alloy_sol_types::private::LogData {
3546                From::from(&self)
3547            }
3548        }
3549        #[automatically_derived]
3550        impl From<&MaxPaidEpochUpdated> for alloy_sol_types::private::LogData {
3551            #[inline]
3552            fn from(this: &MaxPaidEpochUpdated) -> alloy_sol_types::private::LogData {
3553                alloy_sol_types::SolEvent::encode_log_data(this)
3554            }
3555        }
3556    };
3557    /**Event with signature `ProviderAddedToAccessList(address)` and selector `0x4c26e4de691e265be6cf03e639754839907bf74687cd524a6734851331527ffd`.
3558```solidity
3559event ProviderAddedToAccessList(address provider);
3560```*/
3561    #[allow(
3562        non_camel_case_types,
3563        non_snake_case,
3564        clippy::pub_underscore_fields,
3565        clippy::style
3566    )]
3567    #[derive(Clone)]
3568    pub struct ProviderAddedToAccessList {
3569        #[allow(missing_docs)]
3570        pub provider: alloy::sol_types::private::Address,
3571    }
3572    #[allow(
3573        non_camel_case_types,
3574        non_snake_case,
3575        clippy::pub_underscore_fields,
3576        clippy::style
3577    )]
3578    const _: () = {
3579        use alloy::sol_types as alloy_sol_types;
3580        #[automatically_derived]
3581        impl alloy_sol_types::SolEvent for ProviderAddedToAccessList {
3582            type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
3583            type DataToken<'a> = <Self::DataTuple<
3584                'a,
3585            > as alloy_sol_types::SolType>::Token<'a>;
3586            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
3587            const SIGNATURE: &'static str = "ProviderAddedToAccessList(address)";
3588            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
3589                76u8,
3590                38u8,
3591                228u8,
3592                222u8,
3593                105u8,
3594                30u8,
3595                38u8,
3596                91u8,
3597                230u8,
3598                207u8,
3599                3u8,
3600                230u8,
3601                57u8,
3602                117u8,
3603                72u8,
3604                57u8,
3605                144u8,
3606                123u8,
3607                247u8,
3608                70u8,
3609                135u8,
3610                205u8,
3611                82u8,
3612                74u8,
3613                103u8,
3614                52u8,
3615                133u8,
3616                19u8,
3617                49u8,
3618                82u8,
3619                127u8,
3620                253u8,
3621            ]);
3622            const ANONYMOUS: bool = false;
3623            #[allow(unused_variables)]
3624            #[inline]
3625            fn new(
3626                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3627                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3628            ) -> Self {
3629                Self { provider: data.0 }
3630            }
3631            #[inline]
3632            fn check_signature(
3633                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3634            ) -> alloy_sol_types::Result<()> {
3635                if topics.0 != Self::SIGNATURE_HASH {
3636                    return Err(
3637                        alloy_sol_types::Error::invalid_event_signature_hash(
3638                            Self::SIGNATURE,
3639                            topics.0,
3640                            Self::SIGNATURE_HASH,
3641                        ),
3642                    );
3643                }
3644                Ok(())
3645            }
3646            #[inline]
3647            fn tokenize_body(&self) -> Self::DataToken<'_> {
3648                (
3649                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3650                        &self.provider,
3651                    ),
3652                )
3653            }
3654            #[inline]
3655            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3656                (Self::SIGNATURE_HASH.into(),)
3657            }
3658            #[inline]
3659            fn encode_topics_raw(
3660                &self,
3661                out: &mut [alloy_sol_types::abi::token::WordToken],
3662            ) -> alloy_sol_types::Result<()> {
3663                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3664                    return Err(alloy_sol_types::Error::Overrun);
3665                }
3666                out[0usize] = alloy_sol_types::abi::token::WordToken(
3667                    Self::SIGNATURE_HASH,
3668                );
3669                Ok(())
3670            }
3671        }
3672        #[automatically_derived]
3673        impl alloy_sol_types::private::IntoLogData for ProviderAddedToAccessList {
3674            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3675                From::from(self)
3676            }
3677            fn into_log_data(self) -> alloy_sol_types::private::LogData {
3678                From::from(&self)
3679            }
3680        }
3681        #[automatically_derived]
3682        impl From<&ProviderAddedToAccessList> for alloy_sol_types::private::LogData {
3683            #[inline]
3684            fn from(
3685                this: &ProviderAddedToAccessList,
3686            ) -> alloy_sol_types::private::LogData {
3687                alloy_sol_types::SolEvent::encode_log_data(this)
3688            }
3689        }
3690    };
3691    /**Event with signature `ProviderRemovedFromAccessList(address)` and selector `0x38fb081a0b484406977bd94ff8edb79be44b5ca514130361182516b39e2c4528`.
3692```solidity
3693event ProviderRemovedFromAccessList(address provider);
3694```*/
3695    #[allow(
3696        non_camel_case_types,
3697        non_snake_case,
3698        clippy::pub_underscore_fields,
3699        clippy::style
3700    )]
3701    #[derive(Clone)]
3702    pub struct ProviderRemovedFromAccessList {
3703        #[allow(missing_docs)]
3704        pub provider: alloy::sol_types::private::Address,
3705    }
3706    #[allow(
3707        non_camel_case_types,
3708        non_snake_case,
3709        clippy::pub_underscore_fields,
3710        clippy::style
3711    )]
3712    const _: () = {
3713        use alloy::sol_types as alloy_sol_types;
3714        #[automatically_derived]
3715        impl alloy_sol_types::SolEvent for ProviderRemovedFromAccessList {
3716            type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
3717            type DataToken<'a> = <Self::DataTuple<
3718                'a,
3719            > as alloy_sol_types::SolType>::Token<'a>;
3720            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
3721            const SIGNATURE: &'static str = "ProviderRemovedFromAccessList(address)";
3722            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
3723                56u8,
3724                251u8,
3725                8u8,
3726                26u8,
3727                11u8,
3728                72u8,
3729                68u8,
3730                6u8,
3731                151u8,
3732                123u8,
3733                217u8,
3734                79u8,
3735                248u8,
3736                237u8,
3737                183u8,
3738                155u8,
3739                228u8,
3740                75u8,
3741                92u8,
3742                165u8,
3743                20u8,
3744                19u8,
3745                3u8,
3746                97u8,
3747                24u8,
3748                37u8,
3749                22u8,
3750                179u8,
3751                158u8,
3752                44u8,
3753                69u8,
3754                40u8,
3755            ]);
3756            const ANONYMOUS: bool = false;
3757            #[allow(unused_variables)]
3758            #[inline]
3759            fn new(
3760                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3761                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3762            ) -> Self {
3763                Self { provider: data.0 }
3764            }
3765            #[inline]
3766            fn check_signature(
3767                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3768            ) -> alloy_sol_types::Result<()> {
3769                if topics.0 != Self::SIGNATURE_HASH {
3770                    return Err(
3771                        alloy_sol_types::Error::invalid_event_signature_hash(
3772                            Self::SIGNATURE,
3773                            topics.0,
3774                            Self::SIGNATURE_HASH,
3775                        ),
3776                    );
3777                }
3778                Ok(())
3779            }
3780            #[inline]
3781            fn tokenize_body(&self) -> Self::DataToken<'_> {
3782                (
3783                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3784                        &self.provider,
3785                    ),
3786                )
3787            }
3788            #[inline]
3789            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3790                (Self::SIGNATURE_HASH.into(),)
3791            }
3792            #[inline]
3793            fn encode_topics_raw(
3794                &self,
3795                out: &mut [alloy_sol_types::abi::token::WordToken],
3796            ) -> alloy_sol_types::Result<()> {
3797                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3798                    return Err(alloy_sol_types::Error::Overrun);
3799                }
3800                out[0usize] = alloy_sol_types::abi::token::WordToken(
3801                    Self::SIGNATURE_HASH,
3802                );
3803                Ok(())
3804            }
3805        }
3806        #[automatically_derived]
3807        impl alloy_sol_types::private::IntoLogData for ProviderRemovedFromAccessList {
3808            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3809                From::from(self)
3810            }
3811            fn into_log_data(self) -> alloy_sol_types::private::LogData {
3812                From::from(&self)
3813            }
3814        }
3815        #[automatically_derived]
3816        impl From<&ProviderRemovedFromAccessList> for alloy_sol_types::private::LogData {
3817            #[inline]
3818            fn from(
3819                this: &ProviderRemovedFromAccessList,
3820            ) -> alloy_sol_types::private::LogData {
3821                alloy_sol_types::SolEvent::encode_log_data(this)
3822            }
3823        }
3824    };
3825    /**Event with signature `ProvidersAccessTypeChanged(uint8)` and selector `0x1f5a251428f76335a835fcae94ab6a9bcf09ac33bd3c782eb6a81bdf878a7393`.
3826```solidity
3827event ProvidersAccessTypeChanged(IConfigV2.AccessTypeV2 newAccessType);
3828```*/
3829    #[allow(
3830        non_camel_case_types,
3831        non_snake_case,
3832        clippy::pub_underscore_fields,
3833        clippy::style
3834    )]
3835    #[derive(Clone)]
3836    pub struct ProvidersAccessTypeChanged {
3837        #[allow(missing_docs)]
3838        pub newAccessType: <IConfigV2::AccessTypeV2 as alloy::sol_types::SolType>::RustType,
3839    }
3840    #[allow(
3841        non_camel_case_types,
3842        non_snake_case,
3843        clippy::pub_underscore_fields,
3844        clippy::style
3845    )]
3846    const _: () = {
3847        use alloy::sol_types as alloy_sol_types;
3848        #[automatically_derived]
3849        impl alloy_sol_types::SolEvent for ProvidersAccessTypeChanged {
3850            type DataTuple<'a> = (IConfigV2::AccessTypeV2,);
3851            type DataToken<'a> = <Self::DataTuple<
3852                'a,
3853            > as alloy_sol_types::SolType>::Token<'a>;
3854            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
3855            const SIGNATURE: &'static str = "ProvidersAccessTypeChanged(uint8)";
3856            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
3857                31u8,
3858                90u8,
3859                37u8,
3860                20u8,
3861                40u8,
3862                247u8,
3863                99u8,
3864                53u8,
3865                168u8,
3866                53u8,
3867                252u8,
3868                174u8,
3869                148u8,
3870                171u8,
3871                106u8,
3872                155u8,
3873                207u8,
3874                9u8,
3875                172u8,
3876                51u8,
3877                189u8,
3878                60u8,
3879                120u8,
3880                46u8,
3881                182u8,
3882                168u8,
3883                27u8,
3884                223u8,
3885                135u8,
3886                138u8,
3887                115u8,
3888                147u8,
3889            ]);
3890            const ANONYMOUS: bool = false;
3891            #[allow(unused_variables)]
3892            #[inline]
3893            fn new(
3894                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3895                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3896            ) -> Self {
3897                Self { newAccessType: data.0 }
3898            }
3899            #[inline]
3900            fn check_signature(
3901                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3902            ) -> alloy_sol_types::Result<()> {
3903                if topics.0 != Self::SIGNATURE_HASH {
3904                    return Err(
3905                        alloy_sol_types::Error::invalid_event_signature_hash(
3906                            Self::SIGNATURE,
3907                            topics.0,
3908                            Self::SIGNATURE_HASH,
3909                        ),
3910                    );
3911                }
3912                Ok(())
3913            }
3914            #[inline]
3915            fn tokenize_body(&self) -> Self::DataToken<'_> {
3916                (
3917                    <IConfigV2::AccessTypeV2 as alloy_sol_types::SolType>::tokenize(
3918                        &self.newAccessType,
3919                    ),
3920                )
3921            }
3922            #[inline]
3923            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3924                (Self::SIGNATURE_HASH.into(),)
3925            }
3926            #[inline]
3927            fn encode_topics_raw(
3928                &self,
3929                out: &mut [alloy_sol_types::abi::token::WordToken],
3930            ) -> alloy_sol_types::Result<()> {
3931                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3932                    return Err(alloy_sol_types::Error::Overrun);
3933                }
3934                out[0usize] = alloy_sol_types::abi::token::WordToken(
3935                    Self::SIGNATURE_HASH,
3936                );
3937                Ok(())
3938            }
3939        }
3940        #[automatically_derived]
3941        impl alloy_sol_types::private::IntoLogData for ProvidersAccessTypeChanged {
3942            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3943                From::from(self)
3944            }
3945            fn into_log_data(self) -> alloy_sol_types::private::LogData {
3946                From::from(&self)
3947            }
3948        }
3949        #[automatically_derived]
3950        impl From<&ProvidersAccessTypeChanged> for alloy_sol_types::private::LogData {
3951            #[inline]
3952            fn from(
3953                this: &ProvidersAccessTypeChanged,
3954            ) -> alloy_sol_types::private::LogData {
3955                alloy_sol_types::SolEvent::encode_log_data(this)
3956            }
3957        }
3958    };
3959    /**Event with signature `RewardWithdrawn(bytes32,uint256,uint256)` and selector `0xc512f9d0bb2627096491f1074af42a5032fe36ef5dcae7c216cfc34f6ea474d6`.
3960```solidity
3961event RewardWithdrawn(bytes32 onchainWorkerId, uint256 providerReward, uint256 stakerReward);
3962```*/
3963    #[allow(
3964        non_camel_case_types,
3965        non_snake_case,
3966        clippy::pub_underscore_fields,
3967        clippy::style
3968    )]
3969    #[derive(Clone)]
3970    pub struct RewardWithdrawn {
3971        #[allow(missing_docs)]
3972        pub onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
3973        #[allow(missing_docs)]
3974        pub providerReward: alloy::sol_types::private::primitives::aliases::U256,
3975        #[allow(missing_docs)]
3976        pub stakerReward: alloy::sol_types::private::primitives::aliases::U256,
3977    }
3978    #[allow(
3979        non_camel_case_types,
3980        non_snake_case,
3981        clippy::pub_underscore_fields,
3982        clippy::style
3983    )]
3984    const _: () = {
3985        use alloy::sol_types as alloy_sol_types;
3986        #[automatically_derived]
3987        impl alloy_sol_types::SolEvent for RewardWithdrawn {
3988            type DataTuple<'a> = (
3989                alloy::sol_types::sol_data::FixedBytes<32>,
3990                alloy::sol_types::sol_data::Uint<256>,
3991                alloy::sol_types::sol_data::Uint<256>,
3992            );
3993            type DataToken<'a> = <Self::DataTuple<
3994                'a,
3995            > as alloy_sol_types::SolType>::Token<'a>;
3996            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
3997            const SIGNATURE: &'static str = "RewardWithdrawn(bytes32,uint256,uint256)";
3998            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
3999                197u8,
4000                18u8,
4001                249u8,
4002                208u8,
4003                187u8,
4004                38u8,
4005                39u8,
4006                9u8,
4007                100u8,
4008                145u8,
4009                241u8,
4010                7u8,
4011                74u8,
4012                244u8,
4013                42u8,
4014                80u8,
4015                50u8,
4016                254u8,
4017                54u8,
4018                239u8,
4019                93u8,
4020                202u8,
4021                231u8,
4022                194u8,
4023                22u8,
4024                207u8,
4025                195u8,
4026                79u8,
4027                110u8,
4028                164u8,
4029                116u8,
4030                214u8,
4031            ]);
4032            const ANONYMOUS: bool = false;
4033            #[allow(unused_variables)]
4034            #[inline]
4035            fn new(
4036                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4037                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4038            ) -> Self {
4039                Self {
4040                    onchainWorkerId: data.0,
4041                    providerReward: data.1,
4042                    stakerReward: data.2,
4043                }
4044            }
4045            #[inline]
4046            fn check_signature(
4047                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4048            ) -> alloy_sol_types::Result<()> {
4049                if topics.0 != Self::SIGNATURE_HASH {
4050                    return Err(
4051                        alloy_sol_types::Error::invalid_event_signature_hash(
4052                            Self::SIGNATURE,
4053                            topics.0,
4054                            Self::SIGNATURE_HASH,
4055                        ),
4056                    );
4057                }
4058                Ok(())
4059            }
4060            #[inline]
4061            fn tokenize_body(&self) -> Self::DataToken<'_> {
4062                (
4063                    <alloy::sol_types::sol_data::FixedBytes<
4064                        32,
4065                    > as alloy_sol_types::SolType>::tokenize(&self.onchainWorkerId),
4066                    <alloy::sol_types::sol_data::Uint<
4067                        256,
4068                    > as alloy_sol_types::SolType>::tokenize(&self.providerReward),
4069                    <alloy::sol_types::sol_data::Uint<
4070                        256,
4071                    > as alloy_sol_types::SolType>::tokenize(&self.stakerReward),
4072                )
4073            }
4074            #[inline]
4075            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4076                (Self::SIGNATURE_HASH.into(),)
4077            }
4078            #[inline]
4079            fn encode_topics_raw(
4080                &self,
4081                out: &mut [alloy_sol_types::abi::token::WordToken],
4082            ) -> alloy_sol_types::Result<()> {
4083                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4084                    return Err(alloy_sol_types::Error::Overrun);
4085                }
4086                out[0usize] = alloy_sol_types::abi::token::WordToken(
4087                    Self::SIGNATURE_HASH,
4088                );
4089                Ok(())
4090            }
4091        }
4092        #[automatically_derived]
4093        impl alloy_sol_types::private::IntoLogData for RewardWithdrawn {
4094            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4095                From::from(self)
4096            }
4097            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4098                From::from(&self)
4099            }
4100        }
4101        #[automatically_derived]
4102        impl From<&RewardWithdrawn> for alloy_sol_types::private::LogData {
4103            #[inline]
4104            fn from(this: &RewardWithdrawn) -> alloy_sol_types::private::LogData {
4105                alloy_sol_types::SolEvent::encode_log_data(this)
4106            }
4107        }
4108    };
4109    /**Event with signature `Withdrawn(uint256)` and selector `0x430648de173157e069201c943adb2d4e340e7cf5b27b1b09c9cb852f03d63b56`.
4110```solidity
4111event Withdrawn(uint256 amount);
4112```*/
4113    #[allow(
4114        non_camel_case_types,
4115        non_snake_case,
4116        clippy::pub_underscore_fields,
4117        clippy::style
4118    )]
4119    #[derive(Clone)]
4120    pub struct Withdrawn {
4121        #[allow(missing_docs)]
4122        pub amount: alloy::sol_types::private::primitives::aliases::U256,
4123    }
4124    #[allow(
4125        non_camel_case_types,
4126        non_snake_case,
4127        clippy::pub_underscore_fields,
4128        clippy::style
4129    )]
4130    const _: () = {
4131        use alloy::sol_types as alloy_sol_types;
4132        #[automatically_derived]
4133        impl alloy_sol_types::SolEvent for Withdrawn {
4134            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4135            type DataToken<'a> = <Self::DataTuple<
4136                'a,
4137            > as alloy_sol_types::SolType>::Token<'a>;
4138            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
4139            const SIGNATURE: &'static str = "Withdrawn(uint256)";
4140            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
4141                67u8,
4142                6u8,
4143                72u8,
4144                222u8,
4145                23u8,
4146                49u8,
4147                87u8,
4148                224u8,
4149                105u8,
4150                32u8,
4151                28u8,
4152                148u8,
4153                58u8,
4154                219u8,
4155                45u8,
4156                78u8,
4157                52u8,
4158                14u8,
4159                124u8,
4160                245u8,
4161                178u8,
4162                123u8,
4163                27u8,
4164                9u8,
4165                201u8,
4166                203u8,
4167                133u8,
4168                47u8,
4169                3u8,
4170                214u8,
4171                59u8,
4172                86u8,
4173            ]);
4174            const ANONYMOUS: bool = false;
4175            #[allow(unused_variables)]
4176            #[inline]
4177            fn new(
4178                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4179                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4180            ) -> Self {
4181                Self { amount: data.0 }
4182            }
4183            #[inline]
4184            fn check_signature(
4185                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4186            ) -> alloy_sol_types::Result<()> {
4187                if topics.0 != Self::SIGNATURE_HASH {
4188                    return Err(
4189                        alloy_sol_types::Error::invalid_event_signature_hash(
4190                            Self::SIGNATURE,
4191                            topics.0,
4192                            Self::SIGNATURE_HASH,
4193                        ),
4194                    );
4195                }
4196                Ok(())
4197            }
4198            #[inline]
4199            fn tokenize_body(&self) -> Self::DataToken<'_> {
4200                (
4201                    <alloy::sol_types::sol_data::Uint<
4202                        256,
4203                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
4204                )
4205            }
4206            #[inline]
4207            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4208                (Self::SIGNATURE_HASH.into(),)
4209            }
4210            #[inline]
4211            fn encode_topics_raw(
4212                &self,
4213                out: &mut [alloy_sol_types::abi::token::WordToken],
4214            ) -> alloy_sol_types::Result<()> {
4215                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4216                    return Err(alloy_sol_types::Error::Overrun);
4217                }
4218                out[0usize] = alloy_sol_types::abi::token::WordToken(
4219                    Self::SIGNATURE_HASH,
4220                );
4221                Ok(())
4222            }
4223        }
4224        #[automatically_derived]
4225        impl alloy_sol_types::private::IntoLogData for Withdrawn {
4226            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4227                From::from(self)
4228            }
4229            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4230                From::from(&self)
4231            }
4232        }
4233        #[automatically_derived]
4234        impl From<&Withdrawn> for alloy_sol_types::private::LogData {
4235            #[inline]
4236            fn from(this: &Withdrawn) -> alloy_sol_types::private::LogData {
4237                alloy_sol_types::SolEvent::encode_log_data(this)
4238            }
4239        }
4240    };
4241    /**Event with signature `WorkerIdUpdated(bytes32,bytes32)` and selector `0xcf79e0e27c8c35d39bd9b727f35e6f79573597f660c88baf483fc1511c49203c`.
4242```solidity
4243event WorkerIdUpdated(bytes32 onchainWorkerId, bytes32 offchainWorkerId);
4244```*/
4245    #[allow(
4246        non_camel_case_types,
4247        non_snake_case,
4248        clippy::pub_underscore_fields,
4249        clippy::style
4250    )]
4251    #[derive(Clone)]
4252    pub struct WorkerIdUpdated {
4253        #[allow(missing_docs)]
4254        pub onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
4255        #[allow(missing_docs)]
4256        pub offchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
4257    }
4258    #[allow(
4259        non_camel_case_types,
4260        non_snake_case,
4261        clippy::pub_underscore_fields,
4262        clippy::style
4263    )]
4264    const _: () = {
4265        use alloy::sol_types as alloy_sol_types;
4266        #[automatically_derived]
4267        impl alloy_sol_types::SolEvent for WorkerIdUpdated {
4268            type DataTuple<'a> = (
4269                alloy::sol_types::sol_data::FixedBytes<32>,
4270                alloy::sol_types::sol_data::FixedBytes<32>,
4271            );
4272            type DataToken<'a> = <Self::DataTuple<
4273                'a,
4274            > as alloy_sol_types::SolType>::Token<'a>;
4275            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
4276            const SIGNATURE: &'static str = "WorkerIdUpdated(bytes32,bytes32)";
4277            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
4278                207u8,
4279                121u8,
4280                224u8,
4281                226u8,
4282                124u8,
4283                140u8,
4284                53u8,
4285                211u8,
4286                155u8,
4287                217u8,
4288                183u8,
4289                39u8,
4290                243u8,
4291                94u8,
4292                111u8,
4293                121u8,
4294                87u8,
4295                53u8,
4296                151u8,
4297                246u8,
4298                96u8,
4299                200u8,
4300                139u8,
4301                175u8,
4302                72u8,
4303                63u8,
4304                193u8,
4305                81u8,
4306                28u8,
4307                73u8,
4308                32u8,
4309                60u8,
4310            ]);
4311            const ANONYMOUS: bool = false;
4312            #[allow(unused_variables)]
4313            #[inline]
4314            fn new(
4315                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4316                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4317            ) -> Self {
4318                Self {
4319                    onchainWorkerId: data.0,
4320                    offchainWorkerId: data.1,
4321                }
4322            }
4323            #[inline]
4324            fn check_signature(
4325                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4326            ) -> alloy_sol_types::Result<()> {
4327                if topics.0 != Self::SIGNATURE_HASH {
4328                    return Err(
4329                        alloy_sol_types::Error::invalid_event_signature_hash(
4330                            Self::SIGNATURE,
4331                            topics.0,
4332                            Self::SIGNATURE_HASH,
4333                        ),
4334                    );
4335                }
4336                Ok(())
4337            }
4338            #[inline]
4339            fn tokenize_body(&self) -> Self::DataToken<'_> {
4340                (
4341                    <alloy::sol_types::sol_data::FixedBytes<
4342                        32,
4343                    > as alloy_sol_types::SolType>::tokenize(&self.onchainWorkerId),
4344                    <alloy::sol_types::sol_data::FixedBytes<
4345                        32,
4346                    > as alloy_sol_types::SolType>::tokenize(&self.offchainWorkerId),
4347                )
4348            }
4349            #[inline]
4350            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4351                (Self::SIGNATURE_HASH.into(),)
4352            }
4353            #[inline]
4354            fn encode_topics_raw(
4355                &self,
4356                out: &mut [alloy_sol_types::abi::token::WordToken],
4357            ) -> alloy_sol_types::Result<()> {
4358                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4359                    return Err(alloy_sol_types::Error::Overrun);
4360                }
4361                out[0usize] = alloy_sol_types::abi::token::WordToken(
4362                    Self::SIGNATURE_HASH,
4363                );
4364                Ok(())
4365            }
4366        }
4367        #[automatically_derived]
4368        impl alloy_sol_types::private::IntoLogData for WorkerIdUpdated {
4369            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4370                From::from(self)
4371            }
4372            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4373                From::from(&self)
4374            }
4375        }
4376        #[automatically_derived]
4377        impl From<&WorkerIdUpdated> for alloy_sol_types::private::LogData {
4378            #[inline]
4379            fn from(this: &WorkerIdUpdated) -> alloy_sol_types::private::LogData {
4380                alloy_sol_types::SolEvent::encode_log_data(this)
4381            }
4382        }
4383    };
4384    /**Event with signature `WorkerJoined(bytes32,bytes32)` and selector `0x9cd57cfa2e12a37215cabc6897396db265419bd7f06adad06227a2b163ecd6a3`.
4385```solidity
4386event WorkerJoined(bytes32 indexed peerId, bytes32 onchainId);
4387```*/
4388    #[allow(
4389        non_camel_case_types,
4390        non_snake_case,
4391        clippy::pub_underscore_fields,
4392        clippy::style
4393    )]
4394    #[derive(Clone)]
4395    pub struct WorkerJoined {
4396        #[allow(missing_docs)]
4397        pub peerId: alloy::sol_types::private::FixedBytes<32>,
4398        #[allow(missing_docs)]
4399        pub onchainId: alloy::sol_types::private::FixedBytes<32>,
4400    }
4401    #[allow(
4402        non_camel_case_types,
4403        non_snake_case,
4404        clippy::pub_underscore_fields,
4405        clippy::style
4406    )]
4407    const _: () = {
4408        use alloy::sol_types as alloy_sol_types;
4409        #[automatically_derived]
4410        impl alloy_sol_types::SolEvent for WorkerJoined {
4411            type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4412            type DataToken<'a> = <Self::DataTuple<
4413                'a,
4414            > as alloy_sol_types::SolType>::Token<'a>;
4415            type TopicList = (
4416                alloy_sol_types::sol_data::FixedBytes<32>,
4417                alloy::sol_types::sol_data::FixedBytes<32>,
4418            );
4419            const SIGNATURE: &'static str = "WorkerJoined(bytes32,bytes32)";
4420            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
4421                156u8,
4422                213u8,
4423                124u8,
4424                250u8,
4425                46u8,
4426                18u8,
4427                163u8,
4428                114u8,
4429                21u8,
4430                202u8,
4431                188u8,
4432                104u8,
4433                151u8,
4434                57u8,
4435                109u8,
4436                178u8,
4437                101u8,
4438                65u8,
4439                155u8,
4440                215u8,
4441                240u8,
4442                106u8,
4443                218u8,
4444                208u8,
4445                98u8,
4446                39u8,
4447                162u8,
4448                177u8,
4449                99u8,
4450                236u8,
4451                214u8,
4452                163u8,
4453            ]);
4454            const ANONYMOUS: bool = false;
4455            #[allow(unused_variables)]
4456            #[inline]
4457            fn new(
4458                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4459                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4460            ) -> Self {
4461                Self {
4462                    peerId: topics.1,
4463                    onchainId: data.0,
4464                }
4465            }
4466            #[inline]
4467            fn check_signature(
4468                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4469            ) -> alloy_sol_types::Result<()> {
4470                if topics.0 != Self::SIGNATURE_HASH {
4471                    return Err(
4472                        alloy_sol_types::Error::invalid_event_signature_hash(
4473                            Self::SIGNATURE,
4474                            topics.0,
4475                            Self::SIGNATURE_HASH,
4476                        ),
4477                    );
4478                }
4479                Ok(())
4480            }
4481            #[inline]
4482            fn tokenize_body(&self) -> Self::DataToken<'_> {
4483                (
4484                    <alloy::sol_types::sol_data::FixedBytes<
4485                        32,
4486                    > as alloy_sol_types::SolType>::tokenize(&self.onchainId),
4487                )
4488            }
4489            #[inline]
4490            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4491                (Self::SIGNATURE_HASH.into(), self.peerId.clone())
4492            }
4493            #[inline]
4494            fn encode_topics_raw(
4495                &self,
4496                out: &mut [alloy_sol_types::abi::token::WordToken],
4497            ) -> alloy_sol_types::Result<()> {
4498                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4499                    return Err(alloy_sol_types::Error::Overrun);
4500                }
4501                out[0usize] = alloy_sol_types::abi::token::WordToken(
4502                    Self::SIGNATURE_HASH,
4503                );
4504                out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
4505                    32,
4506                > as alloy_sol_types::EventTopic>::encode_topic(&self.peerId);
4507                Ok(())
4508            }
4509        }
4510        #[automatically_derived]
4511        impl alloy_sol_types::private::IntoLogData for WorkerJoined {
4512            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4513                From::from(self)
4514            }
4515            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4516                From::from(&self)
4517            }
4518        }
4519        #[automatically_derived]
4520        impl From<&WorkerJoined> for alloy_sol_types::private::LogData {
4521            #[inline]
4522            fn from(this: &WorkerJoined) -> alloy_sol_types::private::LogData {
4523                alloy_sol_types::SolEvent::encode_log_data(this)
4524            }
4525        }
4526    };
4527    /**Event with signature `WorkerRemoved(bytes32,bytes32)` and selector `0x2931f8975c0ce3cdf8ebe0cac36f06048736d46d6df66ac21cfe717b9ee71006`.
4528```solidity
4529event WorkerRemoved(bytes32 indexed peerId, bytes32 onchainId);
4530```*/
4531    #[allow(
4532        non_camel_case_types,
4533        non_snake_case,
4534        clippy::pub_underscore_fields,
4535        clippy::style
4536    )]
4537    #[derive(Clone)]
4538    pub struct WorkerRemoved {
4539        #[allow(missing_docs)]
4540        pub peerId: alloy::sol_types::private::FixedBytes<32>,
4541        #[allow(missing_docs)]
4542        pub onchainId: alloy::sol_types::private::FixedBytes<32>,
4543    }
4544    #[allow(
4545        non_camel_case_types,
4546        non_snake_case,
4547        clippy::pub_underscore_fields,
4548        clippy::style
4549    )]
4550    const _: () = {
4551        use alloy::sol_types as alloy_sol_types;
4552        #[automatically_derived]
4553        impl alloy_sol_types::SolEvent for WorkerRemoved {
4554            type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4555            type DataToken<'a> = <Self::DataTuple<
4556                'a,
4557            > as alloy_sol_types::SolType>::Token<'a>;
4558            type TopicList = (
4559                alloy_sol_types::sol_data::FixedBytes<32>,
4560                alloy::sol_types::sol_data::FixedBytes<32>,
4561            );
4562            const SIGNATURE: &'static str = "WorkerRemoved(bytes32,bytes32)";
4563            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
4564                41u8,
4565                49u8,
4566                248u8,
4567                151u8,
4568                92u8,
4569                12u8,
4570                227u8,
4571                205u8,
4572                248u8,
4573                235u8,
4574                224u8,
4575                202u8,
4576                195u8,
4577                111u8,
4578                6u8,
4579                4u8,
4580                135u8,
4581                54u8,
4582                212u8,
4583                109u8,
4584                109u8,
4585                246u8,
4586                106u8,
4587                194u8,
4588                28u8,
4589                254u8,
4590                113u8,
4591                123u8,
4592                158u8,
4593                231u8,
4594                16u8,
4595                6u8,
4596            ]);
4597            const ANONYMOUS: bool = false;
4598            #[allow(unused_variables)]
4599            #[inline]
4600            fn new(
4601                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4602                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4603            ) -> Self {
4604                Self {
4605                    peerId: topics.1,
4606                    onchainId: data.0,
4607                }
4608            }
4609            #[inline]
4610            fn check_signature(
4611                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4612            ) -> alloy_sol_types::Result<()> {
4613                if topics.0 != Self::SIGNATURE_HASH {
4614                    return Err(
4615                        alloy_sol_types::Error::invalid_event_signature_hash(
4616                            Self::SIGNATURE,
4617                            topics.0,
4618                            Self::SIGNATURE_HASH,
4619                        ),
4620                    );
4621                }
4622                Ok(())
4623            }
4624            #[inline]
4625            fn tokenize_body(&self) -> Self::DataToken<'_> {
4626                (
4627                    <alloy::sol_types::sol_data::FixedBytes<
4628                        32,
4629                    > as alloy_sol_types::SolType>::tokenize(&self.onchainId),
4630                )
4631            }
4632            #[inline]
4633            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4634                (Self::SIGNATURE_HASH.into(), self.peerId.clone())
4635            }
4636            #[inline]
4637            fn encode_topics_raw(
4638                &self,
4639                out: &mut [alloy_sol_types::abi::token::WordToken],
4640            ) -> alloy_sol_types::Result<()> {
4641                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4642                    return Err(alloy_sol_types::Error::Overrun);
4643                }
4644                out[0usize] = alloy_sol_types::abi::token::WordToken(
4645                    Self::SIGNATURE_HASH,
4646                );
4647                out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
4648                    32,
4649                > as alloy_sol_types::EventTopic>::encode_topic(&self.peerId);
4650                Ok(())
4651            }
4652        }
4653        #[automatically_derived]
4654        impl alloy_sol_types::private::IntoLogData for WorkerRemoved {
4655            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4656                From::from(self)
4657            }
4658            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4659                From::from(&self)
4660            }
4661        }
4662        #[automatically_derived]
4663        impl From<&WorkerRemoved> for alloy_sol_types::private::LogData {
4664            #[inline]
4665            fn from(this: &WorkerRemoved) -> alloy_sol_types::private::LogData {
4666                alloy_sol_types::SolEvent::encode_log_data(this)
4667            }
4668        }
4669    };
4670    /**Function with signature `activateWorker(bytes32,bytes32)` and selector `0x22ebd58a`.
4671```solidity
4672function activateWorker(bytes32 onchainWorkerId, bytes32 offchainWorkerId) external;
4673```*/
4674    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4675    #[derive(Clone)]
4676    pub struct activateWorkerCall {
4677        #[allow(missing_docs)]
4678        pub onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
4679        #[allow(missing_docs)]
4680        pub offchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
4681    }
4682    ///Container type for the return parameters of the [`activateWorker(bytes32,bytes32)`](activateWorkerCall) function.
4683    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4684    #[derive(Clone)]
4685    pub struct activateWorkerReturn {}
4686    #[allow(
4687        non_camel_case_types,
4688        non_snake_case,
4689        clippy::pub_underscore_fields,
4690        clippy::style
4691    )]
4692    const _: () = {
4693        use alloy::sol_types as alloy_sol_types;
4694        {
4695            #[doc(hidden)]
4696            type UnderlyingSolTuple<'a> = (
4697                alloy::sol_types::sol_data::FixedBytes<32>,
4698                alloy::sol_types::sol_data::FixedBytes<32>,
4699            );
4700            #[doc(hidden)]
4701            type UnderlyingRustTuple<'a> = (
4702                alloy::sol_types::private::FixedBytes<32>,
4703                alloy::sol_types::private::FixedBytes<32>,
4704            );
4705            #[cfg(test)]
4706            #[allow(dead_code, unreachable_patterns)]
4707            fn _type_assertion(
4708                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4709            ) {
4710                match _t {
4711                    alloy_sol_types::private::AssertTypeEq::<
4712                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4713                    >(_) => {}
4714                }
4715            }
4716            #[automatically_derived]
4717            #[doc(hidden)]
4718            impl ::core::convert::From<activateWorkerCall> for UnderlyingRustTuple<'_> {
4719                fn from(value: activateWorkerCall) -> Self {
4720                    (value.onchainWorkerId, value.offchainWorkerId)
4721                }
4722            }
4723            #[automatically_derived]
4724            #[doc(hidden)]
4725            impl ::core::convert::From<UnderlyingRustTuple<'_>> for activateWorkerCall {
4726                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4727                    Self {
4728                        onchainWorkerId: tuple.0,
4729                        offchainWorkerId: tuple.1,
4730                    }
4731                }
4732            }
4733        }
4734        {
4735            #[doc(hidden)]
4736            type UnderlyingSolTuple<'a> = ();
4737            #[doc(hidden)]
4738            type UnderlyingRustTuple<'a> = ();
4739            #[cfg(test)]
4740            #[allow(dead_code, unreachable_patterns)]
4741            fn _type_assertion(
4742                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4743            ) {
4744                match _t {
4745                    alloy_sol_types::private::AssertTypeEq::<
4746                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4747                    >(_) => {}
4748                }
4749            }
4750            #[automatically_derived]
4751            #[doc(hidden)]
4752            impl ::core::convert::From<activateWorkerReturn>
4753            for UnderlyingRustTuple<'_> {
4754                fn from(value: activateWorkerReturn) -> Self {
4755                    ()
4756                }
4757            }
4758            #[automatically_derived]
4759            #[doc(hidden)]
4760            impl ::core::convert::From<UnderlyingRustTuple<'_>>
4761            for activateWorkerReturn {
4762                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4763                    Self {}
4764                }
4765            }
4766        }
4767        #[automatically_derived]
4768        impl alloy_sol_types::SolCall for activateWorkerCall {
4769            type Parameters<'a> = (
4770                alloy::sol_types::sol_data::FixedBytes<32>,
4771                alloy::sol_types::sol_data::FixedBytes<32>,
4772            );
4773            type Token<'a> = <Self::Parameters<
4774                'a,
4775            > as alloy_sol_types::SolType>::Token<'a>;
4776            type Return = activateWorkerReturn;
4777            type ReturnTuple<'a> = ();
4778            type ReturnToken<'a> = <Self::ReturnTuple<
4779                'a,
4780            > as alloy_sol_types::SolType>::Token<'a>;
4781            const SIGNATURE: &'static str = "activateWorker(bytes32,bytes32)";
4782            const SELECTOR: [u8; 4] = [34u8, 235u8, 213u8, 138u8];
4783            #[inline]
4784            fn new<'a>(
4785                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4786            ) -> Self {
4787                tuple.into()
4788            }
4789            #[inline]
4790            fn tokenize(&self) -> Self::Token<'_> {
4791                (
4792                    <alloy::sol_types::sol_data::FixedBytes<
4793                        32,
4794                    > as alloy_sol_types::SolType>::tokenize(&self.onchainWorkerId),
4795                    <alloy::sol_types::sol_data::FixedBytes<
4796                        32,
4797                    > as alloy_sol_types::SolType>::tokenize(&self.offchainWorkerId),
4798                )
4799            }
4800            #[inline]
4801            fn abi_decode_returns(
4802                data: &[u8],
4803                validate: bool,
4804            ) -> alloy_sol_types::Result<Self::Return> {
4805                <Self::ReturnTuple<
4806                    '_,
4807                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4808                    .map(Into::into)
4809            }
4810        }
4811    };
4812    /**Function with signature `addProviderToAccessList(address)` and selector `0x73134c15`.
4813```solidity
4814function addProviderToAccessList(address provider) external;
4815```*/
4816    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4817    #[derive(Clone)]
4818    pub struct addProviderToAccessListCall {
4819        #[allow(missing_docs)]
4820        pub provider: alloy::sol_types::private::Address,
4821    }
4822    ///Container type for the return parameters of the [`addProviderToAccessList(address)`](addProviderToAccessListCall) function.
4823    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4824    #[derive(Clone)]
4825    pub struct addProviderToAccessListReturn {}
4826    #[allow(
4827        non_camel_case_types,
4828        non_snake_case,
4829        clippy::pub_underscore_fields,
4830        clippy::style
4831    )]
4832    const _: () = {
4833        use alloy::sol_types as alloy_sol_types;
4834        {
4835            #[doc(hidden)]
4836            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4837            #[doc(hidden)]
4838            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4839            #[cfg(test)]
4840            #[allow(dead_code, unreachable_patterns)]
4841            fn _type_assertion(
4842                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4843            ) {
4844                match _t {
4845                    alloy_sol_types::private::AssertTypeEq::<
4846                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4847                    >(_) => {}
4848                }
4849            }
4850            #[automatically_derived]
4851            #[doc(hidden)]
4852            impl ::core::convert::From<addProviderToAccessListCall>
4853            for UnderlyingRustTuple<'_> {
4854                fn from(value: addProviderToAccessListCall) -> Self {
4855                    (value.provider,)
4856                }
4857            }
4858            #[automatically_derived]
4859            #[doc(hidden)]
4860            impl ::core::convert::From<UnderlyingRustTuple<'_>>
4861            for addProviderToAccessListCall {
4862                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4863                    Self { provider: tuple.0 }
4864                }
4865            }
4866        }
4867        {
4868            #[doc(hidden)]
4869            type UnderlyingSolTuple<'a> = ();
4870            #[doc(hidden)]
4871            type UnderlyingRustTuple<'a> = ();
4872            #[cfg(test)]
4873            #[allow(dead_code, unreachable_patterns)]
4874            fn _type_assertion(
4875                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4876            ) {
4877                match _t {
4878                    alloy_sol_types::private::AssertTypeEq::<
4879                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4880                    >(_) => {}
4881                }
4882            }
4883            #[automatically_derived]
4884            #[doc(hidden)]
4885            impl ::core::convert::From<addProviderToAccessListReturn>
4886            for UnderlyingRustTuple<'_> {
4887                fn from(value: addProviderToAccessListReturn) -> Self {
4888                    ()
4889                }
4890            }
4891            #[automatically_derived]
4892            #[doc(hidden)]
4893            impl ::core::convert::From<UnderlyingRustTuple<'_>>
4894            for addProviderToAccessListReturn {
4895                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4896                    Self {}
4897                }
4898            }
4899        }
4900        #[automatically_derived]
4901        impl alloy_sol_types::SolCall for addProviderToAccessListCall {
4902            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4903            type Token<'a> = <Self::Parameters<
4904                'a,
4905            > as alloy_sol_types::SolType>::Token<'a>;
4906            type Return = addProviderToAccessListReturn;
4907            type ReturnTuple<'a> = ();
4908            type ReturnToken<'a> = <Self::ReturnTuple<
4909                'a,
4910            > as alloy_sol_types::SolType>::Token<'a>;
4911            const SIGNATURE: &'static str = "addProviderToAccessList(address)";
4912            const SELECTOR: [u8; 4] = [115u8, 19u8, 76u8, 21u8];
4913            #[inline]
4914            fn new<'a>(
4915                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4916            ) -> Self {
4917                tuple.into()
4918            }
4919            #[inline]
4920            fn tokenize(&self) -> Self::Token<'_> {
4921                (
4922                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4923                        &self.provider,
4924                    ),
4925                )
4926            }
4927            #[inline]
4928            fn abi_decode_returns(
4929                data: &[u8],
4930                validate: bool,
4931            ) -> alloy_sol_types::Result<Self::Return> {
4932                <Self::ReturnTuple<
4933                    '_,
4934                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4935                    .map(Into::into)
4936            }
4937        }
4938    };
4939    /**Function with signature `addWorker(address,(bytes32),bytes32)` and selector `0xcef74c8b`.
4940```solidity
4941function addWorker(address computeProvider, IWorkerManagerV2.WorkerDataV2 memory workerData, bytes32 peerId) external;
4942```*/
4943    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4944    #[derive(Clone)]
4945    pub struct addWorkerCall {
4946        #[allow(missing_docs)]
4947        pub computeProvider: alloy::sol_types::private::Address,
4948        #[allow(missing_docs)]
4949        pub workerData: <IWorkerManagerV2::WorkerDataV2 as alloy::sol_types::SolType>::RustType,
4950        #[allow(missing_docs)]
4951        pub peerId: alloy::sol_types::private::FixedBytes<32>,
4952    }
4953    ///Container type for the return parameters of the [`addWorker(address,(bytes32),bytes32)`](addWorkerCall) function.
4954    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4955    #[derive(Clone)]
4956    pub struct addWorkerReturn {}
4957    #[allow(
4958        non_camel_case_types,
4959        non_snake_case,
4960        clippy::pub_underscore_fields,
4961        clippy::style
4962    )]
4963    const _: () = {
4964        use alloy::sol_types as alloy_sol_types;
4965        {
4966            #[doc(hidden)]
4967            type UnderlyingSolTuple<'a> = (
4968                alloy::sol_types::sol_data::Address,
4969                IWorkerManagerV2::WorkerDataV2,
4970                alloy::sol_types::sol_data::FixedBytes<32>,
4971            );
4972            #[doc(hidden)]
4973            type UnderlyingRustTuple<'a> = (
4974                alloy::sol_types::private::Address,
4975                <IWorkerManagerV2::WorkerDataV2 as alloy::sol_types::SolType>::RustType,
4976                alloy::sol_types::private::FixedBytes<32>,
4977            );
4978            #[cfg(test)]
4979            #[allow(dead_code, unreachable_patterns)]
4980            fn _type_assertion(
4981                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4982            ) {
4983                match _t {
4984                    alloy_sol_types::private::AssertTypeEq::<
4985                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4986                    >(_) => {}
4987                }
4988            }
4989            #[automatically_derived]
4990            #[doc(hidden)]
4991            impl ::core::convert::From<addWorkerCall> for UnderlyingRustTuple<'_> {
4992                fn from(value: addWorkerCall) -> Self {
4993                    (value.computeProvider, value.workerData, value.peerId)
4994                }
4995            }
4996            #[automatically_derived]
4997            #[doc(hidden)]
4998            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addWorkerCall {
4999                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5000                    Self {
5001                        computeProvider: tuple.0,
5002                        workerData: tuple.1,
5003                        peerId: tuple.2,
5004                    }
5005                }
5006            }
5007        }
5008        {
5009            #[doc(hidden)]
5010            type UnderlyingSolTuple<'a> = ();
5011            #[doc(hidden)]
5012            type UnderlyingRustTuple<'a> = ();
5013            #[cfg(test)]
5014            #[allow(dead_code, unreachable_patterns)]
5015            fn _type_assertion(
5016                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5017            ) {
5018                match _t {
5019                    alloy_sol_types::private::AssertTypeEq::<
5020                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5021                    >(_) => {}
5022                }
5023            }
5024            #[automatically_derived]
5025            #[doc(hidden)]
5026            impl ::core::convert::From<addWorkerReturn> for UnderlyingRustTuple<'_> {
5027                fn from(value: addWorkerReturn) -> Self {
5028                    ()
5029                }
5030            }
5031            #[automatically_derived]
5032            #[doc(hidden)]
5033            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addWorkerReturn {
5034                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5035                    Self {}
5036                }
5037            }
5038        }
5039        #[automatically_derived]
5040        impl alloy_sol_types::SolCall for addWorkerCall {
5041            type Parameters<'a> = (
5042                alloy::sol_types::sol_data::Address,
5043                IWorkerManagerV2::WorkerDataV2,
5044                alloy::sol_types::sol_data::FixedBytes<32>,
5045            );
5046            type Token<'a> = <Self::Parameters<
5047                'a,
5048            > as alloy_sol_types::SolType>::Token<'a>;
5049            type Return = addWorkerReturn;
5050            type ReturnTuple<'a> = ();
5051            type ReturnToken<'a> = <Self::ReturnTuple<
5052                'a,
5053            > as alloy_sol_types::SolType>::Token<'a>;
5054            const SIGNATURE: &'static str = "addWorker(address,(bytes32),bytes32)";
5055            const SELECTOR: [u8; 4] = [206u8, 247u8, 76u8, 139u8];
5056            #[inline]
5057            fn new<'a>(
5058                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5059            ) -> Self {
5060                tuple.into()
5061            }
5062            #[inline]
5063            fn tokenize(&self) -> Self::Token<'_> {
5064                (
5065                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5066                        &self.computeProvider,
5067                    ),
5068                    <IWorkerManagerV2::WorkerDataV2 as alloy_sol_types::SolType>::tokenize(
5069                        &self.workerData,
5070                    ),
5071                    <alloy::sol_types::sol_data::FixedBytes<
5072                        32,
5073                    > as alloy_sol_types::SolType>::tokenize(&self.peerId),
5074                )
5075            }
5076            #[inline]
5077            fn abi_decode_returns(
5078                data: &[u8],
5079                validate: bool,
5080            ) -> alloy_sol_types::Result<Self::Return> {
5081                <Self::ReturnTuple<
5082                    '_,
5083                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5084                    .map(Into::into)
5085            }
5086        }
5087    };
5088    /**Function with signature `appCID()` and selector `0x9bc66868`.
5089```solidity
5090function appCID() external view returns (Common.CIDV1 memory);
5091```*/
5092    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5093    #[derive(Clone)]
5094    pub struct appCIDCall {}
5095    ///Container type for the return parameters of the [`appCID()`](appCIDCall) function.
5096    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5097    #[derive(Clone)]
5098    pub struct appCIDReturn {
5099        #[allow(missing_docs)]
5100        pub _0: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
5101    }
5102    #[allow(
5103        non_camel_case_types,
5104        non_snake_case,
5105        clippy::pub_underscore_fields,
5106        clippy::style
5107    )]
5108    const _: () = {
5109        use alloy::sol_types as alloy_sol_types;
5110        {
5111            #[doc(hidden)]
5112            type UnderlyingSolTuple<'a> = ();
5113            #[doc(hidden)]
5114            type UnderlyingRustTuple<'a> = ();
5115            #[cfg(test)]
5116            #[allow(dead_code, unreachable_patterns)]
5117            fn _type_assertion(
5118                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5119            ) {
5120                match _t {
5121                    alloy_sol_types::private::AssertTypeEq::<
5122                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5123                    >(_) => {}
5124                }
5125            }
5126            #[automatically_derived]
5127            #[doc(hidden)]
5128            impl ::core::convert::From<appCIDCall> for UnderlyingRustTuple<'_> {
5129                fn from(value: appCIDCall) -> Self {
5130                    ()
5131                }
5132            }
5133            #[automatically_derived]
5134            #[doc(hidden)]
5135            impl ::core::convert::From<UnderlyingRustTuple<'_>> for appCIDCall {
5136                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5137                    Self {}
5138                }
5139            }
5140        }
5141        {
5142            #[doc(hidden)]
5143            type UnderlyingSolTuple<'a> = (Common::CIDV1,);
5144            #[doc(hidden)]
5145            type UnderlyingRustTuple<'a> = (
5146                <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
5147            );
5148            #[cfg(test)]
5149            #[allow(dead_code, unreachable_patterns)]
5150            fn _type_assertion(
5151                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5152            ) {
5153                match _t {
5154                    alloy_sol_types::private::AssertTypeEq::<
5155                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5156                    >(_) => {}
5157                }
5158            }
5159            #[automatically_derived]
5160            #[doc(hidden)]
5161            impl ::core::convert::From<appCIDReturn> for UnderlyingRustTuple<'_> {
5162                fn from(value: appCIDReturn) -> Self {
5163                    (value._0,)
5164                }
5165            }
5166            #[automatically_derived]
5167            #[doc(hidden)]
5168            impl ::core::convert::From<UnderlyingRustTuple<'_>> for appCIDReturn {
5169                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5170                    Self { _0: tuple.0 }
5171                }
5172            }
5173        }
5174        #[automatically_derived]
5175        impl alloy_sol_types::SolCall for appCIDCall {
5176            type Parameters<'a> = ();
5177            type Token<'a> = <Self::Parameters<
5178                'a,
5179            > as alloy_sol_types::SolType>::Token<'a>;
5180            type Return = appCIDReturn;
5181            type ReturnTuple<'a> = (Common::CIDV1,);
5182            type ReturnToken<'a> = <Self::ReturnTuple<
5183                'a,
5184            > as alloy_sol_types::SolType>::Token<'a>;
5185            const SIGNATURE: &'static str = "appCID()";
5186            const SELECTOR: [u8; 4] = [155u8, 198u8, 104u8, 104u8];
5187            #[inline]
5188            fn new<'a>(
5189                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5190            ) -> Self {
5191                tuple.into()
5192            }
5193            #[inline]
5194            fn tokenize(&self) -> Self::Token<'_> {
5195                ()
5196            }
5197            #[inline]
5198            fn abi_decode_returns(
5199                data: &[u8],
5200                validate: bool,
5201            ) -> alloy_sol_types::Result<Self::Return> {
5202                <Self::ReturnTuple<
5203                    '_,
5204                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5205                    .map(Into::into)
5206            }
5207        }
5208    };
5209    /**Function with signature `changeProvidersAccessType(uint8)` and selector `0x636fcefb`.
5210```solidity
5211function changeProvidersAccessType(IConfigV2.AccessTypeV2 accessType) external;
5212```*/
5213    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5214    #[derive(Clone)]
5215    pub struct changeProvidersAccessTypeCall {
5216        #[allow(missing_docs)]
5217        pub accessType: <IConfigV2::AccessTypeV2 as alloy::sol_types::SolType>::RustType,
5218    }
5219    ///Container type for the return parameters of the [`changeProvidersAccessType(uint8)`](changeProvidersAccessTypeCall) function.
5220    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5221    #[derive(Clone)]
5222    pub struct changeProvidersAccessTypeReturn {}
5223    #[allow(
5224        non_camel_case_types,
5225        non_snake_case,
5226        clippy::pub_underscore_fields,
5227        clippy::style
5228    )]
5229    const _: () = {
5230        use alloy::sol_types as alloy_sol_types;
5231        {
5232            #[doc(hidden)]
5233            type UnderlyingSolTuple<'a> = (IConfigV2::AccessTypeV2,);
5234            #[doc(hidden)]
5235            type UnderlyingRustTuple<'a> = (
5236                <IConfigV2::AccessTypeV2 as alloy::sol_types::SolType>::RustType,
5237            );
5238            #[cfg(test)]
5239            #[allow(dead_code, unreachable_patterns)]
5240            fn _type_assertion(
5241                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5242            ) {
5243                match _t {
5244                    alloy_sol_types::private::AssertTypeEq::<
5245                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5246                    >(_) => {}
5247                }
5248            }
5249            #[automatically_derived]
5250            #[doc(hidden)]
5251            impl ::core::convert::From<changeProvidersAccessTypeCall>
5252            for UnderlyingRustTuple<'_> {
5253                fn from(value: changeProvidersAccessTypeCall) -> Self {
5254                    (value.accessType,)
5255                }
5256            }
5257            #[automatically_derived]
5258            #[doc(hidden)]
5259            impl ::core::convert::From<UnderlyingRustTuple<'_>>
5260            for changeProvidersAccessTypeCall {
5261                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5262                    Self { accessType: tuple.0 }
5263                }
5264            }
5265        }
5266        {
5267            #[doc(hidden)]
5268            type UnderlyingSolTuple<'a> = ();
5269            #[doc(hidden)]
5270            type UnderlyingRustTuple<'a> = ();
5271            #[cfg(test)]
5272            #[allow(dead_code, unreachable_patterns)]
5273            fn _type_assertion(
5274                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5275            ) {
5276                match _t {
5277                    alloy_sol_types::private::AssertTypeEq::<
5278                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5279                    >(_) => {}
5280                }
5281            }
5282            #[automatically_derived]
5283            #[doc(hidden)]
5284            impl ::core::convert::From<changeProvidersAccessTypeReturn>
5285            for UnderlyingRustTuple<'_> {
5286                fn from(value: changeProvidersAccessTypeReturn) -> Self {
5287                    ()
5288                }
5289            }
5290            #[automatically_derived]
5291            #[doc(hidden)]
5292            impl ::core::convert::From<UnderlyingRustTuple<'_>>
5293            for changeProvidersAccessTypeReturn {
5294                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5295                    Self {}
5296                }
5297            }
5298        }
5299        #[automatically_derived]
5300        impl alloy_sol_types::SolCall for changeProvidersAccessTypeCall {
5301            type Parameters<'a> = (IConfigV2::AccessTypeV2,);
5302            type Token<'a> = <Self::Parameters<
5303                'a,
5304            > as alloy_sol_types::SolType>::Token<'a>;
5305            type Return = changeProvidersAccessTypeReturn;
5306            type ReturnTuple<'a> = ();
5307            type ReturnToken<'a> = <Self::ReturnTuple<
5308                'a,
5309            > as alloy_sol_types::SolType>::Token<'a>;
5310            const SIGNATURE: &'static str = "changeProvidersAccessType(uint8)";
5311            const SELECTOR: [u8; 4] = [99u8, 111u8, 206u8, 251u8];
5312            #[inline]
5313            fn new<'a>(
5314                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5315            ) -> Self {
5316                tuple.into()
5317            }
5318            #[inline]
5319            fn tokenize(&self) -> Self::Token<'_> {
5320                (
5321                    <IConfigV2::AccessTypeV2 as alloy_sol_types::SolType>::tokenize(
5322                        &self.accessType,
5323                    ),
5324                )
5325            }
5326            #[inline]
5327            fn abi_decode_returns(
5328                data: &[u8],
5329                validate: bool,
5330            ) -> alloy_sol_types::Result<Self::Return> {
5331                <Self::ReturnTuple<
5332                    '_,
5333                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5334                    .map(Into::into)
5335            }
5336        }
5337    };
5338    /**Function with signature `computePeerUsed(bytes32)` and selector `0xbd1926e0`.
5339```solidity
5340function computePeerUsed(bytes32 peerId) external view returns (bool);
5341```*/
5342    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5343    #[derive(Clone)]
5344    pub struct computePeerUsedCall {
5345        #[allow(missing_docs)]
5346        pub peerId: alloy::sol_types::private::FixedBytes<32>,
5347    }
5348    ///Container type for the return parameters of the [`computePeerUsed(bytes32)`](computePeerUsedCall) function.
5349    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5350    #[derive(Clone)]
5351    pub struct computePeerUsedReturn {
5352        #[allow(missing_docs)]
5353        pub _0: bool,
5354    }
5355    #[allow(
5356        non_camel_case_types,
5357        non_snake_case,
5358        clippy::pub_underscore_fields,
5359        clippy::style
5360    )]
5361    const _: () = {
5362        use alloy::sol_types as alloy_sol_types;
5363        {
5364            #[doc(hidden)]
5365            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5366            #[doc(hidden)]
5367            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5368            #[cfg(test)]
5369            #[allow(dead_code, unreachable_patterns)]
5370            fn _type_assertion(
5371                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5372            ) {
5373                match _t {
5374                    alloy_sol_types::private::AssertTypeEq::<
5375                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5376                    >(_) => {}
5377                }
5378            }
5379            #[automatically_derived]
5380            #[doc(hidden)]
5381            impl ::core::convert::From<computePeerUsedCall> for UnderlyingRustTuple<'_> {
5382                fn from(value: computePeerUsedCall) -> Self {
5383                    (value.peerId,)
5384                }
5385            }
5386            #[automatically_derived]
5387            #[doc(hidden)]
5388            impl ::core::convert::From<UnderlyingRustTuple<'_>> for computePeerUsedCall {
5389                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5390                    Self { peerId: tuple.0 }
5391                }
5392            }
5393        }
5394        {
5395            #[doc(hidden)]
5396            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5397            #[doc(hidden)]
5398            type UnderlyingRustTuple<'a> = (bool,);
5399            #[cfg(test)]
5400            #[allow(dead_code, unreachable_patterns)]
5401            fn _type_assertion(
5402                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5403            ) {
5404                match _t {
5405                    alloy_sol_types::private::AssertTypeEq::<
5406                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5407                    >(_) => {}
5408                }
5409            }
5410            #[automatically_derived]
5411            #[doc(hidden)]
5412            impl ::core::convert::From<computePeerUsedReturn>
5413            for UnderlyingRustTuple<'_> {
5414                fn from(value: computePeerUsedReturn) -> Self {
5415                    (value._0,)
5416                }
5417            }
5418            #[automatically_derived]
5419            #[doc(hidden)]
5420            impl ::core::convert::From<UnderlyingRustTuple<'_>>
5421            for computePeerUsedReturn {
5422                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5423                    Self { _0: tuple.0 }
5424                }
5425            }
5426        }
5427        #[automatically_derived]
5428        impl alloy_sol_types::SolCall for computePeerUsedCall {
5429            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5430            type Token<'a> = <Self::Parameters<
5431                'a,
5432            > as alloy_sol_types::SolType>::Token<'a>;
5433            type Return = computePeerUsedReturn;
5434            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5435            type ReturnToken<'a> = <Self::ReturnTuple<
5436                'a,
5437            > as alloy_sol_types::SolType>::Token<'a>;
5438            const SIGNATURE: &'static str = "computePeerUsed(bytes32)";
5439            const SELECTOR: [u8; 4] = [189u8, 25u8, 38u8, 224u8];
5440            #[inline]
5441            fn new<'a>(
5442                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5443            ) -> Self {
5444                tuple.into()
5445            }
5446            #[inline]
5447            fn tokenize(&self) -> Self::Token<'_> {
5448                (
5449                    <alloy::sol_types::sol_data::FixedBytes<
5450                        32,
5451                    > as alloy_sol_types::SolType>::tokenize(&self.peerId),
5452                )
5453            }
5454            #[inline]
5455            fn abi_decode_returns(
5456                data: &[u8],
5457                validate: bool,
5458            ) -> alloy_sol_types::Result<Self::Return> {
5459                <Self::ReturnTuple<
5460                    '_,
5461                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5462                    .map(Into::into)
5463            }
5464        }
5465    };
5466    /**Function with signature `creationBlock()` and selector `0x17634514`.
5467```solidity
5468function creationBlock() external view returns (uint256);
5469```*/
5470    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5471    #[derive(Clone)]
5472    pub struct creationBlockCall {}
5473    ///Container type for the return parameters of the [`creationBlock()`](creationBlockCall) function.
5474    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5475    #[derive(Clone)]
5476    pub struct creationBlockReturn {
5477        #[allow(missing_docs)]
5478        pub _0: alloy::sol_types::private::primitives::aliases::U256,
5479    }
5480    #[allow(
5481        non_camel_case_types,
5482        non_snake_case,
5483        clippy::pub_underscore_fields,
5484        clippy::style
5485    )]
5486    const _: () = {
5487        use alloy::sol_types as alloy_sol_types;
5488        {
5489            #[doc(hidden)]
5490            type UnderlyingSolTuple<'a> = ();
5491            #[doc(hidden)]
5492            type UnderlyingRustTuple<'a> = ();
5493            #[cfg(test)]
5494            #[allow(dead_code, unreachable_patterns)]
5495            fn _type_assertion(
5496                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5497            ) {
5498                match _t {
5499                    alloy_sol_types::private::AssertTypeEq::<
5500                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5501                    >(_) => {}
5502                }
5503            }
5504            #[automatically_derived]
5505            #[doc(hidden)]
5506            impl ::core::convert::From<creationBlockCall> for UnderlyingRustTuple<'_> {
5507                fn from(value: creationBlockCall) -> Self {
5508                    ()
5509                }
5510            }
5511            #[automatically_derived]
5512            #[doc(hidden)]
5513            impl ::core::convert::From<UnderlyingRustTuple<'_>> for creationBlockCall {
5514                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5515                    Self {}
5516                }
5517            }
5518        }
5519        {
5520            #[doc(hidden)]
5521            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5522            #[doc(hidden)]
5523            type UnderlyingRustTuple<'a> = (
5524                alloy::sol_types::private::primitives::aliases::U256,
5525            );
5526            #[cfg(test)]
5527            #[allow(dead_code, unreachable_patterns)]
5528            fn _type_assertion(
5529                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5530            ) {
5531                match _t {
5532                    alloy_sol_types::private::AssertTypeEq::<
5533                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5534                    >(_) => {}
5535                }
5536            }
5537            #[automatically_derived]
5538            #[doc(hidden)]
5539            impl ::core::convert::From<creationBlockReturn> for UnderlyingRustTuple<'_> {
5540                fn from(value: creationBlockReturn) -> Self {
5541                    (value._0,)
5542                }
5543            }
5544            #[automatically_derived]
5545            #[doc(hidden)]
5546            impl ::core::convert::From<UnderlyingRustTuple<'_>> for creationBlockReturn {
5547                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5548                    Self { _0: tuple.0 }
5549                }
5550            }
5551        }
5552        #[automatically_derived]
5553        impl alloy_sol_types::SolCall for creationBlockCall {
5554            type Parameters<'a> = ();
5555            type Token<'a> = <Self::Parameters<
5556                'a,
5557            > as alloy_sol_types::SolType>::Token<'a>;
5558            type Return = creationBlockReturn;
5559            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5560            type ReturnToken<'a> = <Self::ReturnTuple<
5561                'a,
5562            > as alloy_sol_types::SolType>::Token<'a>;
5563            const SIGNATURE: &'static str = "creationBlock()";
5564            const SELECTOR: [u8; 4] = [23u8, 99u8, 69u8, 20u8];
5565            #[inline]
5566            fn new<'a>(
5567                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5568            ) -> Self {
5569                tuple.into()
5570            }
5571            #[inline]
5572            fn tokenize(&self) -> Self::Token<'_> {
5573                ()
5574            }
5575            #[inline]
5576            fn abi_decode_returns(
5577                data: &[u8],
5578                validate: bool,
5579            ) -> alloy_sol_types::Result<Self::Return> {
5580                <Self::ReturnTuple<
5581                    '_,
5582                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5583                    .map(Into::into)
5584            }
5585        }
5586    };
5587    /**Function with signature `depositFromOwner(uint256,uint8)` and selector `0xed7b7653`.
5588```solidity
5589function depositFromOwner(uint256 amount, IBalanceKeeper.DealDepositReason reason) external;
5590```*/
5591    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5592    #[derive(Clone)]
5593    pub struct depositFromOwnerCall {
5594        #[allow(missing_docs)]
5595        pub amount: alloy::sol_types::private::primitives::aliases::U256,
5596        #[allow(missing_docs)]
5597        pub reason: <IBalanceKeeper::DealDepositReason as alloy::sol_types::SolType>::RustType,
5598    }
5599    ///Container type for the return parameters of the [`depositFromOwner(uint256,uint8)`](depositFromOwnerCall) function.
5600    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5601    #[derive(Clone)]
5602    pub struct depositFromOwnerReturn {}
5603    #[allow(
5604        non_camel_case_types,
5605        non_snake_case,
5606        clippy::pub_underscore_fields,
5607        clippy::style
5608    )]
5609    const _: () = {
5610        use alloy::sol_types as alloy_sol_types;
5611        {
5612            #[doc(hidden)]
5613            type UnderlyingSolTuple<'a> = (
5614                alloy::sol_types::sol_data::Uint<256>,
5615                IBalanceKeeper::DealDepositReason,
5616            );
5617            #[doc(hidden)]
5618            type UnderlyingRustTuple<'a> = (
5619                alloy::sol_types::private::primitives::aliases::U256,
5620                <IBalanceKeeper::DealDepositReason as alloy::sol_types::SolType>::RustType,
5621            );
5622            #[cfg(test)]
5623            #[allow(dead_code, unreachable_patterns)]
5624            fn _type_assertion(
5625                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5626            ) {
5627                match _t {
5628                    alloy_sol_types::private::AssertTypeEq::<
5629                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5630                    >(_) => {}
5631                }
5632            }
5633            #[automatically_derived]
5634            #[doc(hidden)]
5635            impl ::core::convert::From<depositFromOwnerCall>
5636            for UnderlyingRustTuple<'_> {
5637                fn from(value: depositFromOwnerCall) -> Self {
5638                    (value.amount, value.reason)
5639                }
5640            }
5641            #[automatically_derived]
5642            #[doc(hidden)]
5643            impl ::core::convert::From<UnderlyingRustTuple<'_>>
5644            for depositFromOwnerCall {
5645                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5646                    Self {
5647                        amount: tuple.0,
5648                        reason: tuple.1,
5649                    }
5650                }
5651            }
5652        }
5653        {
5654            #[doc(hidden)]
5655            type UnderlyingSolTuple<'a> = ();
5656            #[doc(hidden)]
5657            type UnderlyingRustTuple<'a> = ();
5658            #[cfg(test)]
5659            #[allow(dead_code, unreachable_patterns)]
5660            fn _type_assertion(
5661                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5662            ) {
5663                match _t {
5664                    alloy_sol_types::private::AssertTypeEq::<
5665                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5666                    >(_) => {}
5667                }
5668            }
5669            #[automatically_derived]
5670            #[doc(hidden)]
5671            impl ::core::convert::From<depositFromOwnerReturn>
5672            for UnderlyingRustTuple<'_> {
5673                fn from(value: depositFromOwnerReturn) -> Self {
5674                    ()
5675                }
5676            }
5677            #[automatically_derived]
5678            #[doc(hidden)]
5679            impl ::core::convert::From<UnderlyingRustTuple<'_>>
5680            for depositFromOwnerReturn {
5681                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5682                    Self {}
5683                }
5684            }
5685        }
5686        #[automatically_derived]
5687        impl alloy_sol_types::SolCall for depositFromOwnerCall {
5688            type Parameters<'a> = (
5689                alloy::sol_types::sol_data::Uint<256>,
5690                IBalanceKeeper::DealDepositReason,
5691            );
5692            type Token<'a> = <Self::Parameters<
5693                'a,
5694            > as alloy_sol_types::SolType>::Token<'a>;
5695            type Return = depositFromOwnerReturn;
5696            type ReturnTuple<'a> = ();
5697            type ReturnToken<'a> = <Self::ReturnTuple<
5698                'a,
5699            > as alloy_sol_types::SolType>::Token<'a>;
5700            const SIGNATURE: &'static str = "depositFromOwner(uint256,uint8)";
5701            const SELECTOR: [u8; 4] = [237u8, 123u8, 118u8, 83u8];
5702            #[inline]
5703            fn new<'a>(
5704                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5705            ) -> Self {
5706                tuple.into()
5707            }
5708            #[inline]
5709            fn tokenize(&self) -> Self::Token<'_> {
5710                (
5711                    <alloy::sol_types::sol_data::Uint<
5712                        256,
5713                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
5714                    <IBalanceKeeper::DealDepositReason as alloy_sol_types::SolType>::tokenize(
5715                        &self.reason,
5716                    ),
5717                )
5718            }
5719            #[inline]
5720            fn abi_decode_returns(
5721                data: &[u8],
5722                validate: bool,
5723            ) -> alloy_sol_types::Result<Self::Return> {
5724                <Self::ReturnTuple<
5725                    '_,
5726                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5727                    .map(Into::into)
5728            }
5729        }
5730    };
5731    /**Function with signature `getActivatedWorkerCount()` and selector `0xade0a202`.
5732```solidity
5733function getActivatedWorkerCount() external view returns (uint256);
5734```*/
5735    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5736    #[derive(Clone)]
5737    pub struct getActivatedWorkerCountCall {}
5738    ///Container type for the return parameters of the [`getActivatedWorkerCount()`](getActivatedWorkerCountCall) function.
5739    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5740    #[derive(Clone)]
5741    pub struct getActivatedWorkerCountReturn {
5742        #[allow(missing_docs)]
5743        pub _0: alloy::sol_types::private::primitives::aliases::U256,
5744    }
5745    #[allow(
5746        non_camel_case_types,
5747        non_snake_case,
5748        clippy::pub_underscore_fields,
5749        clippy::style
5750    )]
5751    const _: () = {
5752        use alloy::sol_types as alloy_sol_types;
5753        {
5754            #[doc(hidden)]
5755            type UnderlyingSolTuple<'a> = ();
5756            #[doc(hidden)]
5757            type UnderlyingRustTuple<'a> = ();
5758            #[cfg(test)]
5759            #[allow(dead_code, unreachable_patterns)]
5760            fn _type_assertion(
5761                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5762            ) {
5763                match _t {
5764                    alloy_sol_types::private::AssertTypeEq::<
5765                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5766                    >(_) => {}
5767                }
5768            }
5769            #[automatically_derived]
5770            #[doc(hidden)]
5771            impl ::core::convert::From<getActivatedWorkerCountCall>
5772            for UnderlyingRustTuple<'_> {
5773                fn from(value: getActivatedWorkerCountCall) -> Self {
5774                    ()
5775                }
5776            }
5777            #[automatically_derived]
5778            #[doc(hidden)]
5779            impl ::core::convert::From<UnderlyingRustTuple<'_>>
5780            for getActivatedWorkerCountCall {
5781                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5782                    Self {}
5783                }
5784            }
5785        }
5786        {
5787            #[doc(hidden)]
5788            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5789            #[doc(hidden)]
5790            type UnderlyingRustTuple<'a> = (
5791                alloy::sol_types::private::primitives::aliases::U256,
5792            );
5793            #[cfg(test)]
5794            #[allow(dead_code, unreachable_patterns)]
5795            fn _type_assertion(
5796                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5797            ) {
5798                match _t {
5799                    alloy_sol_types::private::AssertTypeEq::<
5800                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5801                    >(_) => {}
5802                }
5803            }
5804            #[automatically_derived]
5805            #[doc(hidden)]
5806            impl ::core::convert::From<getActivatedWorkerCountReturn>
5807            for UnderlyingRustTuple<'_> {
5808                fn from(value: getActivatedWorkerCountReturn) -> Self {
5809                    (value._0,)
5810                }
5811            }
5812            #[automatically_derived]
5813            #[doc(hidden)]
5814            impl ::core::convert::From<UnderlyingRustTuple<'_>>
5815            for getActivatedWorkerCountReturn {
5816                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5817                    Self { _0: tuple.0 }
5818                }
5819            }
5820        }
5821        #[automatically_derived]
5822        impl alloy_sol_types::SolCall for getActivatedWorkerCountCall {
5823            type Parameters<'a> = ();
5824            type Token<'a> = <Self::Parameters<
5825                'a,
5826            > as alloy_sol_types::SolType>::Token<'a>;
5827            type Return = getActivatedWorkerCountReturn;
5828            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5829            type ReturnToken<'a> = <Self::ReturnTuple<
5830                'a,
5831            > as alloy_sol_types::SolType>::Token<'a>;
5832            const SIGNATURE: &'static str = "getActivatedWorkerCount()";
5833            const SELECTOR: [u8; 4] = [173u8, 224u8, 162u8, 2u8];
5834            #[inline]
5835            fn new<'a>(
5836                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5837            ) -> Self {
5838                tuple.into()
5839            }
5840            #[inline]
5841            fn tokenize(&self) -> Self::Token<'_> {
5842                ()
5843            }
5844            #[inline]
5845            fn abi_decode_returns(
5846                data: &[u8],
5847                validate: bool,
5848            ) -> alloy_sol_types::Result<Self::Return> {
5849                <Self::ReturnTuple<
5850                    '_,
5851                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5852                    .map(Into::into)
5853            }
5854        }
5855    };
5856    /**Function with signature `getFreeBalance()` and selector `0xe93c4f15`.
5857```solidity
5858function getFreeBalance() external view returns (uint256);
5859```*/
5860    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5861    #[derive(Clone)]
5862    pub struct getFreeBalanceCall {}
5863    ///Container type for the return parameters of the [`getFreeBalance()`](getFreeBalanceCall) function.
5864    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5865    #[derive(Clone)]
5866    pub struct getFreeBalanceReturn {
5867        #[allow(missing_docs)]
5868        pub _0: alloy::sol_types::private::primitives::aliases::U256,
5869    }
5870    #[allow(
5871        non_camel_case_types,
5872        non_snake_case,
5873        clippy::pub_underscore_fields,
5874        clippy::style
5875    )]
5876    const _: () = {
5877        use alloy::sol_types as alloy_sol_types;
5878        {
5879            #[doc(hidden)]
5880            type UnderlyingSolTuple<'a> = ();
5881            #[doc(hidden)]
5882            type UnderlyingRustTuple<'a> = ();
5883            #[cfg(test)]
5884            #[allow(dead_code, unreachable_patterns)]
5885            fn _type_assertion(
5886                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5887            ) {
5888                match _t {
5889                    alloy_sol_types::private::AssertTypeEq::<
5890                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5891                    >(_) => {}
5892                }
5893            }
5894            #[automatically_derived]
5895            #[doc(hidden)]
5896            impl ::core::convert::From<getFreeBalanceCall> for UnderlyingRustTuple<'_> {
5897                fn from(value: getFreeBalanceCall) -> Self {
5898                    ()
5899                }
5900            }
5901            #[automatically_derived]
5902            #[doc(hidden)]
5903            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getFreeBalanceCall {
5904                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5905                    Self {}
5906                }
5907            }
5908        }
5909        {
5910            #[doc(hidden)]
5911            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5912            #[doc(hidden)]
5913            type UnderlyingRustTuple<'a> = (
5914                alloy::sol_types::private::primitives::aliases::U256,
5915            );
5916            #[cfg(test)]
5917            #[allow(dead_code, unreachable_patterns)]
5918            fn _type_assertion(
5919                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5920            ) {
5921                match _t {
5922                    alloy_sol_types::private::AssertTypeEq::<
5923                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5924                    >(_) => {}
5925                }
5926            }
5927            #[automatically_derived]
5928            #[doc(hidden)]
5929            impl ::core::convert::From<getFreeBalanceReturn>
5930            for UnderlyingRustTuple<'_> {
5931                fn from(value: getFreeBalanceReturn) -> Self {
5932                    (value._0,)
5933                }
5934            }
5935            #[automatically_derived]
5936            #[doc(hidden)]
5937            impl ::core::convert::From<UnderlyingRustTuple<'_>>
5938            for getFreeBalanceReturn {
5939                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5940                    Self { _0: tuple.0 }
5941                }
5942            }
5943        }
5944        #[automatically_derived]
5945        impl alloy_sol_types::SolCall for getFreeBalanceCall {
5946            type Parameters<'a> = ();
5947            type Token<'a> = <Self::Parameters<
5948                'a,
5949            > as alloy_sol_types::SolType>::Token<'a>;
5950            type Return = getFreeBalanceReturn;
5951            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
5952            type ReturnToken<'a> = <Self::ReturnTuple<
5953                'a,
5954            > as alloy_sol_types::SolType>::Token<'a>;
5955            const SIGNATURE: &'static str = "getFreeBalance()";
5956            const SELECTOR: [u8; 4] = [233u8, 60u8, 79u8, 21u8];
5957            #[inline]
5958            fn new<'a>(
5959                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5960            ) -> Self {
5961                tuple.into()
5962            }
5963            #[inline]
5964            fn tokenize(&self) -> Self::Token<'_> {
5965                ()
5966            }
5967            #[inline]
5968            fn abi_decode_returns(
5969                data: &[u8],
5970                validate: bool,
5971            ) -> alloy_sol_types::Result<Self::Return> {
5972                <Self::ReturnTuple<
5973                    '_,
5974                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5975                    .map(Into::into)
5976            }
5977        }
5978    };
5979    /**Function with signature `getMaxPaidEpoch()` and selector `0x378b22e4`.
5980```solidity
5981function getMaxPaidEpoch() external view returns (uint256);
5982```*/
5983    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5984    #[derive(Clone)]
5985    pub struct getMaxPaidEpochCall {}
5986    ///Container type for the return parameters of the [`getMaxPaidEpoch()`](getMaxPaidEpochCall) function.
5987    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5988    #[derive(Clone)]
5989    pub struct getMaxPaidEpochReturn {
5990        #[allow(missing_docs)]
5991        pub _0: alloy::sol_types::private::primitives::aliases::U256,
5992    }
5993    #[allow(
5994        non_camel_case_types,
5995        non_snake_case,
5996        clippy::pub_underscore_fields,
5997        clippy::style
5998    )]
5999    const _: () = {
6000        use alloy::sol_types as alloy_sol_types;
6001        {
6002            #[doc(hidden)]
6003            type UnderlyingSolTuple<'a> = ();
6004            #[doc(hidden)]
6005            type UnderlyingRustTuple<'a> = ();
6006            #[cfg(test)]
6007            #[allow(dead_code, unreachable_patterns)]
6008            fn _type_assertion(
6009                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6010            ) {
6011                match _t {
6012                    alloy_sol_types::private::AssertTypeEq::<
6013                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6014                    >(_) => {}
6015                }
6016            }
6017            #[automatically_derived]
6018            #[doc(hidden)]
6019            impl ::core::convert::From<getMaxPaidEpochCall> for UnderlyingRustTuple<'_> {
6020                fn from(value: getMaxPaidEpochCall) -> Self {
6021                    ()
6022                }
6023            }
6024            #[automatically_derived]
6025            #[doc(hidden)]
6026            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxPaidEpochCall {
6027                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6028                    Self {}
6029                }
6030            }
6031        }
6032        {
6033            #[doc(hidden)]
6034            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6035            #[doc(hidden)]
6036            type UnderlyingRustTuple<'a> = (
6037                alloy::sol_types::private::primitives::aliases::U256,
6038            );
6039            #[cfg(test)]
6040            #[allow(dead_code, unreachable_patterns)]
6041            fn _type_assertion(
6042                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6043            ) {
6044                match _t {
6045                    alloy_sol_types::private::AssertTypeEq::<
6046                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6047                    >(_) => {}
6048                }
6049            }
6050            #[automatically_derived]
6051            #[doc(hidden)]
6052            impl ::core::convert::From<getMaxPaidEpochReturn>
6053            for UnderlyingRustTuple<'_> {
6054                fn from(value: getMaxPaidEpochReturn) -> Self {
6055                    (value._0,)
6056                }
6057            }
6058            #[automatically_derived]
6059            #[doc(hidden)]
6060            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6061            for getMaxPaidEpochReturn {
6062                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6063                    Self { _0: tuple.0 }
6064                }
6065            }
6066        }
6067        #[automatically_derived]
6068        impl alloy_sol_types::SolCall for getMaxPaidEpochCall {
6069            type Parameters<'a> = ();
6070            type Token<'a> = <Self::Parameters<
6071                'a,
6072            > as alloy_sol_types::SolType>::Token<'a>;
6073            type Return = getMaxPaidEpochReturn;
6074            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6075            type ReturnToken<'a> = <Self::ReturnTuple<
6076                'a,
6077            > as alloy_sol_types::SolType>::Token<'a>;
6078            const SIGNATURE: &'static str = "getMaxPaidEpoch()";
6079            const SELECTOR: [u8; 4] = [55u8, 139u8, 34u8, 228u8];
6080            #[inline]
6081            fn new<'a>(
6082                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6083            ) -> Self {
6084                tuple.into()
6085            }
6086            #[inline]
6087            fn tokenize(&self) -> Self::Token<'_> {
6088                ()
6089            }
6090            #[inline]
6091            fn abi_decode_returns(
6092                data: &[u8],
6093                validate: bool,
6094            ) -> alloy_sol_types::Result<Self::Return> {
6095                <Self::ReturnTuple<
6096                    '_,
6097                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6098                    .map(Into::into)
6099            }
6100        }
6101    };
6102    /**Function with signature `getProtocolVersion()` and selector `0x33ce93fe`.
6103```solidity
6104function getProtocolVersion() external view returns (uint256);
6105```*/
6106    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6107    #[derive(Clone)]
6108    pub struct getProtocolVersionCall {}
6109    ///Container type for the return parameters of the [`getProtocolVersion()`](getProtocolVersionCall) function.
6110    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6111    #[derive(Clone)]
6112    pub struct getProtocolVersionReturn {
6113        #[allow(missing_docs)]
6114        pub _0: alloy::sol_types::private::primitives::aliases::U256,
6115    }
6116    #[allow(
6117        non_camel_case_types,
6118        non_snake_case,
6119        clippy::pub_underscore_fields,
6120        clippy::style
6121    )]
6122    const _: () = {
6123        use alloy::sol_types as alloy_sol_types;
6124        {
6125            #[doc(hidden)]
6126            type UnderlyingSolTuple<'a> = ();
6127            #[doc(hidden)]
6128            type UnderlyingRustTuple<'a> = ();
6129            #[cfg(test)]
6130            #[allow(dead_code, unreachable_patterns)]
6131            fn _type_assertion(
6132                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6133            ) {
6134                match _t {
6135                    alloy_sol_types::private::AssertTypeEq::<
6136                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6137                    >(_) => {}
6138                }
6139            }
6140            #[automatically_derived]
6141            #[doc(hidden)]
6142            impl ::core::convert::From<getProtocolVersionCall>
6143            for UnderlyingRustTuple<'_> {
6144                fn from(value: getProtocolVersionCall) -> Self {
6145                    ()
6146                }
6147            }
6148            #[automatically_derived]
6149            #[doc(hidden)]
6150            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6151            for getProtocolVersionCall {
6152                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6153                    Self {}
6154                }
6155            }
6156        }
6157        {
6158            #[doc(hidden)]
6159            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6160            #[doc(hidden)]
6161            type UnderlyingRustTuple<'a> = (
6162                alloy::sol_types::private::primitives::aliases::U256,
6163            );
6164            #[cfg(test)]
6165            #[allow(dead_code, unreachable_patterns)]
6166            fn _type_assertion(
6167                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6168            ) {
6169                match _t {
6170                    alloy_sol_types::private::AssertTypeEq::<
6171                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6172                    >(_) => {}
6173                }
6174            }
6175            #[automatically_derived]
6176            #[doc(hidden)]
6177            impl ::core::convert::From<getProtocolVersionReturn>
6178            for UnderlyingRustTuple<'_> {
6179                fn from(value: getProtocolVersionReturn) -> Self {
6180                    (value._0,)
6181                }
6182            }
6183            #[automatically_derived]
6184            #[doc(hidden)]
6185            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6186            for getProtocolVersionReturn {
6187                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6188                    Self { _0: tuple.0 }
6189                }
6190            }
6191        }
6192        #[automatically_derived]
6193        impl alloy_sol_types::SolCall for getProtocolVersionCall {
6194            type Parameters<'a> = ();
6195            type Token<'a> = <Self::Parameters<
6196                'a,
6197            > as alloy_sol_types::SolType>::Token<'a>;
6198            type Return = getProtocolVersionReturn;
6199            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6200            type ReturnToken<'a> = <Self::ReturnTuple<
6201                'a,
6202            > as alloy_sol_types::SolType>::Token<'a>;
6203            const SIGNATURE: &'static str = "getProtocolVersion()";
6204            const SELECTOR: [u8; 4] = [51u8, 206u8, 147u8, 254u8];
6205            #[inline]
6206            fn new<'a>(
6207                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6208            ) -> Self {
6209                tuple.into()
6210            }
6211            #[inline]
6212            fn tokenize(&self) -> Self::Token<'_> {
6213                ()
6214            }
6215            #[inline]
6216            fn abi_decode_returns(
6217                data: &[u8],
6218                validate: bool,
6219            ) -> alloy_sol_types::Result<Self::Return> {
6220                <Self::ReturnTuple<
6221                    '_,
6222                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6223                    .map(Into::into)
6224            }
6225        }
6226    };
6227    /**Function with signature `getRewardAmount(bytes32)` and selector `0x1af57b96`.
6228```solidity
6229function getRewardAmount(bytes32 onchainWorkerId) external view returns (DealRewards memory);
6230```*/
6231    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6232    #[derive(Clone)]
6233    pub struct getRewardAmountCall {
6234        #[allow(missing_docs)]
6235        pub onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
6236    }
6237    ///Container type for the return parameters of the [`getRewardAmount(bytes32)`](getRewardAmountCall) function.
6238    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6239    #[derive(Clone)]
6240    pub struct getRewardAmountReturn {
6241        #[allow(missing_docs)]
6242        pub _0: <DealRewards as alloy::sol_types::SolType>::RustType,
6243    }
6244    #[allow(
6245        non_camel_case_types,
6246        non_snake_case,
6247        clippy::pub_underscore_fields,
6248        clippy::style
6249    )]
6250    const _: () = {
6251        use alloy::sol_types as alloy_sol_types;
6252        {
6253            #[doc(hidden)]
6254            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6255            #[doc(hidden)]
6256            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
6257            #[cfg(test)]
6258            #[allow(dead_code, unreachable_patterns)]
6259            fn _type_assertion(
6260                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6261            ) {
6262                match _t {
6263                    alloy_sol_types::private::AssertTypeEq::<
6264                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6265                    >(_) => {}
6266                }
6267            }
6268            #[automatically_derived]
6269            #[doc(hidden)]
6270            impl ::core::convert::From<getRewardAmountCall> for UnderlyingRustTuple<'_> {
6271                fn from(value: getRewardAmountCall) -> Self {
6272                    (value.onchainWorkerId,)
6273                }
6274            }
6275            #[automatically_derived]
6276            #[doc(hidden)]
6277            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRewardAmountCall {
6278                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6279                    Self { onchainWorkerId: tuple.0 }
6280                }
6281            }
6282        }
6283        {
6284            #[doc(hidden)]
6285            type UnderlyingSolTuple<'a> = (DealRewards,);
6286            #[doc(hidden)]
6287            type UnderlyingRustTuple<'a> = (
6288                <DealRewards as alloy::sol_types::SolType>::RustType,
6289            );
6290            #[cfg(test)]
6291            #[allow(dead_code, unreachable_patterns)]
6292            fn _type_assertion(
6293                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6294            ) {
6295                match _t {
6296                    alloy_sol_types::private::AssertTypeEq::<
6297                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6298                    >(_) => {}
6299                }
6300            }
6301            #[automatically_derived]
6302            #[doc(hidden)]
6303            impl ::core::convert::From<getRewardAmountReturn>
6304            for UnderlyingRustTuple<'_> {
6305                fn from(value: getRewardAmountReturn) -> Self {
6306                    (value._0,)
6307                }
6308            }
6309            #[automatically_derived]
6310            #[doc(hidden)]
6311            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6312            for getRewardAmountReturn {
6313                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6314                    Self { _0: tuple.0 }
6315                }
6316            }
6317        }
6318        #[automatically_derived]
6319        impl alloy_sol_types::SolCall for getRewardAmountCall {
6320            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6321            type Token<'a> = <Self::Parameters<
6322                'a,
6323            > as alloy_sol_types::SolType>::Token<'a>;
6324            type Return = getRewardAmountReturn;
6325            type ReturnTuple<'a> = (DealRewards,);
6326            type ReturnToken<'a> = <Self::ReturnTuple<
6327                'a,
6328            > as alloy_sol_types::SolType>::Token<'a>;
6329            const SIGNATURE: &'static str = "getRewardAmount(bytes32)";
6330            const SELECTOR: [u8; 4] = [26u8, 245u8, 123u8, 150u8];
6331            #[inline]
6332            fn new<'a>(
6333                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6334            ) -> Self {
6335                tuple.into()
6336            }
6337            #[inline]
6338            fn tokenize(&self) -> Self::Token<'_> {
6339                (
6340                    <alloy::sol_types::sol_data::FixedBytes<
6341                        32,
6342                    > as alloy_sol_types::SolType>::tokenize(&self.onchainWorkerId),
6343                )
6344            }
6345            #[inline]
6346            fn abi_decode_returns(
6347                data: &[u8],
6348                validate: bool,
6349            ) -> alloy_sol_types::Result<Self::Return> {
6350                <Self::ReturnTuple<
6351                    '_,
6352                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6353                    .map(Into::into)
6354            }
6355        }
6356    };
6357    /**Function with signature `getStatus()` and selector `0x4e69d560`.
6358```solidity
6359function getStatus() external view returns (Status);
6360```*/
6361    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6362    #[derive(Clone)]
6363    pub struct getStatusCall {}
6364    ///Container type for the return parameters of the [`getStatus()`](getStatusCall) function.
6365    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6366    #[derive(Clone)]
6367    pub struct getStatusReturn {
6368        #[allow(missing_docs)]
6369        pub _0: <Status as alloy::sol_types::SolType>::RustType,
6370    }
6371    #[allow(
6372        non_camel_case_types,
6373        non_snake_case,
6374        clippy::pub_underscore_fields,
6375        clippy::style
6376    )]
6377    const _: () = {
6378        use alloy::sol_types as alloy_sol_types;
6379        {
6380            #[doc(hidden)]
6381            type UnderlyingSolTuple<'a> = ();
6382            #[doc(hidden)]
6383            type UnderlyingRustTuple<'a> = ();
6384            #[cfg(test)]
6385            #[allow(dead_code, unreachable_patterns)]
6386            fn _type_assertion(
6387                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6388            ) {
6389                match _t {
6390                    alloy_sol_types::private::AssertTypeEq::<
6391                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6392                    >(_) => {}
6393                }
6394            }
6395            #[automatically_derived]
6396            #[doc(hidden)]
6397            impl ::core::convert::From<getStatusCall> for UnderlyingRustTuple<'_> {
6398                fn from(value: getStatusCall) -> Self {
6399                    ()
6400                }
6401            }
6402            #[automatically_derived]
6403            #[doc(hidden)]
6404            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStatusCall {
6405                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6406                    Self {}
6407                }
6408            }
6409        }
6410        {
6411            #[doc(hidden)]
6412            type UnderlyingSolTuple<'a> = (Status,);
6413            #[doc(hidden)]
6414            type UnderlyingRustTuple<'a> = (
6415                <Status as alloy::sol_types::SolType>::RustType,
6416            );
6417            #[cfg(test)]
6418            #[allow(dead_code, unreachable_patterns)]
6419            fn _type_assertion(
6420                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6421            ) {
6422                match _t {
6423                    alloy_sol_types::private::AssertTypeEq::<
6424                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6425                    >(_) => {}
6426                }
6427            }
6428            #[automatically_derived]
6429            #[doc(hidden)]
6430            impl ::core::convert::From<getStatusReturn> for UnderlyingRustTuple<'_> {
6431                fn from(value: getStatusReturn) -> Self {
6432                    (value._0,)
6433                }
6434            }
6435            #[automatically_derived]
6436            #[doc(hidden)]
6437            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStatusReturn {
6438                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6439                    Self { _0: tuple.0 }
6440                }
6441            }
6442        }
6443        #[automatically_derived]
6444        impl alloy_sol_types::SolCall for getStatusCall {
6445            type Parameters<'a> = ();
6446            type Token<'a> = <Self::Parameters<
6447                'a,
6448            > as alloy_sol_types::SolType>::Token<'a>;
6449            type Return = getStatusReturn;
6450            type ReturnTuple<'a> = (Status,);
6451            type ReturnToken<'a> = <Self::ReturnTuple<
6452                'a,
6453            > as alloy_sol_types::SolType>::Token<'a>;
6454            const SIGNATURE: &'static str = "getStatus()";
6455            const SELECTOR: [u8; 4] = [78u8, 105u8, 213u8, 96u8];
6456            #[inline]
6457            fn new<'a>(
6458                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6459            ) -> Self {
6460                tuple.into()
6461            }
6462            #[inline]
6463            fn tokenize(&self) -> Self::Token<'_> {
6464                ()
6465            }
6466            #[inline]
6467            fn abi_decode_returns(
6468                data: &[u8],
6469                validate: bool,
6470            ) -> alloy_sol_types::Result<Self::Return> {
6471                <Self::ReturnTuple<
6472                    '_,
6473                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6474                    .map(Into::into)
6475            }
6476        }
6477    };
6478    /**Function with signature `getWorkerCount()` and selector `0x4d7599f1`.
6479```solidity
6480function getWorkerCount() external view returns (uint256);
6481```*/
6482    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6483    #[derive(Clone)]
6484    pub struct getWorkerCount_0Call {}
6485    ///Container type for the return parameters of the [`getWorkerCount()`](getWorkerCount_0Call) function.
6486    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6487    #[derive(Clone)]
6488    pub struct getWorkerCount_0Return {
6489        #[allow(missing_docs)]
6490        pub _0: alloy::sol_types::private::primitives::aliases::U256,
6491    }
6492    #[allow(
6493        non_camel_case_types,
6494        non_snake_case,
6495        clippy::pub_underscore_fields,
6496        clippy::style
6497    )]
6498    const _: () = {
6499        use alloy::sol_types as alloy_sol_types;
6500        {
6501            #[doc(hidden)]
6502            type UnderlyingSolTuple<'a> = ();
6503            #[doc(hidden)]
6504            type UnderlyingRustTuple<'a> = ();
6505            #[cfg(test)]
6506            #[allow(dead_code, unreachable_patterns)]
6507            fn _type_assertion(
6508                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6509            ) {
6510                match _t {
6511                    alloy_sol_types::private::AssertTypeEq::<
6512                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6513                    >(_) => {}
6514                }
6515            }
6516            #[automatically_derived]
6517            #[doc(hidden)]
6518            impl ::core::convert::From<getWorkerCount_0Call>
6519            for UnderlyingRustTuple<'_> {
6520                fn from(value: getWorkerCount_0Call) -> Self {
6521                    ()
6522                }
6523            }
6524            #[automatically_derived]
6525            #[doc(hidden)]
6526            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6527            for getWorkerCount_0Call {
6528                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6529                    Self {}
6530                }
6531            }
6532        }
6533        {
6534            #[doc(hidden)]
6535            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6536            #[doc(hidden)]
6537            type UnderlyingRustTuple<'a> = (
6538                alloy::sol_types::private::primitives::aliases::U256,
6539            );
6540            #[cfg(test)]
6541            #[allow(dead_code, unreachable_patterns)]
6542            fn _type_assertion(
6543                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6544            ) {
6545                match _t {
6546                    alloy_sol_types::private::AssertTypeEq::<
6547                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6548                    >(_) => {}
6549                }
6550            }
6551            #[automatically_derived]
6552            #[doc(hidden)]
6553            impl ::core::convert::From<getWorkerCount_0Return>
6554            for UnderlyingRustTuple<'_> {
6555                fn from(value: getWorkerCount_0Return) -> Self {
6556                    (value._0,)
6557                }
6558            }
6559            #[automatically_derived]
6560            #[doc(hidden)]
6561            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6562            for getWorkerCount_0Return {
6563                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6564                    Self { _0: tuple.0 }
6565                }
6566            }
6567        }
6568        #[automatically_derived]
6569        impl alloy_sol_types::SolCall for getWorkerCount_0Call {
6570            type Parameters<'a> = ();
6571            type Token<'a> = <Self::Parameters<
6572                'a,
6573            > as alloy_sol_types::SolType>::Token<'a>;
6574            type Return = getWorkerCount_0Return;
6575            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6576            type ReturnToken<'a> = <Self::ReturnTuple<
6577                'a,
6578            > as alloy_sol_types::SolType>::Token<'a>;
6579            const SIGNATURE: &'static str = "getWorkerCount()";
6580            const SELECTOR: [u8; 4] = [77u8, 117u8, 153u8, 241u8];
6581            #[inline]
6582            fn new<'a>(
6583                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6584            ) -> Self {
6585                tuple.into()
6586            }
6587            #[inline]
6588            fn tokenize(&self) -> Self::Token<'_> {
6589                ()
6590            }
6591            #[inline]
6592            fn abi_decode_returns(
6593                data: &[u8],
6594                validate: bool,
6595            ) -> alloy_sol_types::Result<Self::Return> {
6596                <Self::ReturnTuple<
6597                    '_,
6598                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6599                    .map(Into::into)
6600            }
6601        }
6602    };
6603    /**Function with signature `getWorkerCount(address)` and selector `0x59c4afc0`.
6604```solidity
6605function getWorkerCount(address provider) external view returns (uint256);
6606```*/
6607    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6608    #[derive(Clone)]
6609    pub struct getWorkerCount_1Call {
6610        #[allow(missing_docs)]
6611        pub provider: alloy::sol_types::private::Address,
6612    }
6613    ///Container type for the return parameters of the [`getWorkerCount(address)`](getWorkerCount_1Call) function.
6614    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6615    #[derive(Clone)]
6616    pub struct getWorkerCount_1Return {
6617        #[allow(missing_docs)]
6618        pub _0: alloy::sol_types::private::primitives::aliases::U256,
6619    }
6620    #[allow(
6621        non_camel_case_types,
6622        non_snake_case,
6623        clippy::pub_underscore_fields,
6624        clippy::style
6625    )]
6626    const _: () = {
6627        use alloy::sol_types as alloy_sol_types;
6628        {
6629            #[doc(hidden)]
6630            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6631            #[doc(hidden)]
6632            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6633            #[cfg(test)]
6634            #[allow(dead_code, unreachable_patterns)]
6635            fn _type_assertion(
6636                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6637            ) {
6638                match _t {
6639                    alloy_sol_types::private::AssertTypeEq::<
6640                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6641                    >(_) => {}
6642                }
6643            }
6644            #[automatically_derived]
6645            #[doc(hidden)]
6646            impl ::core::convert::From<getWorkerCount_1Call>
6647            for UnderlyingRustTuple<'_> {
6648                fn from(value: getWorkerCount_1Call) -> Self {
6649                    (value.provider,)
6650                }
6651            }
6652            #[automatically_derived]
6653            #[doc(hidden)]
6654            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6655            for getWorkerCount_1Call {
6656                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6657                    Self { provider: tuple.0 }
6658                }
6659            }
6660        }
6661        {
6662            #[doc(hidden)]
6663            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6664            #[doc(hidden)]
6665            type UnderlyingRustTuple<'a> = (
6666                alloy::sol_types::private::primitives::aliases::U256,
6667            );
6668            #[cfg(test)]
6669            #[allow(dead_code, unreachable_patterns)]
6670            fn _type_assertion(
6671                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6672            ) {
6673                match _t {
6674                    alloy_sol_types::private::AssertTypeEq::<
6675                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6676                    >(_) => {}
6677                }
6678            }
6679            #[automatically_derived]
6680            #[doc(hidden)]
6681            impl ::core::convert::From<getWorkerCount_1Return>
6682            for UnderlyingRustTuple<'_> {
6683                fn from(value: getWorkerCount_1Return) -> Self {
6684                    (value._0,)
6685                }
6686            }
6687            #[automatically_derived]
6688            #[doc(hidden)]
6689            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6690            for getWorkerCount_1Return {
6691                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6692                    Self { _0: tuple.0 }
6693                }
6694            }
6695        }
6696        #[automatically_derived]
6697        impl alloy_sol_types::SolCall for getWorkerCount_1Call {
6698            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
6699            type Token<'a> = <Self::Parameters<
6700                'a,
6701            > as alloy_sol_types::SolType>::Token<'a>;
6702            type Return = getWorkerCount_1Return;
6703            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
6704            type ReturnToken<'a> = <Self::ReturnTuple<
6705                'a,
6706            > as alloy_sol_types::SolType>::Token<'a>;
6707            const SIGNATURE: &'static str = "getWorkerCount(address)";
6708            const SELECTOR: [u8; 4] = [89u8, 196u8, 175u8, 192u8];
6709            #[inline]
6710            fn new<'a>(
6711                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6712            ) -> Self {
6713                tuple.into()
6714            }
6715            #[inline]
6716            fn tokenize(&self) -> Self::Token<'_> {
6717                (
6718                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6719                        &self.provider,
6720                    ),
6721                )
6722            }
6723            #[inline]
6724            fn abi_decode_returns(
6725                data: &[u8],
6726                validate: bool,
6727            ) -> alloy_sol_types::Result<Self::Return> {
6728                <Self::ReturnTuple<
6729                    '_,
6730                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6731                    .map(Into::into)
6732            }
6733        }
6734    };
6735    /**Function with signature `getWorkerIds()` and selector `0xf2574c1b`.
6736```solidity
6737function getWorkerIds() external view returns (bytes32[] memory);
6738```*/
6739    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6740    #[derive(Clone)]
6741    pub struct getWorkerIdsCall {}
6742    ///Container type for the return parameters of the [`getWorkerIds()`](getWorkerIdsCall) function.
6743    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6744    #[derive(Clone)]
6745    pub struct getWorkerIdsReturn {
6746        #[allow(missing_docs)]
6747        pub _0: alloy::sol_types::private::Vec<
6748            alloy::sol_types::private::FixedBytes<32>,
6749        >,
6750    }
6751    #[allow(
6752        non_camel_case_types,
6753        non_snake_case,
6754        clippy::pub_underscore_fields,
6755        clippy::style
6756    )]
6757    const _: () = {
6758        use alloy::sol_types as alloy_sol_types;
6759        {
6760            #[doc(hidden)]
6761            type UnderlyingSolTuple<'a> = ();
6762            #[doc(hidden)]
6763            type UnderlyingRustTuple<'a> = ();
6764            #[cfg(test)]
6765            #[allow(dead_code, unreachable_patterns)]
6766            fn _type_assertion(
6767                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6768            ) {
6769                match _t {
6770                    alloy_sol_types::private::AssertTypeEq::<
6771                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6772                    >(_) => {}
6773                }
6774            }
6775            #[automatically_derived]
6776            #[doc(hidden)]
6777            impl ::core::convert::From<getWorkerIdsCall> for UnderlyingRustTuple<'_> {
6778                fn from(value: getWorkerIdsCall) -> Self {
6779                    ()
6780                }
6781            }
6782            #[automatically_derived]
6783            #[doc(hidden)]
6784            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getWorkerIdsCall {
6785                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6786                    Self {}
6787                }
6788            }
6789        }
6790        {
6791            #[doc(hidden)]
6792            type UnderlyingSolTuple<'a> = (
6793                alloy::sol_types::sol_data::Array<
6794                    alloy::sol_types::sol_data::FixedBytes<32>,
6795                >,
6796            );
6797            #[doc(hidden)]
6798            type UnderlyingRustTuple<'a> = (
6799                alloy::sol_types::private::Vec<
6800                    alloy::sol_types::private::FixedBytes<32>,
6801                >,
6802            );
6803            #[cfg(test)]
6804            #[allow(dead_code, unreachable_patterns)]
6805            fn _type_assertion(
6806                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6807            ) {
6808                match _t {
6809                    alloy_sol_types::private::AssertTypeEq::<
6810                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6811                    >(_) => {}
6812                }
6813            }
6814            #[automatically_derived]
6815            #[doc(hidden)]
6816            impl ::core::convert::From<getWorkerIdsReturn> for UnderlyingRustTuple<'_> {
6817                fn from(value: getWorkerIdsReturn) -> Self {
6818                    (value._0,)
6819                }
6820            }
6821            #[automatically_derived]
6822            #[doc(hidden)]
6823            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getWorkerIdsReturn {
6824                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6825                    Self { _0: tuple.0 }
6826                }
6827            }
6828        }
6829        #[automatically_derived]
6830        impl alloy_sol_types::SolCall for getWorkerIdsCall {
6831            type Parameters<'a> = ();
6832            type Token<'a> = <Self::Parameters<
6833                'a,
6834            > as alloy_sol_types::SolType>::Token<'a>;
6835            type Return = getWorkerIdsReturn;
6836            type ReturnTuple<'a> = (
6837                alloy::sol_types::sol_data::Array<
6838                    alloy::sol_types::sol_data::FixedBytes<32>,
6839                >,
6840            );
6841            type ReturnToken<'a> = <Self::ReturnTuple<
6842                'a,
6843            > as alloy_sol_types::SolType>::Token<'a>;
6844            const SIGNATURE: &'static str = "getWorkerIds()";
6845            const SELECTOR: [u8; 4] = [242u8, 87u8, 76u8, 27u8];
6846            #[inline]
6847            fn new<'a>(
6848                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6849            ) -> Self {
6850                tuple.into()
6851            }
6852            #[inline]
6853            fn tokenize(&self) -> Self::Token<'_> {
6854                ()
6855            }
6856            #[inline]
6857            fn abi_decode_returns(
6858                data: &[u8],
6859                validate: bool,
6860            ) -> alloy_sol_types::Result<Self::Return> {
6861                <Self::ReturnTuple<
6862                    '_,
6863                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6864                    .map(Into::into)
6865            }
6866        }
6867    };
6868    /**Function with signature `initialize(address,(bytes4,bytes32),address,uint256,(bytes32,uint8,uint256)[],uint256,uint256,uint8,address[],uint256,address)` and selector `0x84608454`.
6869```solidity
6870function initialize(address diamond_, Common.CIDV1 memory appCID_, address paymentToken_, uint256 targetWorkers_, IOfferV2.ResourceRequirement[] memory resources_, uint256 pricePerEpoch_, uint256 maxWorkersPerProvider_, IConfigV2.AccessTypeV2 providersAccessType_, address[] memory providersAccessList_, uint256 protocolVersion_, address owner_) external;
6871```*/
6872    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6873    #[derive(Clone)]
6874    pub struct initializeCall {
6875        #[allow(missing_docs)]
6876        pub diamond_: alloy::sol_types::private::Address,
6877        #[allow(missing_docs)]
6878        pub appCID_: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
6879        #[allow(missing_docs)]
6880        pub paymentToken_: alloy::sol_types::private::Address,
6881        #[allow(missing_docs)]
6882        pub targetWorkers_: alloy::sol_types::private::primitives::aliases::U256,
6883        #[allow(missing_docs)]
6884        pub resources_: alloy::sol_types::private::Vec<
6885            <IOfferV2::ResourceRequirement as alloy::sol_types::SolType>::RustType,
6886        >,
6887        #[allow(missing_docs)]
6888        pub pricePerEpoch_: alloy::sol_types::private::primitives::aliases::U256,
6889        #[allow(missing_docs)]
6890        pub maxWorkersPerProvider_: alloy::sol_types::private::primitives::aliases::U256,
6891        #[allow(missing_docs)]
6892        pub providersAccessType_: <IConfigV2::AccessTypeV2 as alloy::sol_types::SolType>::RustType,
6893        #[allow(missing_docs)]
6894        pub providersAccessList_: alloy::sol_types::private::Vec<
6895            alloy::sol_types::private::Address,
6896        >,
6897        #[allow(missing_docs)]
6898        pub protocolVersion_: alloy::sol_types::private::primitives::aliases::U256,
6899        #[allow(missing_docs)]
6900        pub owner_: alloy::sol_types::private::Address,
6901    }
6902    ///Container type for the return parameters of the [`initialize(address,(bytes4,bytes32),address,uint256,(bytes32,uint8,uint256)[],uint256,uint256,uint8,address[],uint256,address)`](initializeCall) function.
6903    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6904    #[derive(Clone)]
6905    pub struct initializeReturn {}
6906    #[allow(
6907        non_camel_case_types,
6908        non_snake_case,
6909        clippy::pub_underscore_fields,
6910        clippy::style
6911    )]
6912    const _: () = {
6913        use alloy::sol_types as alloy_sol_types;
6914        {
6915            #[doc(hidden)]
6916            type UnderlyingSolTuple<'a> = (
6917                alloy::sol_types::sol_data::Address,
6918                Common::CIDV1,
6919                alloy::sol_types::sol_data::Address,
6920                alloy::sol_types::sol_data::Uint<256>,
6921                alloy::sol_types::sol_data::Array<IOfferV2::ResourceRequirement>,
6922                alloy::sol_types::sol_data::Uint<256>,
6923                alloy::sol_types::sol_data::Uint<256>,
6924                IConfigV2::AccessTypeV2,
6925                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6926                alloy::sol_types::sol_data::Uint<256>,
6927                alloy::sol_types::sol_data::Address,
6928            );
6929            #[doc(hidden)]
6930            type UnderlyingRustTuple<'a> = (
6931                alloy::sol_types::private::Address,
6932                <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
6933                alloy::sol_types::private::Address,
6934                alloy::sol_types::private::primitives::aliases::U256,
6935                alloy::sol_types::private::Vec<
6936                    <IOfferV2::ResourceRequirement as alloy::sol_types::SolType>::RustType,
6937                >,
6938                alloy::sol_types::private::primitives::aliases::U256,
6939                alloy::sol_types::private::primitives::aliases::U256,
6940                <IConfigV2::AccessTypeV2 as alloy::sol_types::SolType>::RustType,
6941                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
6942                alloy::sol_types::private::primitives::aliases::U256,
6943                alloy::sol_types::private::Address,
6944            );
6945            #[cfg(test)]
6946            #[allow(dead_code, unreachable_patterns)]
6947            fn _type_assertion(
6948                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6949            ) {
6950                match _t {
6951                    alloy_sol_types::private::AssertTypeEq::<
6952                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6953                    >(_) => {}
6954                }
6955            }
6956            #[automatically_derived]
6957            #[doc(hidden)]
6958            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
6959                fn from(value: initializeCall) -> Self {
6960                    (
6961                        value.diamond_,
6962                        value.appCID_,
6963                        value.paymentToken_,
6964                        value.targetWorkers_,
6965                        value.resources_,
6966                        value.pricePerEpoch_,
6967                        value.maxWorkersPerProvider_,
6968                        value.providersAccessType_,
6969                        value.providersAccessList_,
6970                        value.protocolVersion_,
6971                        value.owner_,
6972                    )
6973                }
6974            }
6975            #[automatically_derived]
6976            #[doc(hidden)]
6977            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
6978                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6979                    Self {
6980                        diamond_: tuple.0,
6981                        appCID_: tuple.1,
6982                        paymentToken_: tuple.2,
6983                        targetWorkers_: tuple.3,
6984                        resources_: tuple.4,
6985                        pricePerEpoch_: tuple.5,
6986                        maxWorkersPerProvider_: tuple.6,
6987                        providersAccessType_: tuple.7,
6988                        providersAccessList_: tuple.8,
6989                        protocolVersion_: tuple.9,
6990                        owner_: tuple.10,
6991                    }
6992                }
6993            }
6994        }
6995        {
6996            #[doc(hidden)]
6997            type UnderlyingSolTuple<'a> = ();
6998            #[doc(hidden)]
6999            type UnderlyingRustTuple<'a> = ();
7000            #[cfg(test)]
7001            #[allow(dead_code, unreachable_patterns)]
7002            fn _type_assertion(
7003                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7004            ) {
7005                match _t {
7006                    alloy_sol_types::private::AssertTypeEq::<
7007                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7008                    >(_) => {}
7009                }
7010            }
7011            #[automatically_derived]
7012            #[doc(hidden)]
7013            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
7014                fn from(value: initializeReturn) -> Self {
7015                    ()
7016                }
7017            }
7018            #[automatically_derived]
7019            #[doc(hidden)]
7020            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
7021                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7022                    Self {}
7023                }
7024            }
7025        }
7026        #[automatically_derived]
7027        impl alloy_sol_types::SolCall for initializeCall {
7028            type Parameters<'a> = (
7029                alloy::sol_types::sol_data::Address,
7030                Common::CIDV1,
7031                alloy::sol_types::sol_data::Address,
7032                alloy::sol_types::sol_data::Uint<256>,
7033                alloy::sol_types::sol_data::Array<IOfferV2::ResourceRequirement>,
7034                alloy::sol_types::sol_data::Uint<256>,
7035                alloy::sol_types::sol_data::Uint<256>,
7036                IConfigV2::AccessTypeV2,
7037                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7038                alloy::sol_types::sol_data::Uint<256>,
7039                alloy::sol_types::sol_data::Address,
7040            );
7041            type Token<'a> = <Self::Parameters<
7042                'a,
7043            > as alloy_sol_types::SolType>::Token<'a>;
7044            type Return = initializeReturn;
7045            type ReturnTuple<'a> = ();
7046            type ReturnToken<'a> = <Self::ReturnTuple<
7047                'a,
7048            > as alloy_sol_types::SolType>::Token<'a>;
7049            const SIGNATURE: &'static str = "initialize(address,(bytes4,bytes32),address,uint256,(bytes32,uint8,uint256)[],uint256,uint256,uint8,address[],uint256,address)";
7050            const SELECTOR: [u8; 4] = [132u8, 96u8, 132u8, 84u8];
7051            #[inline]
7052            fn new<'a>(
7053                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7054            ) -> Self {
7055                tuple.into()
7056            }
7057            #[inline]
7058            fn tokenize(&self) -> Self::Token<'_> {
7059                (
7060                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7061                        &self.diamond_,
7062                    ),
7063                    <Common::CIDV1 as alloy_sol_types::SolType>::tokenize(&self.appCID_),
7064                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7065                        &self.paymentToken_,
7066                    ),
7067                    <alloy::sol_types::sol_data::Uint<
7068                        256,
7069                    > as alloy_sol_types::SolType>::tokenize(&self.targetWorkers_),
7070                    <alloy::sol_types::sol_data::Array<
7071                        IOfferV2::ResourceRequirement,
7072                    > as alloy_sol_types::SolType>::tokenize(&self.resources_),
7073                    <alloy::sol_types::sol_data::Uint<
7074                        256,
7075                    > as alloy_sol_types::SolType>::tokenize(&self.pricePerEpoch_),
7076                    <alloy::sol_types::sol_data::Uint<
7077                        256,
7078                    > as alloy_sol_types::SolType>::tokenize(
7079                        &self.maxWorkersPerProvider_,
7080                    ),
7081                    <IConfigV2::AccessTypeV2 as alloy_sol_types::SolType>::tokenize(
7082                        &self.providersAccessType_,
7083                    ),
7084                    <alloy::sol_types::sol_data::Array<
7085                        alloy::sol_types::sol_data::Address,
7086                    > as alloy_sol_types::SolType>::tokenize(&self.providersAccessList_),
7087                    <alloy::sol_types::sol_data::Uint<
7088                        256,
7089                    > as alloy_sol_types::SolType>::tokenize(&self.protocolVersion_),
7090                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7091                        &self.owner_,
7092                    ),
7093                )
7094            }
7095            #[inline]
7096            fn abi_decode_returns(
7097                data: &[u8],
7098                validate: bool,
7099            ) -> alloy_sol_types::Result<Self::Return> {
7100                <Self::ReturnTuple<
7101                    '_,
7102                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7103                    .map(Into::into)
7104            }
7105        }
7106    };
7107    /**Function with signature `isProviderAllowed(address)` and selector `0x3e8ae1ae`.
7108```solidity
7109function isProviderAllowed(address account) external view returns (bool);
7110```*/
7111    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7112    #[derive(Clone)]
7113    pub struct isProviderAllowedCall {
7114        #[allow(missing_docs)]
7115        pub account: alloy::sol_types::private::Address,
7116    }
7117    ///Container type for the return parameters of the [`isProviderAllowed(address)`](isProviderAllowedCall) function.
7118    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7119    #[derive(Clone)]
7120    pub struct isProviderAllowedReturn {
7121        #[allow(missing_docs)]
7122        pub _0: bool,
7123    }
7124    #[allow(
7125        non_camel_case_types,
7126        non_snake_case,
7127        clippy::pub_underscore_fields,
7128        clippy::style
7129    )]
7130    const _: () = {
7131        use alloy::sol_types as alloy_sol_types;
7132        {
7133            #[doc(hidden)]
7134            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7135            #[doc(hidden)]
7136            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7137            #[cfg(test)]
7138            #[allow(dead_code, unreachable_patterns)]
7139            fn _type_assertion(
7140                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7141            ) {
7142                match _t {
7143                    alloy_sol_types::private::AssertTypeEq::<
7144                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7145                    >(_) => {}
7146                }
7147            }
7148            #[automatically_derived]
7149            #[doc(hidden)]
7150            impl ::core::convert::From<isProviderAllowedCall>
7151            for UnderlyingRustTuple<'_> {
7152                fn from(value: isProviderAllowedCall) -> Self {
7153                    (value.account,)
7154                }
7155            }
7156            #[automatically_derived]
7157            #[doc(hidden)]
7158            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7159            for isProviderAllowedCall {
7160                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7161                    Self { account: tuple.0 }
7162                }
7163            }
7164        }
7165        {
7166            #[doc(hidden)]
7167            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
7168            #[doc(hidden)]
7169            type UnderlyingRustTuple<'a> = (bool,);
7170            #[cfg(test)]
7171            #[allow(dead_code, unreachable_patterns)]
7172            fn _type_assertion(
7173                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7174            ) {
7175                match _t {
7176                    alloy_sol_types::private::AssertTypeEq::<
7177                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7178                    >(_) => {}
7179                }
7180            }
7181            #[automatically_derived]
7182            #[doc(hidden)]
7183            impl ::core::convert::From<isProviderAllowedReturn>
7184            for UnderlyingRustTuple<'_> {
7185                fn from(value: isProviderAllowedReturn) -> Self {
7186                    (value._0,)
7187                }
7188            }
7189            #[automatically_derived]
7190            #[doc(hidden)]
7191            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7192            for isProviderAllowedReturn {
7193                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7194                    Self { _0: tuple.0 }
7195                }
7196            }
7197        }
7198        #[automatically_derived]
7199        impl alloy_sol_types::SolCall for isProviderAllowedCall {
7200            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
7201            type Token<'a> = <Self::Parameters<
7202                'a,
7203            > as alloy_sol_types::SolType>::Token<'a>;
7204            type Return = isProviderAllowedReturn;
7205            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
7206            type ReturnToken<'a> = <Self::ReturnTuple<
7207                'a,
7208            > as alloy_sol_types::SolType>::Token<'a>;
7209            const SIGNATURE: &'static str = "isProviderAllowed(address)";
7210            const SELECTOR: [u8; 4] = [62u8, 138u8, 225u8, 174u8];
7211            #[inline]
7212            fn new<'a>(
7213                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7214            ) -> Self {
7215                tuple.into()
7216            }
7217            #[inline]
7218            fn tokenize(&self) -> Self::Token<'_> {
7219                (
7220                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7221                        &self.account,
7222                    ),
7223                )
7224            }
7225            #[inline]
7226            fn abi_decode_returns(
7227                data: &[u8],
7228                validate: bool,
7229            ) -> alloy_sol_types::Result<Self::Return> {
7230                <Self::ReturnTuple<
7231                    '_,
7232                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7233                    .map(Into::into)
7234            }
7235        }
7236    };
7237    /**Function with signature `maxWorkersPerProvider()` and selector `0x8a0c725b`.
7238```solidity
7239function maxWorkersPerProvider() external view returns (uint256);
7240```*/
7241    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7242    #[derive(Clone)]
7243    pub struct maxWorkersPerProviderCall {}
7244    ///Container type for the return parameters of the [`maxWorkersPerProvider()`](maxWorkersPerProviderCall) function.
7245    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7246    #[derive(Clone)]
7247    pub struct maxWorkersPerProviderReturn {
7248        #[allow(missing_docs)]
7249        pub _0: alloy::sol_types::private::primitives::aliases::U256,
7250    }
7251    #[allow(
7252        non_camel_case_types,
7253        non_snake_case,
7254        clippy::pub_underscore_fields,
7255        clippy::style
7256    )]
7257    const _: () = {
7258        use alloy::sol_types as alloy_sol_types;
7259        {
7260            #[doc(hidden)]
7261            type UnderlyingSolTuple<'a> = ();
7262            #[doc(hidden)]
7263            type UnderlyingRustTuple<'a> = ();
7264            #[cfg(test)]
7265            #[allow(dead_code, unreachable_patterns)]
7266            fn _type_assertion(
7267                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7268            ) {
7269                match _t {
7270                    alloy_sol_types::private::AssertTypeEq::<
7271                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7272                    >(_) => {}
7273                }
7274            }
7275            #[automatically_derived]
7276            #[doc(hidden)]
7277            impl ::core::convert::From<maxWorkersPerProviderCall>
7278            for UnderlyingRustTuple<'_> {
7279                fn from(value: maxWorkersPerProviderCall) -> Self {
7280                    ()
7281                }
7282            }
7283            #[automatically_derived]
7284            #[doc(hidden)]
7285            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7286            for maxWorkersPerProviderCall {
7287                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7288                    Self {}
7289                }
7290            }
7291        }
7292        {
7293            #[doc(hidden)]
7294            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7295            #[doc(hidden)]
7296            type UnderlyingRustTuple<'a> = (
7297                alloy::sol_types::private::primitives::aliases::U256,
7298            );
7299            #[cfg(test)]
7300            #[allow(dead_code, unreachable_patterns)]
7301            fn _type_assertion(
7302                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7303            ) {
7304                match _t {
7305                    alloy_sol_types::private::AssertTypeEq::<
7306                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7307                    >(_) => {}
7308                }
7309            }
7310            #[automatically_derived]
7311            #[doc(hidden)]
7312            impl ::core::convert::From<maxWorkersPerProviderReturn>
7313            for UnderlyingRustTuple<'_> {
7314                fn from(value: maxWorkersPerProviderReturn) -> Self {
7315                    (value._0,)
7316                }
7317            }
7318            #[automatically_derived]
7319            #[doc(hidden)]
7320            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7321            for maxWorkersPerProviderReturn {
7322                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7323                    Self { _0: tuple.0 }
7324                }
7325            }
7326        }
7327        #[automatically_derived]
7328        impl alloy_sol_types::SolCall for maxWorkersPerProviderCall {
7329            type Parameters<'a> = ();
7330            type Token<'a> = <Self::Parameters<
7331                'a,
7332            > as alloy_sol_types::SolType>::Token<'a>;
7333            type Return = maxWorkersPerProviderReturn;
7334            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7335            type ReturnToken<'a> = <Self::ReturnTuple<
7336                'a,
7337            > as alloy_sol_types::SolType>::Token<'a>;
7338            const SIGNATURE: &'static str = "maxWorkersPerProvider()";
7339            const SELECTOR: [u8; 4] = [138u8, 12u8, 114u8, 91u8];
7340            #[inline]
7341            fn new<'a>(
7342                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7343            ) -> Self {
7344                tuple.into()
7345            }
7346            #[inline]
7347            fn tokenize(&self) -> Self::Token<'_> {
7348                ()
7349            }
7350            #[inline]
7351            fn abi_decode_returns(
7352                data: &[u8],
7353                validate: bool,
7354            ) -> alloy_sol_types::Result<Self::Return> {
7355                <Self::ReturnTuple<
7356                    '_,
7357                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7358                    .map(Into::into)
7359            }
7360        }
7361    };
7362    /**Function with signature `paymentToken()` and selector `0x3013ce29`.
7363```solidity
7364function paymentToken() external view returns (address);
7365```*/
7366    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7367    #[derive(Clone)]
7368    pub struct paymentTokenCall {}
7369    ///Container type for the return parameters of the [`paymentToken()`](paymentTokenCall) function.
7370    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7371    #[derive(Clone)]
7372    pub struct paymentTokenReturn {
7373        #[allow(missing_docs)]
7374        pub _0: alloy::sol_types::private::Address,
7375    }
7376    #[allow(
7377        non_camel_case_types,
7378        non_snake_case,
7379        clippy::pub_underscore_fields,
7380        clippy::style
7381    )]
7382    const _: () = {
7383        use alloy::sol_types as alloy_sol_types;
7384        {
7385            #[doc(hidden)]
7386            type UnderlyingSolTuple<'a> = ();
7387            #[doc(hidden)]
7388            type UnderlyingRustTuple<'a> = ();
7389            #[cfg(test)]
7390            #[allow(dead_code, unreachable_patterns)]
7391            fn _type_assertion(
7392                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7393            ) {
7394                match _t {
7395                    alloy_sol_types::private::AssertTypeEq::<
7396                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7397                    >(_) => {}
7398                }
7399            }
7400            #[automatically_derived]
7401            #[doc(hidden)]
7402            impl ::core::convert::From<paymentTokenCall> for UnderlyingRustTuple<'_> {
7403                fn from(value: paymentTokenCall) -> Self {
7404                    ()
7405                }
7406            }
7407            #[automatically_derived]
7408            #[doc(hidden)]
7409            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paymentTokenCall {
7410                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7411                    Self {}
7412                }
7413            }
7414        }
7415        {
7416            #[doc(hidden)]
7417            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7418            #[doc(hidden)]
7419            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7420            #[cfg(test)]
7421            #[allow(dead_code, unreachable_patterns)]
7422            fn _type_assertion(
7423                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7424            ) {
7425                match _t {
7426                    alloy_sol_types::private::AssertTypeEq::<
7427                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7428                    >(_) => {}
7429                }
7430            }
7431            #[automatically_derived]
7432            #[doc(hidden)]
7433            impl ::core::convert::From<paymentTokenReturn> for UnderlyingRustTuple<'_> {
7434                fn from(value: paymentTokenReturn) -> Self {
7435                    (value._0,)
7436                }
7437            }
7438            #[automatically_derived]
7439            #[doc(hidden)]
7440            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paymentTokenReturn {
7441                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7442                    Self { _0: tuple.0 }
7443                }
7444            }
7445        }
7446        #[automatically_derived]
7447        impl alloy_sol_types::SolCall for paymentTokenCall {
7448            type Parameters<'a> = ();
7449            type Token<'a> = <Self::Parameters<
7450                'a,
7451            > as alloy_sol_types::SolType>::Token<'a>;
7452            type Return = paymentTokenReturn;
7453            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
7454            type ReturnToken<'a> = <Self::ReturnTuple<
7455                'a,
7456            > as alloy_sol_types::SolType>::Token<'a>;
7457            const SIGNATURE: &'static str = "paymentToken()";
7458            const SELECTOR: [u8; 4] = [48u8, 19u8, 206u8, 41u8];
7459            #[inline]
7460            fn new<'a>(
7461                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7462            ) -> Self {
7463                tuple.into()
7464            }
7465            #[inline]
7466            fn tokenize(&self) -> Self::Token<'_> {
7467                ()
7468            }
7469            #[inline]
7470            fn abi_decode_returns(
7471                data: &[u8],
7472                validate: bool,
7473            ) -> alloy_sol_types::Result<Self::Return> {
7474                <Self::ReturnTuple<
7475                    '_,
7476                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7477                    .map(Into::into)
7478            }
7479        }
7480    };
7481    /**Function with signature `pricePerEpoch()` and selector `0x5fc8f59c`.
7482```solidity
7483function pricePerEpoch() external view returns (uint256);
7484```*/
7485    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7486    #[derive(Clone)]
7487    pub struct pricePerEpochCall {}
7488    ///Container type for the return parameters of the [`pricePerEpoch()`](pricePerEpochCall) function.
7489    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7490    #[derive(Clone)]
7491    pub struct pricePerEpochReturn {
7492        #[allow(missing_docs)]
7493        pub _0: alloy::sol_types::private::primitives::aliases::U256,
7494    }
7495    #[allow(
7496        non_camel_case_types,
7497        non_snake_case,
7498        clippy::pub_underscore_fields,
7499        clippy::style
7500    )]
7501    const _: () = {
7502        use alloy::sol_types as alloy_sol_types;
7503        {
7504            #[doc(hidden)]
7505            type UnderlyingSolTuple<'a> = ();
7506            #[doc(hidden)]
7507            type UnderlyingRustTuple<'a> = ();
7508            #[cfg(test)]
7509            #[allow(dead_code, unreachable_patterns)]
7510            fn _type_assertion(
7511                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7512            ) {
7513                match _t {
7514                    alloy_sol_types::private::AssertTypeEq::<
7515                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7516                    >(_) => {}
7517                }
7518            }
7519            #[automatically_derived]
7520            #[doc(hidden)]
7521            impl ::core::convert::From<pricePerEpochCall> for UnderlyingRustTuple<'_> {
7522                fn from(value: pricePerEpochCall) -> Self {
7523                    ()
7524                }
7525            }
7526            #[automatically_derived]
7527            #[doc(hidden)]
7528            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pricePerEpochCall {
7529                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7530                    Self {}
7531                }
7532            }
7533        }
7534        {
7535            #[doc(hidden)]
7536            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7537            #[doc(hidden)]
7538            type UnderlyingRustTuple<'a> = (
7539                alloy::sol_types::private::primitives::aliases::U256,
7540            );
7541            #[cfg(test)]
7542            #[allow(dead_code, unreachable_patterns)]
7543            fn _type_assertion(
7544                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7545            ) {
7546                match _t {
7547                    alloy_sol_types::private::AssertTypeEq::<
7548                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7549                    >(_) => {}
7550                }
7551            }
7552            #[automatically_derived]
7553            #[doc(hidden)]
7554            impl ::core::convert::From<pricePerEpochReturn> for UnderlyingRustTuple<'_> {
7555                fn from(value: pricePerEpochReturn) -> Self {
7556                    (value._0,)
7557                }
7558            }
7559            #[automatically_derived]
7560            #[doc(hidden)]
7561            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pricePerEpochReturn {
7562                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7563                    Self { _0: tuple.0 }
7564                }
7565            }
7566        }
7567        #[automatically_derived]
7568        impl alloy_sol_types::SolCall for pricePerEpochCall {
7569            type Parameters<'a> = ();
7570            type Token<'a> = <Self::Parameters<
7571                'a,
7572            > as alloy_sol_types::SolType>::Token<'a>;
7573            type Return = pricePerEpochReturn;
7574            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7575            type ReturnToken<'a> = <Self::ReturnTuple<
7576                'a,
7577            > as alloy_sol_types::SolType>::Token<'a>;
7578            const SIGNATURE: &'static str = "pricePerEpoch()";
7579            const SELECTOR: [u8; 4] = [95u8, 200u8, 245u8, 156u8];
7580            #[inline]
7581            fn new<'a>(
7582                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7583            ) -> Self {
7584                tuple.into()
7585            }
7586            #[inline]
7587            fn tokenize(&self) -> Self::Token<'_> {
7588                ()
7589            }
7590            #[inline]
7591            fn abi_decode_returns(
7592                data: &[u8],
7593                validate: bool,
7594            ) -> alloy_sol_types::Result<Self::Return> {
7595                <Self::ReturnTuple<
7596                    '_,
7597                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7598                    .map(Into::into)
7599            }
7600        }
7601    };
7602    /**Function with signature `providersAccessType()` and selector `0xd4773ff0`.
7603```solidity
7604function providersAccessType() external view returns (IConfigV2.AccessTypeV2);
7605```*/
7606    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7607    #[derive(Clone)]
7608    pub struct providersAccessTypeCall {}
7609    ///Container type for the return parameters of the [`providersAccessType()`](providersAccessTypeCall) function.
7610    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7611    #[derive(Clone)]
7612    pub struct providersAccessTypeReturn {
7613        #[allow(missing_docs)]
7614        pub _0: <IConfigV2::AccessTypeV2 as alloy::sol_types::SolType>::RustType,
7615    }
7616    #[allow(
7617        non_camel_case_types,
7618        non_snake_case,
7619        clippy::pub_underscore_fields,
7620        clippy::style
7621    )]
7622    const _: () = {
7623        use alloy::sol_types as alloy_sol_types;
7624        {
7625            #[doc(hidden)]
7626            type UnderlyingSolTuple<'a> = ();
7627            #[doc(hidden)]
7628            type UnderlyingRustTuple<'a> = ();
7629            #[cfg(test)]
7630            #[allow(dead_code, unreachable_patterns)]
7631            fn _type_assertion(
7632                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7633            ) {
7634                match _t {
7635                    alloy_sol_types::private::AssertTypeEq::<
7636                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7637                    >(_) => {}
7638                }
7639            }
7640            #[automatically_derived]
7641            #[doc(hidden)]
7642            impl ::core::convert::From<providersAccessTypeCall>
7643            for UnderlyingRustTuple<'_> {
7644                fn from(value: providersAccessTypeCall) -> Self {
7645                    ()
7646                }
7647            }
7648            #[automatically_derived]
7649            #[doc(hidden)]
7650            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7651            for providersAccessTypeCall {
7652                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7653                    Self {}
7654                }
7655            }
7656        }
7657        {
7658            #[doc(hidden)]
7659            type UnderlyingSolTuple<'a> = (IConfigV2::AccessTypeV2,);
7660            #[doc(hidden)]
7661            type UnderlyingRustTuple<'a> = (
7662                <IConfigV2::AccessTypeV2 as alloy::sol_types::SolType>::RustType,
7663            );
7664            #[cfg(test)]
7665            #[allow(dead_code, unreachable_patterns)]
7666            fn _type_assertion(
7667                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7668            ) {
7669                match _t {
7670                    alloy_sol_types::private::AssertTypeEq::<
7671                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7672                    >(_) => {}
7673                }
7674            }
7675            #[automatically_derived]
7676            #[doc(hidden)]
7677            impl ::core::convert::From<providersAccessTypeReturn>
7678            for UnderlyingRustTuple<'_> {
7679                fn from(value: providersAccessTypeReturn) -> Self {
7680                    (value._0,)
7681                }
7682            }
7683            #[automatically_derived]
7684            #[doc(hidden)]
7685            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7686            for providersAccessTypeReturn {
7687                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7688                    Self { _0: tuple.0 }
7689                }
7690            }
7691        }
7692        #[automatically_derived]
7693        impl alloy_sol_types::SolCall for providersAccessTypeCall {
7694            type Parameters<'a> = ();
7695            type Token<'a> = <Self::Parameters<
7696                'a,
7697            > as alloy_sol_types::SolType>::Token<'a>;
7698            type Return = providersAccessTypeReturn;
7699            type ReturnTuple<'a> = (IConfigV2::AccessTypeV2,);
7700            type ReturnToken<'a> = <Self::ReturnTuple<
7701                'a,
7702            > as alloy_sol_types::SolType>::Token<'a>;
7703            const SIGNATURE: &'static str = "providersAccessType()";
7704            const SELECTOR: [u8; 4] = [212u8, 119u8, 63u8, 240u8];
7705            #[inline]
7706            fn new<'a>(
7707                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7708            ) -> Self {
7709                tuple.into()
7710            }
7711            #[inline]
7712            fn tokenize(&self) -> Self::Token<'_> {
7713                ()
7714            }
7715            #[inline]
7716            fn abi_decode_returns(
7717                data: &[u8],
7718                validate: bool,
7719            ) -> alloy_sol_types::Result<Self::Return> {
7720                <Self::ReturnTuple<
7721                    '_,
7722                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7723                    .map(Into::into)
7724            }
7725        }
7726    };
7727    /**Function with signature `removeProviderFromAccessList(address)` and selector `0x444e6a5a`.
7728```solidity
7729function removeProviderFromAccessList(address provider) external;
7730```*/
7731    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7732    #[derive(Clone)]
7733    pub struct removeProviderFromAccessListCall {
7734        #[allow(missing_docs)]
7735        pub provider: alloy::sol_types::private::Address,
7736    }
7737    ///Container type for the return parameters of the [`removeProviderFromAccessList(address)`](removeProviderFromAccessListCall) function.
7738    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7739    #[derive(Clone)]
7740    pub struct removeProviderFromAccessListReturn {}
7741    #[allow(
7742        non_camel_case_types,
7743        non_snake_case,
7744        clippy::pub_underscore_fields,
7745        clippy::style
7746    )]
7747    const _: () = {
7748        use alloy::sol_types as alloy_sol_types;
7749        {
7750            #[doc(hidden)]
7751            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7752            #[doc(hidden)]
7753            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7754            #[cfg(test)]
7755            #[allow(dead_code, unreachable_patterns)]
7756            fn _type_assertion(
7757                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7758            ) {
7759                match _t {
7760                    alloy_sol_types::private::AssertTypeEq::<
7761                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7762                    >(_) => {}
7763                }
7764            }
7765            #[automatically_derived]
7766            #[doc(hidden)]
7767            impl ::core::convert::From<removeProviderFromAccessListCall>
7768            for UnderlyingRustTuple<'_> {
7769                fn from(value: removeProviderFromAccessListCall) -> Self {
7770                    (value.provider,)
7771                }
7772            }
7773            #[automatically_derived]
7774            #[doc(hidden)]
7775            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7776            for removeProviderFromAccessListCall {
7777                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7778                    Self { provider: tuple.0 }
7779                }
7780            }
7781        }
7782        {
7783            #[doc(hidden)]
7784            type UnderlyingSolTuple<'a> = ();
7785            #[doc(hidden)]
7786            type UnderlyingRustTuple<'a> = ();
7787            #[cfg(test)]
7788            #[allow(dead_code, unreachable_patterns)]
7789            fn _type_assertion(
7790                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7791            ) {
7792                match _t {
7793                    alloy_sol_types::private::AssertTypeEq::<
7794                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7795                    >(_) => {}
7796                }
7797            }
7798            #[automatically_derived]
7799            #[doc(hidden)]
7800            impl ::core::convert::From<removeProviderFromAccessListReturn>
7801            for UnderlyingRustTuple<'_> {
7802                fn from(value: removeProviderFromAccessListReturn) -> Self {
7803                    ()
7804                }
7805            }
7806            #[automatically_derived]
7807            #[doc(hidden)]
7808            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7809            for removeProviderFromAccessListReturn {
7810                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7811                    Self {}
7812                }
7813            }
7814        }
7815        #[automatically_derived]
7816        impl alloy_sol_types::SolCall for removeProviderFromAccessListCall {
7817            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
7818            type Token<'a> = <Self::Parameters<
7819                'a,
7820            > as alloy_sol_types::SolType>::Token<'a>;
7821            type Return = removeProviderFromAccessListReturn;
7822            type ReturnTuple<'a> = ();
7823            type ReturnToken<'a> = <Self::ReturnTuple<
7824                'a,
7825            > as alloy_sol_types::SolType>::Token<'a>;
7826            const SIGNATURE: &'static str = "removeProviderFromAccessList(address)";
7827            const SELECTOR: [u8; 4] = [68u8, 78u8, 106u8, 90u8];
7828            #[inline]
7829            fn new<'a>(
7830                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7831            ) -> Self {
7832                tuple.into()
7833            }
7834            #[inline]
7835            fn tokenize(&self) -> Self::Token<'_> {
7836                (
7837                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7838                        &self.provider,
7839                    ),
7840                )
7841            }
7842            #[inline]
7843            fn abi_decode_returns(
7844                data: &[u8],
7845                validate: bool,
7846            ) -> alloy_sol_types::Result<Self::Return> {
7847                <Self::ReturnTuple<
7848                    '_,
7849                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7850                    .map(Into::into)
7851            }
7852        }
7853    };
7854    /**Function with signature `removeStaleWorkers(bytes32[])` and selector `0xcb7b88d1`.
7855```solidity
7856function removeStaleWorkers(bytes32[] memory onchainWorkerIds) external;
7857```*/
7858    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7859    #[derive(Clone)]
7860    pub struct removeStaleWorkersCall {
7861        #[allow(missing_docs)]
7862        pub onchainWorkerIds: alloy::sol_types::private::Vec<
7863            alloy::sol_types::private::FixedBytes<32>,
7864        >,
7865    }
7866    ///Container type for the return parameters of the [`removeStaleWorkers(bytes32[])`](removeStaleWorkersCall) function.
7867    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7868    #[derive(Clone)]
7869    pub struct removeStaleWorkersReturn {}
7870    #[allow(
7871        non_camel_case_types,
7872        non_snake_case,
7873        clippy::pub_underscore_fields,
7874        clippy::style
7875    )]
7876    const _: () = {
7877        use alloy::sol_types as alloy_sol_types;
7878        {
7879            #[doc(hidden)]
7880            type UnderlyingSolTuple<'a> = (
7881                alloy::sol_types::sol_data::Array<
7882                    alloy::sol_types::sol_data::FixedBytes<32>,
7883                >,
7884            );
7885            #[doc(hidden)]
7886            type UnderlyingRustTuple<'a> = (
7887                alloy::sol_types::private::Vec<
7888                    alloy::sol_types::private::FixedBytes<32>,
7889                >,
7890            );
7891            #[cfg(test)]
7892            #[allow(dead_code, unreachable_patterns)]
7893            fn _type_assertion(
7894                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7895            ) {
7896                match _t {
7897                    alloy_sol_types::private::AssertTypeEq::<
7898                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7899                    >(_) => {}
7900                }
7901            }
7902            #[automatically_derived]
7903            #[doc(hidden)]
7904            impl ::core::convert::From<removeStaleWorkersCall>
7905            for UnderlyingRustTuple<'_> {
7906                fn from(value: removeStaleWorkersCall) -> Self {
7907                    (value.onchainWorkerIds,)
7908                }
7909            }
7910            #[automatically_derived]
7911            #[doc(hidden)]
7912            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7913            for removeStaleWorkersCall {
7914                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7915                    Self { onchainWorkerIds: tuple.0 }
7916                }
7917            }
7918        }
7919        {
7920            #[doc(hidden)]
7921            type UnderlyingSolTuple<'a> = ();
7922            #[doc(hidden)]
7923            type UnderlyingRustTuple<'a> = ();
7924            #[cfg(test)]
7925            #[allow(dead_code, unreachable_patterns)]
7926            fn _type_assertion(
7927                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7928            ) {
7929                match _t {
7930                    alloy_sol_types::private::AssertTypeEq::<
7931                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7932                    >(_) => {}
7933                }
7934            }
7935            #[automatically_derived]
7936            #[doc(hidden)]
7937            impl ::core::convert::From<removeStaleWorkersReturn>
7938            for UnderlyingRustTuple<'_> {
7939                fn from(value: removeStaleWorkersReturn) -> Self {
7940                    ()
7941                }
7942            }
7943            #[automatically_derived]
7944            #[doc(hidden)]
7945            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7946            for removeStaleWorkersReturn {
7947                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7948                    Self {}
7949                }
7950            }
7951        }
7952        #[automatically_derived]
7953        impl alloy_sol_types::SolCall for removeStaleWorkersCall {
7954            type Parameters<'a> = (
7955                alloy::sol_types::sol_data::Array<
7956                    alloy::sol_types::sol_data::FixedBytes<32>,
7957                >,
7958            );
7959            type Token<'a> = <Self::Parameters<
7960                'a,
7961            > as alloy_sol_types::SolType>::Token<'a>;
7962            type Return = removeStaleWorkersReturn;
7963            type ReturnTuple<'a> = ();
7964            type ReturnToken<'a> = <Self::ReturnTuple<
7965                'a,
7966            > as alloy_sol_types::SolType>::Token<'a>;
7967            const SIGNATURE: &'static str = "removeStaleWorkers(bytes32[])";
7968            const SELECTOR: [u8; 4] = [203u8, 123u8, 136u8, 209u8];
7969            #[inline]
7970            fn new<'a>(
7971                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7972            ) -> Self {
7973                tuple.into()
7974            }
7975            #[inline]
7976            fn tokenize(&self) -> Self::Token<'_> {
7977                (
7978                    <alloy::sol_types::sol_data::Array<
7979                        alloy::sol_types::sol_data::FixedBytes<32>,
7980                    > as alloy_sol_types::SolType>::tokenize(&self.onchainWorkerIds),
7981                )
7982            }
7983            #[inline]
7984            fn abi_decode_returns(
7985                data: &[u8],
7986                validate: bool,
7987            ) -> alloy_sol_types::Result<Self::Return> {
7988                <Self::ReturnTuple<
7989                    '_,
7990                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7991                    .map(Into::into)
7992            }
7993        }
7994    };
7995    /**Function with signature `removeWorker(bytes32)` and selector `0xbc126f1f`.
7996```solidity
7997function removeWorker(bytes32 onchainWorkerId) external;
7998```*/
7999    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8000    #[derive(Clone)]
8001    pub struct removeWorkerCall {
8002        #[allow(missing_docs)]
8003        pub onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
8004    }
8005    ///Container type for the return parameters of the [`removeWorker(bytes32)`](removeWorkerCall) function.
8006    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8007    #[derive(Clone)]
8008    pub struct removeWorkerReturn {}
8009    #[allow(
8010        non_camel_case_types,
8011        non_snake_case,
8012        clippy::pub_underscore_fields,
8013        clippy::style
8014    )]
8015    const _: () = {
8016        use alloy::sol_types as alloy_sol_types;
8017        {
8018            #[doc(hidden)]
8019            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8020            #[doc(hidden)]
8021            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
8022            #[cfg(test)]
8023            #[allow(dead_code, unreachable_patterns)]
8024            fn _type_assertion(
8025                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8026            ) {
8027                match _t {
8028                    alloy_sol_types::private::AssertTypeEq::<
8029                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8030                    >(_) => {}
8031                }
8032            }
8033            #[automatically_derived]
8034            #[doc(hidden)]
8035            impl ::core::convert::From<removeWorkerCall> for UnderlyingRustTuple<'_> {
8036                fn from(value: removeWorkerCall) -> Self {
8037                    (value.onchainWorkerId,)
8038                }
8039            }
8040            #[automatically_derived]
8041            #[doc(hidden)]
8042            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeWorkerCall {
8043                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8044                    Self { onchainWorkerId: tuple.0 }
8045                }
8046            }
8047        }
8048        {
8049            #[doc(hidden)]
8050            type UnderlyingSolTuple<'a> = ();
8051            #[doc(hidden)]
8052            type UnderlyingRustTuple<'a> = ();
8053            #[cfg(test)]
8054            #[allow(dead_code, unreachable_patterns)]
8055            fn _type_assertion(
8056                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8057            ) {
8058                match _t {
8059                    alloy_sol_types::private::AssertTypeEq::<
8060                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8061                    >(_) => {}
8062                }
8063            }
8064            #[automatically_derived]
8065            #[doc(hidden)]
8066            impl ::core::convert::From<removeWorkerReturn> for UnderlyingRustTuple<'_> {
8067                fn from(value: removeWorkerReturn) -> Self {
8068                    ()
8069                }
8070            }
8071            #[automatically_derived]
8072            #[doc(hidden)]
8073            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeWorkerReturn {
8074                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8075                    Self {}
8076                }
8077            }
8078        }
8079        #[automatically_derived]
8080        impl alloy_sol_types::SolCall for removeWorkerCall {
8081            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8082            type Token<'a> = <Self::Parameters<
8083                'a,
8084            > as alloy_sol_types::SolType>::Token<'a>;
8085            type Return = removeWorkerReturn;
8086            type ReturnTuple<'a> = ();
8087            type ReturnToken<'a> = <Self::ReturnTuple<
8088                'a,
8089            > as alloy_sol_types::SolType>::Token<'a>;
8090            const SIGNATURE: &'static str = "removeWorker(bytes32)";
8091            const SELECTOR: [u8; 4] = [188u8, 18u8, 111u8, 31u8];
8092            #[inline]
8093            fn new<'a>(
8094                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8095            ) -> Self {
8096                tuple.into()
8097            }
8098            #[inline]
8099            fn tokenize(&self) -> Self::Token<'_> {
8100                (
8101                    <alloy::sol_types::sol_data::FixedBytes<
8102                        32,
8103                    > as alloy_sol_types::SolType>::tokenize(&self.onchainWorkerId),
8104                )
8105            }
8106            #[inline]
8107            fn abi_decode_returns(
8108                data: &[u8],
8109                validate: bool,
8110            ) -> alloy_sol_types::Result<Self::Return> {
8111                <Self::ReturnTuple<
8112                    '_,
8113                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8114                    .map(Into::into)
8115            }
8116        }
8117    };
8118    /**Function with signature `requiredResources()` and selector `0x4e4d7af8`.
8119```solidity
8120function requiredResources() external view returns (IOfferV2.ResourceRequirement[] memory);
8121```*/
8122    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8123    #[derive(Clone)]
8124    pub struct requiredResourcesCall {}
8125    ///Container type for the return parameters of the [`requiredResources()`](requiredResourcesCall) function.
8126    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8127    #[derive(Clone)]
8128    pub struct requiredResourcesReturn {
8129        #[allow(missing_docs)]
8130        pub _0: alloy::sol_types::private::Vec<
8131            <IOfferV2::ResourceRequirement as alloy::sol_types::SolType>::RustType,
8132        >,
8133    }
8134    #[allow(
8135        non_camel_case_types,
8136        non_snake_case,
8137        clippy::pub_underscore_fields,
8138        clippy::style
8139    )]
8140    const _: () = {
8141        use alloy::sol_types as alloy_sol_types;
8142        {
8143            #[doc(hidden)]
8144            type UnderlyingSolTuple<'a> = ();
8145            #[doc(hidden)]
8146            type UnderlyingRustTuple<'a> = ();
8147            #[cfg(test)]
8148            #[allow(dead_code, unreachable_patterns)]
8149            fn _type_assertion(
8150                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8151            ) {
8152                match _t {
8153                    alloy_sol_types::private::AssertTypeEq::<
8154                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8155                    >(_) => {}
8156                }
8157            }
8158            #[automatically_derived]
8159            #[doc(hidden)]
8160            impl ::core::convert::From<requiredResourcesCall>
8161            for UnderlyingRustTuple<'_> {
8162                fn from(value: requiredResourcesCall) -> Self {
8163                    ()
8164                }
8165            }
8166            #[automatically_derived]
8167            #[doc(hidden)]
8168            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8169            for requiredResourcesCall {
8170                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8171                    Self {}
8172                }
8173            }
8174        }
8175        {
8176            #[doc(hidden)]
8177            type UnderlyingSolTuple<'a> = (
8178                alloy::sol_types::sol_data::Array<IOfferV2::ResourceRequirement>,
8179            );
8180            #[doc(hidden)]
8181            type UnderlyingRustTuple<'a> = (
8182                alloy::sol_types::private::Vec<
8183                    <IOfferV2::ResourceRequirement as alloy::sol_types::SolType>::RustType,
8184                >,
8185            );
8186            #[cfg(test)]
8187            #[allow(dead_code, unreachable_patterns)]
8188            fn _type_assertion(
8189                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8190            ) {
8191                match _t {
8192                    alloy_sol_types::private::AssertTypeEq::<
8193                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8194                    >(_) => {}
8195                }
8196            }
8197            #[automatically_derived]
8198            #[doc(hidden)]
8199            impl ::core::convert::From<requiredResourcesReturn>
8200            for UnderlyingRustTuple<'_> {
8201                fn from(value: requiredResourcesReturn) -> Self {
8202                    (value._0,)
8203                }
8204            }
8205            #[automatically_derived]
8206            #[doc(hidden)]
8207            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8208            for requiredResourcesReturn {
8209                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8210                    Self { _0: tuple.0 }
8211                }
8212            }
8213        }
8214        #[automatically_derived]
8215        impl alloy_sol_types::SolCall for requiredResourcesCall {
8216            type Parameters<'a> = ();
8217            type Token<'a> = <Self::Parameters<
8218                'a,
8219            > as alloy_sol_types::SolType>::Token<'a>;
8220            type Return = requiredResourcesReturn;
8221            type ReturnTuple<'a> = (
8222                alloy::sol_types::sol_data::Array<IOfferV2::ResourceRequirement>,
8223            );
8224            type ReturnToken<'a> = <Self::ReturnTuple<
8225                'a,
8226            > as alloy_sol_types::SolType>::Token<'a>;
8227            const SIGNATURE: &'static str = "requiredResources()";
8228            const SELECTOR: [u8; 4] = [78u8, 77u8, 122u8, 248u8];
8229            #[inline]
8230            fn new<'a>(
8231                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8232            ) -> Self {
8233                tuple.into()
8234            }
8235            #[inline]
8236            fn tokenize(&self) -> Self::Token<'_> {
8237                ()
8238            }
8239            #[inline]
8240            fn abi_decode_returns(
8241                data: &[u8],
8242                validate: bool,
8243            ) -> alloy_sol_types::Result<Self::Return> {
8244                <Self::ReturnTuple<
8245                    '_,
8246                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8247                    .map(Into::into)
8248            }
8249        }
8250    };
8251    /**Function with signature `setAppCID((bytes4,bytes32))` and selector `0x176474cf`.
8252```solidity
8253function setAppCID(Common.CIDV1 memory appCID_) external;
8254```*/
8255    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8256    #[derive(Clone)]
8257    pub struct setAppCIDCall {
8258        #[allow(missing_docs)]
8259        pub appCID_: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
8260    }
8261    ///Container type for the return parameters of the [`setAppCID((bytes4,bytes32))`](setAppCIDCall) function.
8262    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8263    #[derive(Clone)]
8264    pub struct setAppCIDReturn {}
8265    #[allow(
8266        non_camel_case_types,
8267        non_snake_case,
8268        clippy::pub_underscore_fields,
8269        clippy::style
8270    )]
8271    const _: () = {
8272        use alloy::sol_types as alloy_sol_types;
8273        {
8274            #[doc(hidden)]
8275            type UnderlyingSolTuple<'a> = (Common::CIDV1,);
8276            #[doc(hidden)]
8277            type UnderlyingRustTuple<'a> = (
8278                <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
8279            );
8280            #[cfg(test)]
8281            #[allow(dead_code, unreachable_patterns)]
8282            fn _type_assertion(
8283                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8284            ) {
8285                match _t {
8286                    alloy_sol_types::private::AssertTypeEq::<
8287                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8288                    >(_) => {}
8289                }
8290            }
8291            #[automatically_derived]
8292            #[doc(hidden)]
8293            impl ::core::convert::From<setAppCIDCall> for UnderlyingRustTuple<'_> {
8294                fn from(value: setAppCIDCall) -> Self {
8295                    (value.appCID_,)
8296                }
8297            }
8298            #[automatically_derived]
8299            #[doc(hidden)]
8300            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppCIDCall {
8301                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8302                    Self { appCID_: tuple.0 }
8303                }
8304            }
8305        }
8306        {
8307            #[doc(hidden)]
8308            type UnderlyingSolTuple<'a> = ();
8309            #[doc(hidden)]
8310            type UnderlyingRustTuple<'a> = ();
8311            #[cfg(test)]
8312            #[allow(dead_code, unreachable_patterns)]
8313            fn _type_assertion(
8314                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8315            ) {
8316                match _t {
8317                    alloy_sol_types::private::AssertTypeEq::<
8318                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8319                    >(_) => {}
8320                }
8321            }
8322            #[automatically_derived]
8323            #[doc(hidden)]
8324            impl ::core::convert::From<setAppCIDReturn> for UnderlyingRustTuple<'_> {
8325                fn from(value: setAppCIDReturn) -> Self {
8326                    ()
8327                }
8328            }
8329            #[automatically_derived]
8330            #[doc(hidden)]
8331            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppCIDReturn {
8332                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8333                    Self {}
8334                }
8335            }
8336        }
8337        #[automatically_derived]
8338        impl alloy_sol_types::SolCall for setAppCIDCall {
8339            type Parameters<'a> = (Common::CIDV1,);
8340            type Token<'a> = <Self::Parameters<
8341                'a,
8342            > as alloy_sol_types::SolType>::Token<'a>;
8343            type Return = setAppCIDReturn;
8344            type ReturnTuple<'a> = ();
8345            type ReturnToken<'a> = <Self::ReturnTuple<
8346                'a,
8347            > as alloy_sol_types::SolType>::Token<'a>;
8348            const SIGNATURE: &'static str = "setAppCID((bytes4,bytes32))";
8349            const SELECTOR: [u8; 4] = [23u8, 100u8, 116u8, 207u8];
8350            #[inline]
8351            fn new<'a>(
8352                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8353            ) -> Self {
8354                tuple.into()
8355            }
8356            #[inline]
8357            fn tokenize(&self) -> Self::Token<'_> {
8358                (<Common::CIDV1 as alloy_sol_types::SolType>::tokenize(&self.appCID_),)
8359            }
8360            #[inline]
8361            fn abi_decode_returns(
8362                data: &[u8],
8363                validate: bool,
8364            ) -> alloy_sol_types::Result<Self::Return> {
8365                <Self::ReturnTuple<
8366                    '_,
8367                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8368                    .map(Into::into)
8369            }
8370        }
8371    };
8372    /**Function with signature `stop()` and selector `0x07da68f5`.
8373```solidity
8374function stop() external;
8375```*/
8376    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8377    #[derive(Clone)]
8378    pub struct stopCall {}
8379    ///Container type for the return parameters of the [`stop()`](stopCall) function.
8380    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8381    #[derive(Clone)]
8382    pub struct stopReturn {}
8383    #[allow(
8384        non_camel_case_types,
8385        non_snake_case,
8386        clippy::pub_underscore_fields,
8387        clippy::style
8388    )]
8389    const _: () = {
8390        use alloy::sol_types as alloy_sol_types;
8391        {
8392            #[doc(hidden)]
8393            type UnderlyingSolTuple<'a> = ();
8394            #[doc(hidden)]
8395            type UnderlyingRustTuple<'a> = ();
8396            #[cfg(test)]
8397            #[allow(dead_code, unreachable_patterns)]
8398            fn _type_assertion(
8399                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8400            ) {
8401                match _t {
8402                    alloy_sol_types::private::AssertTypeEq::<
8403                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8404                    >(_) => {}
8405                }
8406            }
8407            #[automatically_derived]
8408            #[doc(hidden)]
8409            impl ::core::convert::From<stopCall> for UnderlyingRustTuple<'_> {
8410                fn from(value: stopCall) -> Self {
8411                    ()
8412                }
8413            }
8414            #[automatically_derived]
8415            #[doc(hidden)]
8416            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopCall {
8417                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8418                    Self {}
8419                }
8420            }
8421        }
8422        {
8423            #[doc(hidden)]
8424            type UnderlyingSolTuple<'a> = ();
8425            #[doc(hidden)]
8426            type UnderlyingRustTuple<'a> = ();
8427            #[cfg(test)]
8428            #[allow(dead_code, unreachable_patterns)]
8429            fn _type_assertion(
8430                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8431            ) {
8432                match _t {
8433                    alloy_sol_types::private::AssertTypeEq::<
8434                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8435                    >(_) => {}
8436                }
8437            }
8438            #[automatically_derived]
8439            #[doc(hidden)]
8440            impl ::core::convert::From<stopReturn> for UnderlyingRustTuple<'_> {
8441                fn from(value: stopReturn) -> Self {
8442                    ()
8443                }
8444            }
8445            #[automatically_derived]
8446            #[doc(hidden)]
8447            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopReturn {
8448                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8449                    Self {}
8450                }
8451            }
8452        }
8453        #[automatically_derived]
8454        impl alloy_sol_types::SolCall for stopCall {
8455            type Parameters<'a> = ();
8456            type Token<'a> = <Self::Parameters<
8457                'a,
8458            > as alloy_sol_types::SolType>::Token<'a>;
8459            type Return = stopReturn;
8460            type ReturnTuple<'a> = ();
8461            type ReturnToken<'a> = <Self::ReturnTuple<
8462                'a,
8463            > as alloy_sol_types::SolType>::Token<'a>;
8464            const SIGNATURE: &'static str = "stop()";
8465            const SELECTOR: [u8; 4] = [7u8, 218u8, 104u8, 245u8];
8466            #[inline]
8467            fn new<'a>(
8468                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8469            ) -> Self {
8470                tuple.into()
8471            }
8472            #[inline]
8473            fn tokenize(&self) -> Self::Token<'_> {
8474                ()
8475            }
8476            #[inline]
8477            fn abi_decode_returns(
8478                data: &[u8],
8479                validate: bool,
8480            ) -> alloy_sol_types::Result<Self::Return> {
8481                <Self::ReturnTuple<
8482                    '_,
8483                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8484                    .map(Into::into)
8485            }
8486        }
8487    };
8488    /**Function with signature `targetWorkers()` and selector `0x2943dcab`.
8489```solidity
8490function targetWorkers() external view returns (uint256);
8491```*/
8492    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8493    #[derive(Clone)]
8494    pub struct targetWorkersCall {}
8495    ///Container type for the return parameters of the [`targetWorkers()`](targetWorkersCall) function.
8496    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8497    #[derive(Clone)]
8498    pub struct targetWorkersReturn {
8499        #[allow(missing_docs)]
8500        pub _0: alloy::sol_types::private::primitives::aliases::U256,
8501    }
8502    #[allow(
8503        non_camel_case_types,
8504        non_snake_case,
8505        clippy::pub_underscore_fields,
8506        clippy::style
8507    )]
8508    const _: () = {
8509        use alloy::sol_types as alloy_sol_types;
8510        {
8511            #[doc(hidden)]
8512            type UnderlyingSolTuple<'a> = ();
8513            #[doc(hidden)]
8514            type UnderlyingRustTuple<'a> = ();
8515            #[cfg(test)]
8516            #[allow(dead_code, unreachable_patterns)]
8517            fn _type_assertion(
8518                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8519            ) {
8520                match _t {
8521                    alloy_sol_types::private::AssertTypeEq::<
8522                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8523                    >(_) => {}
8524                }
8525            }
8526            #[automatically_derived]
8527            #[doc(hidden)]
8528            impl ::core::convert::From<targetWorkersCall> for UnderlyingRustTuple<'_> {
8529                fn from(value: targetWorkersCall) -> Self {
8530                    ()
8531                }
8532            }
8533            #[automatically_derived]
8534            #[doc(hidden)]
8535            impl ::core::convert::From<UnderlyingRustTuple<'_>> for targetWorkersCall {
8536                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8537                    Self {}
8538                }
8539            }
8540        }
8541        {
8542            #[doc(hidden)]
8543            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
8544            #[doc(hidden)]
8545            type UnderlyingRustTuple<'a> = (
8546                alloy::sol_types::private::primitives::aliases::U256,
8547            );
8548            #[cfg(test)]
8549            #[allow(dead_code, unreachable_patterns)]
8550            fn _type_assertion(
8551                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8552            ) {
8553                match _t {
8554                    alloy_sol_types::private::AssertTypeEq::<
8555                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8556                    >(_) => {}
8557                }
8558            }
8559            #[automatically_derived]
8560            #[doc(hidden)]
8561            impl ::core::convert::From<targetWorkersReturn> for UnderlyingRustTuple<'_> {
8562                fn from(value: targetWorkersReturn) -> Self {
8563                    (value._0,)
8564                }
8565            }
8566            #[automatically_derived]
8567            #[doc(hidden)]
8568            impl ::core::convert::From<UnderlyingRustTuple<'_>> for targetWorkersReturn {
8569                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8570                    Self { _0: tuple.0 }
8571                }
8572            }
8573        }
8574        #[automatically_derived]
8575        impl alloy_sol_types::SolCall for targetWorkersCall {
8576            type Parameters<'a> = ();
8577            type Token<'a> = <Self::Parameters<
8578                'a,
8579            > as alloy_sol_types::SolType>::Token<'a>;
8580            type Return = targetWorkersReturn;
8581            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
8582            type ReturnToken<'a> = <Self::ReturnTuple<
8583                'a,
8584            > as alloy_sol_types::SolType>::Token<'a>;
8585            const SIGNATURE: &'static str = "targetWorkers()";
8586            const SELECTOR: [u8; 4] = [41u8, 67u8, 220u8, 171u8];
8587            #[inline]
8588            fn new<'a>(
8589                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8590            ) -> Self {
8591                tuple.into()
8592            }
8593            #[inline]
8594            fn tokenize(&self) -> Self::Token<'_> {
8595                ()
8596            }
8597            #[inline]
8598            fn abi_decode_returns(
8599                data: &[u8],
8600                validate: bool,
8601            ) -> alloy_sol_types::Result<Self::Return> {
8602                <Self::ReturnTuple<
8603                    '_,
8604                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8605                    .map(Into::into)
8606            }
8607        }
8608    };
8609    /**Function with signature `withdraw(uint256)` and selector `0x2e1a7d4d`.
8610```solidity
8611function withdraw(uint256 amount) external;
8612```*/
8613    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8614    #[derive(Clone)]
8615    pub struct withdrawCall {
8616        #[allow(missing_docs)]
8617        pub amount: alloy::sol_types::private::primitives::aliases::U256,
8618    }
8619    ///Container type for the return parameters of the [`withdraw(uint256)`](withdrawCall) function.
8620    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8621    #[derive(Clone)]
8622    pub struct withdrawReturn {}
8623    #[allow(
8624        non_camel_case_types,
8625        non_snake_case,
8626        clippy::pub_underscore_fields,
8627        clippy::style
8628    )]
8629    const _: () = {
8630        use alloy::sol_types as alloy_sol_types;
8631        {
8632            #[doc(hidden)]
8633            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
8634            #[doc(hidden)]
8635            type UnderlyingRustTuple<'a> = (
8636                alloy::sol_types::private::primitives::aliases::U256,
8637            );
8638            #[cfg(test)]
8639            #[allow(dead_code, unreachable_patterns)]
8640            fn _type_assertion(
8641                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8642            ) {
8643                match _t {
8644                    alloy_sol_types::private::AssertTypeEq::<
8645                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8646                    >(_) => {}
8647                }
8648            }
8649            #[automatically_derived]
8650            #[doc(hidden)]
8651            impl ::core::convert::From<withdrawCall> for UnderlyingRustTuple<'_> {
8652                fn from(value: withdrawCall) -> Self {
8653                    (value.amount,)
8654                }
8655            }
8656            #[automatically_derived]
8657            #[doc(hidden)]
8658            impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawCall {
8659                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8660                    Self { amount: tuple.0 }
8661                }
8662            }
8663        }
8664        {
8665            #[doc(hidden)]
8666            type UnderlyingSolTuple<'a> = ();
8667            #[doc(hidden)]
8668            type UnderlyingRustTuple<'a> = ();
8669            #[cfg(test)]
8670            #[allow(dead_code, unreachable_patterns)]
8671            fn _type_assertion(
8672                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8673            ) {
8674                match _t {
8675                    alloy_sol_types::private::AssertTypeEq::<
8676                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8677                    >(_) => {}
8678                }
8679            }
8680            #[automatically_derived]
8681            #[doc(hidden)]
8682            impl ::core::convert::From<withdrawReturn> for UnderlyingRustTuple<'_> {
8683                fn from(value: withdrawReturn) -> Self {
8684                    ()
8685                }
8686            }
8687            #[automatically_derived]
8688            #[doc(hidden)]
8689            impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawReturn {
8690                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8691                    Self {}
8692                }
8693            }
8694        }
8695        #[automatically_derived]
8696        impl alloy_sol_types::SolCall for withdrawCall {
8697            type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
8698            type Token<'a> = <Self::Parameters<
8699                'a,
8700            > as alloy_sol_types::SolType>::Token<'a>;
8701            type Return = withdrawReturn;
8702            type ReturnTuple<'a> = ();
8703            type ReturnToken<'a> = <Self::ReturnTuple<
8704                'a,
8705            > as alloy_sol_types::SolType>::Token<'a>;
8706            const SIGNATURE: &'static str = "withdraw(uint256)";
8707            const SELECTOR: [u8; 4] = [46u8, 26u8, 125u8, 77u8];
8708            #[inline]
8709            fn new<'a>(
8710                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8711            ) -> Self {
8712                tuple.into()
8713            }
8714            #[inline]
8715            fn tokenize(&self) -> Self::Token<'_> {
8716                (
8717                    <alloy::sol_types::sol_data::Uint<
8718                        256,
8719                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
8720                )
8721            }
8722            #[inline]
8723            fn abi_decode_returns(
8724                data: &[u8],
8725                validate: bool,
8726            ) -> alloy_sol_types::Result<Self::Return> {
8727                <Self::ReturnTuple<
8728                    '_,
8729                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8730                    .map(Into::into)
8731            }
8732        }
8733    };
8734    /**Function with signature `withdrawRewards(bytes32)` and selector `0x7dfb6626`.
8735```solidity
8736function withdrawRewards(bytes32 onchainWorkerId) external;
8737```*/
8738    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8739    #[derive(Clone)]
8740    pub struct withdrawRewardsCall {
8741        #[allow(missing_docs)]
8742        pub onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
8743    }
8744    ///Container type for the return parameters of the [`withdrawRewards(bytes32)`](withdrawRewardsCall) function.
8745    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8746    #[derive(Clone)]
8747    pub struct withdrawRewardsReturn {}
8748    #[allow(
8749        non_camel_case_types,
8750        non_snake_case,
8751        clippy::pub_underscore_fields,
8752        clippy::style
8753    )]
8754    const _: () = {
8755        use alloy::sol_types as alloy_sol_types;
8756        {
8757            #[doc(hidden)]
8758            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8759            #[doc(hidden)]
8760            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
8761            #[cfg(test)]
8762            #[allow(dead_code, unreachable_patterns)]
8763            fn _type_assertion(
8764                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8765            ) {
8766                match _t {
8767                    alloy_sol_types::private::AssertTypeEq::<
8768                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8769                    >(_) => {}
8770                }
8771            }
8772            #[automatically_derived]
8773            #[doc(hidden)]
8774            impl ::core::convert::From<withdrawRewardsCall> for UnderlyingRustTuple<'_> {
8775                fn from(value: withdrawRewardsCall) -> Self {
8776                    (value.onchainWorkerId,)
8777                }
8778            }
8779            #[automatically_derived]
8780            #[doc(hidden)]
8781            impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawRewardsCall {
8782                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8783                    Self { onchainWorkerId: tuple.0 }
8784                }
8785            }
8786        }
8787        {
8788            #[doc(hidden)]
8789            type UnderlyingSolTuple<'a> = ();
8790            #[doc(hidden)]
8791            type UnderlyingRustTuple<'a> = ();
8792            #[cfg(test)]
8793            #[allow(dead_code, unreachable_patterns)]
8794            fn _type_assertion(
8795                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8796            ) {
8797                match _t {
8798                    alloy_sol_types::private::AssertTypeEq::<
8799                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8800                    >(_) => {}
8801                }
8802            }
8803            #[automatically_derived]
8804            #[doc(hidden)]
8805            impl ::core::convert::From<withdrawRewardsReturn>
8806            for UnderlyingRustTuple<'_> {
8807                fn from(value: withdrawRewardsReturn) -> Self {
8808                    ()
8809                }
8810            }
8811            #[automatically_derived]
8812            #[doc(hidden)]
8813            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8814            for withdrawRewardsReturn {
8815                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8816                    Self {}
8817                }
8818            }
8819        }
8820        #[automatically_derived]
8821        impl alloy_sol_types::SolCall for withdrawRewardsCall {
8822            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
8823            type Token<'a> = <Self::Parameters<
8824                'a,
8825            > as alloy_sol_types::SolType>::Token<'a>;
8826            type Return = withdrawRewardsReturn;
8827            type ReturnTuple<'a> = ();
8828            type ReturnToken<'a> = <Self::ReturnTuple<
8829                'a,
8830            > as alloy_sol_types::SolType>::Token<'a>;
8831            const SIGNATURE: &'static str = "withdrawRewards(bytes32)";
8832            const SELECTOR: [u8; 4] = [125u8, 251u8, 102u8, 38u8];
8833            #[inline]
8834            fn new<'a>(
8835                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8836            ) -> Self {
8837                tuple.into()
8838            }
8839            #[inline]
8840            fn tokenize(&self) -> Self::Token<'_> {
8841                (
8842                    <alloy::sol_types::sol_data::FixedBytes<
8843                        32,
8844                    > as alloy_sol_types::SolType>::tokenize(&self.onchainWorkerId),
8845                )
8846            }
8847            #[inline]
8848            fn abi_decode_returns(
8849                data: &[u8],
8850                validate: bool,
8851            ) -> alloy_sol_types::Result<Self::Return> {
8852                <Self::ReturnTuple<
8853                    '_,
8854                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
8855                    .map(Into::into)
8856            }
8857        }
8858    };
8859    ///Container for all the [`IDealV2`](self) function calls.
8860    pub enum IDealV2Calls {
8861        #[allow(missing_docs)]
8862        activateWorker(activateWorkerCall),
8863        #[allow(missing_docs)]
8864        addProviderToAccessList(addProviderToAccessListCall),
8865        #[allow(missing_docs)]
8866        addWorker(addWorkerCall),
8867        #[allow(missing_docs)]
8868        appCID(appCIDCall),
8869        #[allow(missing_docs)]
8870        changeProvidersAccessType(changeProvidersAccessTypeCall),
8871        #[allow(missing_docs)]
8872        computePeerUsed(computePeerUsedCall),
8873        #[allow(missing_docs)]
8874        creationBlock(creationBlockCall),
8875        #[allow(missing_docs)]
8876        depositFromOwner(depositFromOwnerCall),
8877        #[allow(missing_docs)]
8878        getActivatedWorkerCount(getActivatedWorkerCountCall),
8879        #[allow(missing_docs)]
8880        getFreeBalance(getFreeBalanceCall),
8881        #[allow(missing_docs)]
8882        getMaxPaidEpoch(getMaxPaidEpochCall),
8883        #[allow(missing_docs)]
8884        getProtocolVersion(getProtocolVersionCall),
8885        #[allow(missing_docs)]
8886        getRewardAmount(getRewardAmountCall),
8887        #[allow(missing_docs)]
8888        getStatus(getStatusCall),
8889        #[allow(missing_docs)]
8890        getWorkerCount_0(getWorkerCount_0Call),
8891        #[allow(missing_docs)]
8892        getWorkerCount_1(getWorkerCount_1Call),
8893        #[allow(missing_docs)]
8894        getWorkerIds(getWorkerIdsCall),
8895        #[allow(missing_docs)]
8896        initialize(initializeCall),
8897        #[allow(missing_docs)]
8898        isProviderAllowed(isProviderAllowedCall),
8899        #[allow(missing_docs)]
8900        maxWorkersPerProvider(maxWorkersPerProviderCall),
8901        #[allow(missing_docs)]
8902        paymentToken(paymentTokenCall),
8903        #[allow(missing_docs)]
8904        pricePerEpoch(pricePerEpochCall),
8905        #[allow(missing_docs)]
8906        providersAccessType(providersAccessTypeCall),
8907        #[allow(missing_docs)]
8908        removeProviderFromAccessList(removeProviderFromAccessListCall),
8909        #[allow(missing_docs)]
8910        removeStaleWorkers(removeStaleWorkersCall),
8911        #[allow(missing_docs)]
8912        removeWorker(removeWorkerCall),
8913        #[allow(missing_docs)]
8914        requiredResources(requiredResourcesCall),
8915        #[allow(missing_docs)]
8916        setAppCID(setAppCIDCall),
8917        #[allow(missing_docs)]
8918        stop(stopCall),
8919        #[allow(missing_docs)]
8920        targetWorkers(targetWorkersCall),
8921        #[allow(missing_docs)]
8922        withdraw(withdrawCall),
8923        #[allow(missing_docs)]
8924        withdrawRewards(withdrawRewardsCall),
8925    }
8926    #[automatically_derived]
8927    impl IDealV2Calls {
8928        /// All the selectors of this enum.
8929        ///
8930        /// Note that the selectors might not be in the same order as the variants.
8931        /// No guarantees are made about the order of the selectors.
8932        ///
8933        /// Prefer using `SolInterface` methods instead.
8934        pub const SELECTORS: &'static [[u8; 4usize]] = &[
8935            [7u8, 218u8, 104u8, 245u8],
8936            [23u8, 99u8, 69u8, 20u8],
8937            [23u8, 100u8, 116u8, 207u8],
8938            [26u8, 245u8, 123u8, 150u8],
8939            [34u8, 235u8, 213u8, 138u8],
8940            [41u8, 67u8, 220u8, 171u8],
8941            [46u8, 26u8, 125u8, 77u8],
8942            [48u8, 19u8, 206u8, 41u8],
8943            [51u8, 206u8, 147u8, 254u8],
8944            [55u8, 139u8, 34u8, 228u8],
8945            [62u8, 138u8, 225u8, 174u8],
8946            [68u8, 78u8, 106u8, 90u8],
8947            [77u8, 117u8, 153u8, 241u8],
8948            [78u8, 77u8, 122u8, 248u8],
8949            [78u8, 105u8, 213u8, 96u8],
8950            [89u8, 196u8, 175u8, 192u8],
8951            [95u8, 200u8, 245u8, 156u8],
8952            [99u8, 111u8, 206u8, 251u8],
8953            [115u8, 19u8, 76u8, 21u8],
8954            [125u8, 251u8, 102u8, 38u8],
8955            [132u8, 96u8, 132u8, 84u8],
8956            [138u8, 12u8, 114u8, 91u8],
8957            [155u8, 198u8, 104u8, 104u8],
8958            [173u8, 224u8, 162u8, 2u8],
8959            [188u8, 18u8, 111u8, 31u8],
8960            [189u8, 25u8, 38u8, 224u8],
8961            [203u8, 123u8, 136u8, 209u8],
8962            [206u8, 247u8, 76u8, 139u8],
8963            [212u8, 119u8, 63u8, 240u8],
8964            [233u8, 60u8, 79u8, 21u8],
8965            [237u8, 123u8, 118u8, 83u8],
8966            [242u8, 87u8, 76u8, 27u8],
8967        ];
8968    }
8969    #[automatically_derived]
8970    impl alloy_sol_types::SolInterface for IDealV2Calls {
8971        const NAME: &'static str = "IDealV2Calls";
8972        const MIN_DATA_LENGTH: usize = 0usize;
8973        const COUNT: usize = 32usize;
8974        #[inline]
8975        fn selector(&self) -> [u8; 4] {
8976            match self {
8977                Self::activateWorker(_) => {
8978                    <activateWorkerCall as alloy_sol_types::SolCall>::SELECTOR
8979                }
8980                Self::addProviderToAccessList(_) => {
8981                    <addProviderToAccessListCall as alloy_sol_types::SolCall>::SELECTOR
8982                }
8983                Self::addWorker(_) => {
8984                    <addWorkerCall as alloy_sol_types::SolCall>::SELECTOR
8985                }
8986                Self::appCID(_) => <appCIDCall as alloy_sol_types::SolCall>::SELECTOR,
8987                Self::changeProvidersAccessType(_) => {
8988                    <changeProvidersAccessTypeCall as alloy_sol_types::SolCall>::SELECTOR
8989                }
8990                Self::computePeerUsed(_) => {
8991                    <computePeerUsedCall as alloy_sol_types::SolCall>::SELECTOR
8992                }
8993                Self::creationBlock(_) => {
8994                    <creationBlockCall as alloy_sol_types::SolCall>::SELECTOR
8995                }
8996                Self::depositFromOwner(_) => {
8997                    <depositFromOwnerCall as alloy_sol_types::SolCall>::SELECTOR
8998                }
8999                Self::getActivatedWorkerCount(_) => {
9000                    <getActivatedWorkerCountCall as alloy_sol_types::SolCall>::SELECTOR
9001                }
9002                Self::getFreeBalance(_) => {
9003                    <getFreeBalanceCall as alloy_sol_types::SolCall>::SELECTOR
9004                }
9005                Self::getMaxPaidEpoch(_) => {
9006                    <getMaxPaidEpochCall as alloy_sol_types::SolCall>::SELECTOR
9007                }
9008                Self::getProtocolVersion(_) => {
9009                    <getProtocolVersionCall as alloy_sol_types::SolCall>::SELECTOR
9010                }
9011                Self::getRewardAmount(_) => {
9012                    <getRewardAmountCall as alloy_sol_types::SolCall>::SELECTOR
9013                }
9014                Self::getStatus(_) => {
9015                    <getStatusCall as alloy_sol_types::SolCall>::SELECTOR
9016                }
9017                Self::getWorkerCount_0(_) => {
9018                    <getWorkerCount_0Call as alloy_sol_types::SolCall>::SELECTOR
9019                }
9020                Self::getWorkerCount_1(_) => {
9021                    <getWorkerCount_1Call as alloy_sol_types::SolCall>::SELECTOR
9022                }
9023                Self::getWorkerIds(_) => {
9024                    <getWorkerIdsCall as alloy_sol_types::SolCall>::SELECTOR
9025                }
9026                Self::initialize(_) => {
9027                    <initializeCall as alloy_sol_types::SolCall>::SELECTOR
9028                }
9029                Self::isProviderAllowed(_) => {
9030                    <isProviderAllowedCall as alloy_sol_types::SolCall>::SELECTOR
9031                }
9032                Self::maxWorkersPerProvider(_) => {
9033                    <maxWorkersPerProviderCall as alloy_sol_types::SolCall>::SELECTOR
9034                }
9035                Self::paymentToken(_) => {
9036                    <paymentTokenCall as alloy_sol_types::SolCall>::SELECTOR
9037                }
9038                Self::pricePerEpoch(_) => {
9039                    <pricePerEpochCall as alloy_sol_types::SolCall>::SELECTOR
9040                }
9041                Self::providersAccessType(_) => {
9042                    <providersAccessTypeCall as alloy_sol_types::SolCall>::SELECTOR
9043                }
9044                Self::removeProviderFromAccessList(_) => {
9045                    <removeProviderFromAccessListCall as alloy_sol_types::SolCall>::SELECTOR
9046                }
9047                Self::removeStaleWorkers(_) => {
9048                    <removeStaleWorkersCall as alloy_sol_types::SolCall>::SELECTOR
9049                }
9050                Self::removeWorker(_) => {
9051                    <removeWorkerCall as alloy_sol_types::SolCall>::SELECTOR
9052                }
9053                Self::requiredResources(_) => {
9054                    <requiredResourcesCall as alloy_sol_types::SolCall>::SELECTOR
9055                }
9056                Self::setAppCID(_) => {
9057                    <setAppCIDCall as alloy_sol_types::SolCall>::SELECTOR
9058                }
9059                Self::stop(_) => <stopCall as alloy_sol_types::SolCall>::SELECTOR,
9060                Self::targetWorkers(_) => {
9061                    <targetWorkersCall as alloy_sol_types::SolCall>::SELECTOR
9062                }
9063                Self::withdraw(_) => <withdrawCall as alloy_sol_types::SolCall>::SELECTOR,
9064                Self::withdrawRewards(_) => {
9065                    <withdrawRewardsCall as alloy_sol_types::SolCall>::SELECTOR
9066                }
9067            }
9068        }
9069        #[inline]
9070        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
9071            Self::SELECTORS.get(i).copied()
9072        }
9073        #[inline]
9074        fn valid_selector(selector: [u8; 4]) -> bool {
9075            Self::SELECTORS.binary_search(&selector).is_ok()
9076        }
9077        #[inline]
9078        #[allow(non_snake_case)]
9079        fn abi_decode_raw(
9080            selector: [u8; 4],
9081            data: &[u8],
9082            validate: bool,
9083        ) -> alloy_sol_types::Result<Self> {
9084            static DECODE_SHIMS: &[fn(
9085                &[u8],
9086                bool,
9087            ) -> alloy_sol_types::Result<IDealV2Calls>] = &[
9088                {
9089                    fn stop(
9090                        data: &[u8],
9091                        validate: bool,
9092                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9093                        <stopCall as alloy_sol_types::SolCall>::abi_decode_raw(
9094                                data,
9095                                validate,
9096                            )
9097                            .map(IDealV2Calls::stop)
9098                    }
9099                    stop
9100                },
9101                {
9102                    fn creationBlock(
9103                        data: &[u8],
9104                        validate: bool,
9105                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9106                        <creationBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
9107                                data,
9108                                validate,
9109                            )
9110                            .map(IDealV2Calls::creationBlock)
9111                    }
9112                    creationBlock
9113                },
9114                {
9115                    fn setAppCID(
9116                        data: &[u8],
9117                        validate: bool,
9118                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9119                        <setAppCIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
9120                                data,
9121                                validate,
9122                            )
9123                            .map(IDealV2Calls::setAppCID)
9124                    }
9125                    setAppCID
9126                },
9127                {
9128                    fn getRewardAmount(
9129                        data: &[u8],
9130                        validate: bool,
9131                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9132                        <getRewardAmountCall as alloy_sol_types::SolCall>::abi_decode_raw(
9133                                data,
9134                                validate,
9135                            )
9136                            .map(IDealV2Calls::getRewardAmount)
9137                    }
9138                    getRewardAmount
9139                },
9140                {
9141                    fn activateWorker(
9142                        data: &[u8],
9143                        validate: bool,
9144                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9145                        <activateWorkerCall as alloy_sol_types::SolCall>::abi_decode_raw(
9146                                data,
9147                                validate,
9148                            )
9149                            .map(IDealV2Calls::activateWorker)
9150                    }
9151                    activateWorker
9152                },
9153                {
9154                    fn targetWorkers(
9155                        data: &[u8],
9156                        validate: bool,
9157                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9158                        <targetWorkersCall as alloy_sol_types::SolCall>::abi_decode_raw(
9159                                data,
9160                                validate,
9161                            )
9162                            .map(IDealV2Calls::targetWorkers)
9163                    }
9164                    targetWorkers
9165                },
9166                {
9167                    fn withdraw(
9168                        data: &[u8],
9169                        validate: bool,
9170                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9171                        <withdrawCall as alloy_sol_types::SolCall>::abi_decode_raw(
9172                                data,
9173                                validate,
9174                            )
9175                            .map(IDealV2Calls::withdraw)
9176                    }
9177                    withdraw
9178                },
9179                {
9180                    fn paymentToken(
9181                        data: &[u8],
9182                        validate: bool,
9183                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9184                        <paymentTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
9185                                data,
9186                                validate,
9187                            )
9188                            .map(IDealV2Calls::paymentToken)
9189                    }
9190                    paymentToken
9191                },
9192                {
9193                    fn getProtocolVersion(
9194                        data: &[u8],
9195                        validate: bool,
9196                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9197                        <getProtocolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(
9198                                data,
9199                                validate,
9200                            )
9201                            .map(IDealV2Calls::getProtocolVersion)
9202                    }
9203                    getProtocolVersion
9204                },
9205                {
9206                    fn getMaxPaidEpoch(
9207                        data: &[u8],
9208                        validate: bool,
9209                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9210                        <getMaxPaidEpochCall as alloy_sol_types::SolCall>::abi_decode_raw(
9211                                data,
9212                                validate,
9213                            )
9214                            .map(IDealV2Calls::getMaxPaidEpoch)
9215                    }
9216                    getMaxPaidEpoch
9217                },
9218                {
9219                    fn isProviderAllowed(
9220                        data: &[u8],
9221                        validate: bool,
9222                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9223                        <isProviderAllowedCall as alloy_sol_types::SolCall>::abi_decode_raw(
9224                                data,
9225                                validate,
9226                            )
9227                            .map(IDealV2Calls::isProviderAllowed)
9228                    }
9229                    isProviderAllowed
9230                },
9231                {
9232                    fn removeProviderFromAccessList(
9233                        data: &[u8],
9234                        validate: bool,
9235                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9236                        <removeProviderFromAccessListCall as alloy_sol_types::SolCall>::abi_decode_raw(
9237                                data,
9238                                validate,
9239                            )
9240                            .map(IDealV2Calls::removeProviderFromAccessList)
9241                    }
9242                    removeProviderFromAccessList
9243                },
9244                {
9245                    fn getWorkerCount_0(
9246                        data: &[u8],
9247                        validate: bool,
9248                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9249                        <getWorkerCount_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
9250                                data,
9251                                validate,
9252                            )
9253                            .map(IDealV2Calls::getWorkerCount_0)
9254                    }
9255                    getWorkerCount_0
9256                },
9257                {
9258                    fn requiredResources(
9259                        data: &[u8],
9260                        validate: bool,
9261                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9262                        <requiredResourcesCall as alloy_sol_types::SolCall>::abi_decode_raw(
9263                                data,
9264                                validate,
9265                            )
9266                            .map(IDealV2Calls::requiredResources)
9267                    }
9268                    requiredResources
9269                },
9270                {
9271                    fn getStatus(
9272                        data: &[u8],
9273                        validate: bool,
9274                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9275                        <getStatusCall as alloy_sol_types::SolCall>::abi_decode_raw(
9276                                data,
9277                                validate,
9278                            )
9279                            .map(IDealV2Calls::getStatus)
9280                    }
9281                    getStatus
9282                },
9283                {
9284                    fn getWorkerCount_1(
9285                        data: &[u8],
9286                        validate: bool,
9287                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9288                        <getWorkerCount_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
9289                                data,
9290                                validate,
9291                            )
9292                            .map(IDealV2Calls::getWorkerCount_1)
9293                    }
9294                    getWorkerCount_1
9295                },
9296                {
9297                    fn pricePerEpoch(
9298                        data: &[u8],
9299                        validate: bool,
9300                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9301                        <pricePerEpochCall as alloy_sol_types::SolCall>::abi_decode_raw(
9302                                data,
9303                                validate,
9304                            )
9305                            .map(IDealV2Calls::pricePerEpoch)
9306                    }
9307                    pricePerEpoch
9308                },
9309                {
9310                    fn changeProvidersAccessType(
9311                        data: &[u8],
9312                        validate: bool,
9313                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9314                        <changeProvidersAccessTypeCall as alloy_sol_types::SolCall>::abi_decode_raw(
9315                                data,
9316                                validate,
9317                            )
9318                            .map(IDealV2Calls::changeProvidersAccessType)
9319                    }
9320                    changeProvidersAccessType
9321                },
9322                {
9323                    fn addProviderToAccessList(
9324                        data: &[u8],
9325                        validate: bool,
9326                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9327                        <addProviderToAccessListCall as alloy_sol_types::SolCall>::abi_decode_raw(
9328                                data,
9329                                validate,
9330                            )
9331                            .map(IDealV2Calls::addProviderToAccessList)
9332                    }
9333                    addProviderToAccessList
9334                },
9335                {
9336                    fn withdrawRewards(
9337                        data: &[u8],
9338                        validate: bool,
9339                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9340                        <withdrawRewardsCall as alloy_sol_types::SolCall>::abi_decode_raw(
9341                                data,
9342                                validate,
9343                            )
9344                            .map(IDealV2Calls::withdrawRewards)
9345                    }
9346                    withdrawRewards
9347                },
9348                {
9349                    fn initialize(
9350                        data: &[u8],
9351                        validate: bool,
9352                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9353                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
9354                                data,
9355                                validate,
9356                            )
9357                            .map(IDealV2Calls::initialize)
9358                    }
9359                    initialize
9360                },
9361                {
9362                    fn maxWorkersPerProvider(
9363                        data: &[u8],
9364                        validate: bool,
9365                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9366                        <maxWorkersPerProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
9367                                data,
9368                                validate,
9369                            )
9370                            .map(IDealV2Calls::maxWorkersPerProvider)
9371                    }
9372                    maxWorkersPerProvider
9373                },
9374                {
9375                    fn appCID(
9376                        data: &[u8],
9377                        validate: bool,
9378                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9379                        <appCIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
9380                                data,
9381                                validate,
9382                            )
9383                            .map(IDealV2Calls::appCID)
9384                    }
9385                    appCID
9386                },
9387                {
9388                    fn getActivatedWorkerCount(
9389                        data: &[u8],
9390                        validate: bool,
9391                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9392                        <getActivatedWorkerCountCall as alloy_sol_types::SolCall>::abi_decode_raw(
9393                                data,
9394                                validate,
9395                            )
9396                            .map(IDealV2Calls::getActivatedWorkerCount)
9397                    }
9398                    getActivatedWorkerCount
9399                },
9400                {
9401                    fn removeWorker(
9402                        data: &[u8],
9403                        validate: bool,
9404                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9405                        <removeWorkerCall as alloy_sol_types::SolCall>::abi_decode_raw(
9406                                data,
9407                                validate,
9408                            )
9409                            .map(IDealV2Calls::removeWorker)
9410                    }
9411                    removeWorker
9412                },
9413                {
9414                    fn computePeerUsed(
9415                        data: &[u8],
9416                        validate: bool,
9417                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9418                        <computePeerUsedCall as alloy_sol_types::SolCall>::abi_decode_raw(
9419                                data,
9420                                validate,
9421                            )
9422                            .map(IDealV2Calls::computePeerUsed)
9423                    }
9424                    computePeerUsed
9425                },
9426                {
9427                    fn removeStaleWorkers(
9428                        data: &[u8],
9429                        validate: bool,
9430                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9431                        <removeStaleWorkersCall as alloy_sol_types::SolCall>::abi_decode_raw(
9432                                data,
9433                                validate,
9434                            )
9435                            .map(IDealV2Calls::removeStaleWorkers)
9436                    }
9437                    removeStaleWorkers
9438                },
9439                {
9440                    fn addWorker(
9441                        data: &[u8],
9442                        validate: bool,
9443                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9444                        <addWorkerCall as alloy_sol_types::SolCall>::abi_decode_raw(
9445                                data,
9446                                validate,
9447                            )
9448                            .map(IDealV2Calls::addWorker)
9449                    }
9450                    addWorker
9451                },
9452                {
9453                    fn providersAccessType(
9454                        data: &[u8],
9455                        validate: bool,
9456                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9457                        <providersAccessTypeCall as alloy_sol_types::SolCall>::abi_decode_raw(
9458                                data,
9459                                validate,
9460                            )
9461                            .map(IDealV2Calls::providersAccessType)
9462                    }
9463                    providersAccessType
9464                },
9465                {
9466                    fn getFreeBalance(
9467                        data: &[u8],
9468                        validate: bool,
9469                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9470                        <getFreeBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw(
9471                                data,
9472                                validate,
9473                            )
9474                            .map(IDealV2Calls::getFreeBalance)
9475                    }
9476                    getFreeBalance
9477                },
9478                {
9479                    fn depositFromOwner(
9480                        data: &[u8],
9481                        validate: bool,
9482                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9483                        <depositFromOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(
9484                                data,
9485                                validate,
9486                            )
9487                            .map(IDealV2Calls::depositFromOwner)
9488                    }
9489                    depositFromOwner
9490                },
9491                {
9492                    fn getWorkerIds(
9493                        data: &[u8],
9494                        validate: bool,
9495                    ) -> alloy_sol_types::Result<IDealV2Calls> {
9496                        <getWorkerIdsCall as alloy_sol_types::SolCall>::abi_decode_raw(
9497                                data,
9498                                validate,
9499                            )
9500                            .map(IDealV2Calls::getWorkerIds)
9501                    }
9502                    getWorkerIds
9503                },
9504            ];
9505            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
9506                return Err(
9507                    alloy_sol_types::Error::unknown_selector(
9508                        <Self as alloy_sol_types::SolInterface>::NAME,
9509                        selector,
9510                    ),
9511                );
9512            };
9513            DECODE_SHIMS[idx](data, validate)
9514        }
9515        #[inline]
9516        fn abi_encoded_size(&self) -> usize {
9517            match self {
9518                Self::activateWorker(inner) => {
9519                    <activateWorkerCall as alloy_sol_types::SolCall>::abi_encoded_size(
9520                        inner,
9521                    )
9522                }
9523                Self::addProviderToAccessList(inner) => {
9524                    <addProviderToAccessListCall as alloy_sol_types::SolCall>::abi_encoded_size(
9525                        inner,
9526                    )
9527                }
9528                Self::addWorker(inner) => {
9529                    <addWorkerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
9530                }
9531                Self::appCID(inner) => {
9532                    <appCIDCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
9533                }
9534                Self::changeProvidersAccessType(inner) => {
9535                    <changeProvidersAccessTypeCall as alloy_sol_types::SolCall>::abi_encoded_size(
9536                        inner,
9537                    )
9538                }
9539                Self::computePeerUsed(inner) => {
9540                    <computePeerUsedCall as alloy_sol_types::SolCall>::abi_encoded_size(
9541                        inner,
9542                    )
9543                }
9544                Self::creationBlock(inner) => {
9545                    <creationBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
9546                        inner,
9547                    )
9548                }
9549                Self::depositFromOwner(inner) => {
9550                    <depositFromOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(
9551                        inner,
9552                    )
9553                }
9554                Self::getActivatedWorkerCount(inner) => {
9555                    <getActivatedWorkerCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
9556                        inner,
9557                    )
9558                }
9559                Self::getFreeBalance(inner) => {
9560                    <getFreeBalanceCall as alloy_sol_types::SolCall>::abi_encoded_size(
9561                        inner,
9562                    )
9563                }
9564                Self::getMaxPaidEpoch(inner) => {
9565                    <getMaxPaidEpochCall as alloy_sol_types::SolCall>::abi_encoded_size(
9566                        inner,
9567                    )
9568                }
9569                Self::getProtocolVersion(inner) => {
9570                    <getProtocolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
9571                        inner,
9572                    )
9573                }
9574                Self::getRewardAmount(inner) => {
9575                    <getRewardAmountCall as alloy_sol_types::SolCall>::abi_encoded_size(
9576                        inner,
9577                    )
9578                }
9579                Self::getStatus(inner) => {
9580                    <getStatusCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
9581                }
9582                Self::getWorkerCount_0(inner) => {
9583                    <getWorkerCount_0Call as alloy_sol_types::SolCall>::abi_encoded_size(
9584                        inner,
9585                    )
9586                }
9587                Self::getWorkerCount_1(inner) => {
9588                    <getWorkerCount_1Call as alloy_sol_types::SolCall>::abi_encoded_size(
9589                        inner,
9590                    )
9591                }
9592                Self::getWorkerIds(inner) => {
9593                    <getWorkerIdsCall as alloy_sol_types::SolCall>::abi_encoded_size(
9594                        inner,
9595                    )
9596                }
9597                Self::initialize(inner) => {
9598                    <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
9599                }
9600                Self::isProviderAllowed(inner) => {
9601                    <isProviderAllowedCall as alloy_sol_types::SolCall>::abi_encoded_size(
9602                        inner,
9603                    )
9604                }
9605                Self::maxWorkersPerProvider(inner) => {
9606                    <maxWorkersPerProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
9607                        inner,
9608                    )
9609                }
9610                Self::paymentToken(inner) => {
9611                    <paymentTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
9612                        inner,
9613                    )
9614                }
9615                Self::pricePerEpoch(inner) => {
9616                    <pricePerEpochCall as alloy_sol_types::SolCall>::abi_encoded_size(
9617                        inner,
9618                    )
9619                }
9620                Self::providersAccessType(inner) => {
9621                    <providersAccessTypeCall as alloy_sol_types::SolCall>::abi_encoded_size(
9622                        inner,
9623                    )
9624                }
9625                Self::removeProviderFromAccessList(inner) => {
9626                    <removeProviderFromAccessListCall as alloy_sol_types::SolCall>::abi_encoded_size(
9627                        inner,
9628                    )
9629                }
9630                Self::removeStaleWorkers(inner) => {
9631                    <removeStaleWorkersCall as alloy_sol_types::SolCall>::abi_encoded_size(
9632                        inner,
9633                    )
9634                }
9635                Self::removeWorker(inner) => {
9636                    <removeWorkerCall as alloy_sol_types::SolCall>::abi_encoded_size(
9637                        inner,
9638                    )
9639                }
9640                Self::requiredResources(inner) => {
9641                    <requiredResourcesCall as alloy_sol_types::SolCall>::abi_encoded_size(
9642                        inner,
9643                    )
9644                }
9645                Self::setAppCID(inner) => {
9646                    <setAppCIDCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
9647                }
9648                Self::stop(inner) => {
9649                    <stopCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
9650                }
9651                Self::targetWorkers(inner) => {
9652                    <targetWorkersCall as alloy_sol_types::SolCall>::abi_encoded_size(
9653                        inner,
9654                    )
9655                }
9656                Self::withdraw(inner) => {
9657                    <withdrawCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
9658                }
9659                Self::withdrawRewards(inner) => {
9660                    <withdrawRewardsCall as alloy_sol_types::SolCall>::abi_encoded_size(
9661                        inner,
9662                    )
9663                }
9664            }
9665        }
9666        #[inline]
9667        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
9668            match self {
9669                Self::activateWorker(inner) => {
9670                    <activateWorkerCall as alloy_sol_types::SolCall>::abi_encode_raw(
9671                        inner,
9672                        out,
9673                    )
9674                }
9675                Self::addProviderToAccessList(inner) => {
9676                    <addProviderToAccessListCall as alloy_sol_types::SolCall>::abi_encode_raw(
9677                        inner,
9678                        out,
9679                    )
9680                }
9681                Self::addWorker(inner) => {
9682                    <addWorkerCall as alloy_sol_types::SolCall>::abi_encode_raw(
9683                        inner,
9684                        out,
9685                    )
9686                }
9687                Self::appCID(inner) => {
9688                    <appCIDCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
9689                }
9690                Self::changeProvidersAccessType(inner) => {
9691                    <changeProvidersAccessTypeCall as alloy_sol_types::SolCall>::abi_encode_raw(
9692                        inner,
9693                        out,
9694                    )
9695                }
9696                Self::computePeerUsed(inner) => {
9697                    <computePeerUsedCall as alloy_sol_types::SolCall>::abi_encode_raw(
9698                        inner,
9699                        out,
9700                    )
9701                }
9702                Self::creationBlock(inner) => {
9703                    <creationBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
9704                        inner,
9705                        out,
9706                    )
9707                }
9708                Self::depositFromOwner(inner) => {
9709                    <depositFromOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
9710                        inner,
9711                        out,
9712                    )
9713                }
9714                Self::getActivatedWorkerCount(inner) => {
9715                    <getActivatedWorkerCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
9716                        inner,
9717                        out,
9718                    )
9719                }
9720                Self::getFreeBalance(inner) => {
9721                    <getFreeBalanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
9722                        inner,
9723                        out,
9724                    )
9725                }
9726                Self::getMaxPaidEpoch(inner) => {
9727                    <getMaxPaidEpochCall as alloy_sol_types::SolCall>::abi_encode_raw(
9728                        inner,
9729                        out,
9730                    )
9731                }
9732                Self::getProtocolVersion(inner) => {
9733                    <getProtocolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
9734                        inner,
9735                        out,
9736                    )
9737                }
9738                Self::getRewardAmount(inner) => {
9739                    <getRewardAmountCall as alloy_sol_types::SolCall>::abi_encode_raw(
9740                        inner,
9741                        out,
9742                    )
9743                }
9744                Self::getStatus(inner) => {
9745                    <getStatusCall as alloy_sol_types::SolCall>::abi_encode_raw(
9746                        inner,
9747                        out,
9748                    )
9749                }
9750                Self::getWorkerCount_0(inner) => {
9751                    <getWorkerCount_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
9752                        inner,
9753                        out,
9754                    )
9755                }
9756                Self::getWorkerCount_1(inner) => {
9757                    <getWorkerCount_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
9758                        inner,
9759                        out,
9760                    )
9761                }
9762                Self::getWorkerIds(inner) => {
9763                    <getWorkerIdsCall as alloy_sol_types::SolCall>::abi_encode_raw(
9764                        inner,
9765                        out,
9766                    )
9767                }
9768                Self::initialize(inner) => {
9769                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
9770                        inner,
9771                        out,
9772                    )
9773                }
9774                Self::isProviderAllowed(inner) => {
9775                    <isProviderAllowedCall as alloy_sol_types::SolCall>::abi_encode_raw(
9776                        inner,
9777                        out,
9778                    )
9779                }
9780                Self::maxWorkersPerProvider(inner) => {
9781                    <maxWorkersPerProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
9782                        inner,
9783                        out,
9784                    )
9785                }
9786                Self::paymentToken(inner) => {
9787                    <paymentTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
9788                        inner,
9789                        out,
9790                    )
9791                }
9792                Self::pricePerEpoch(inner) => {
9793                    <pricePerEpochCall as alloy_sol_types::SolCall>::abi_encode_raw(
9794                        inner,
9795                        out,
9796                    )
9797                }
9798                Self::providersAccessType(inner) => {
9799                    <providersAccessTypeCall as alloy_sol_types::SolCall>::abi_encode_raw(
9800                        inner,
9801                        out,
9802                    )
9803                }
9804                Self::removeProviderFromAccessList(inner) => {
9805                    <removeProviderFromAccessListCall as alloy_sol_types::SolCall>::abi_encode_raw(
9806                        inner,
9807                        out,
9808                    )
9809                }
9810                Self::removeStaleWorkers(inner) => {
9811                    <removeStaleWorkersCall as alloy_sol_types::SolCall>::abi_encode_raw(
9812                        inner,
9813                        out,
9814                    )
9815                }
9816                Self::removeWorker(inner) => {
9817                    <removeWorkerCall as alloy_sol_types::SolCall>::abi_encode_raw(
9818                        inner,
9819                        out,
9820                    )
9821                }
9822                Self::requiredResources(inner) => {
9823                    <requiredResourcesCall as alloy_sol_types::SolCall>::abi_encode_raw(
9824                        inner,
9825                        out,
9826                    )
9827                }
9828                Self::setAppCID(inner) => {
9829                    <setAppCIDCall as alloy_sol_types::SolCall>::abi_encode_raw(
9830                        inner,
9831                        out,
9832                    )
9833                }
9834                Self::stop(inner) => {
9835                    <stopCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
9836                }
9837                Self::targetWorkers(inner) => {
9838                    <targetWorkersCall as alloy_sol_types::SolCall>::abi_encode_raw(
9839                        inner,
9840                        out,
9841                    )
9842                }
9843                Self::withdraw(inner) => {
9844                    <withdrawCall as alloy_sol_types::SolCall>::abi_encode_raw(
9845                        inner,
9846                        out,
9847                    )
9848                }
9849                Self::withdrawRewards(inner) => {
9850                    <withdrawRewardsCall as alloy_sol_types::SolCall>::abi_encode_raw(
9851                        inner,
9852                        out,
9853                    )
9854                }
9855            }
9856        }
9857    }
9858    ///Container for all the [`IDealV2`](self) events.
9859    pub enum IDealV2Events {
9860        #[allow(missing_docs)]
9861        AppCIDChanged(AppCIDChanged),
9862        #[allow(missing_docs)]
9863        DealEnded(DealEnded),
9864        #[allow(missing_docs)]
9865        Deposited(Deposited),
9866        #[allow(missing_docs)]
9867        MaxPaidEpochUpdated(MaxPaidEpochUpdated),
9868        #[allow(missing_docs)]
9869        ProviderAddedToAccessList(ProviderAddedToAccessList),
9870        #[allow(missing_docs)]
9871        ProviderRemovedFromAccessList(ProviderRemovedFromAccessList),
9872        #[allow(missing_docs)]
9873        ProvidersAccessTypeChanged(ProvidersAccessTypeChanged),
9874        #[allow(missing_docs)]
9875        RewardWithdrawn(RewardWithdrawn),
9876        #[allow(missing_docs)]
9877        Withdrawn(Withdrawn),
9878        #[allow(missing_docs)]
9879        WorkerIdUpdated(WorkerIdUpdated),
9880        #[allow(missing_docs)]
9881        WorkerJoined(WorkerJoined),
9882        #[allow(missing_docs)]
9883        WorkerRemoved(WorkerRemoved),
9884    }
9885    #[automatically_derived]
9886    impl IDealV2Events {
9887        /// All the selectors of this enum.
9888        ///
9889        /// Note that the selectors might not be in the same order as the variants.
9890        /// No guarantees are made about the order of the selectors.
9891        ///
9892        /// Prefer using `SolInterface` methods instead.
9893        pub const SELECTORS: &'static [[u8; 32usize]] = &[
9894            [
9895                31u8,
9896                90u8,
9897                37u8,
9898                20u8,
9899                40u8,
9900                247u8,
9901                99u8,
9902                53u8,
9903                168u8,
9904                53u8,
9905                252u8,
9906                174u8,
9907                148u8,
9908                171u8,
9909                106u8,
9910                155u8,
9911                207u8,
9912                9u8,
9913                172u8,
9914                51u8,
9915                189u8,
9916                60u8,
9917                120u8,
9918                46u8,
9919                182u8,
9920                168u8,
9921                27u8,
9922                223u8,
9923                135u8,
9924                138u8,
9925                115u8,
9926                147u8,
9927            ],
9928            [
9929                41u8,
9930                49u8,
9931                248u8,
9932                151u8,
9933                92u8,
9934                12u8,
9935                227u8,
9936                205u8,
9937                248u8,
9938                235u8,
9939                224u8,
9940                202u8,
9941                195u8,
9942                111u8,
9943                6u8,
9944                4u8,
9945                135u8,
9946                54u8,
9947                212u8,
9948                109u8,
9949                109u8,
9950                246u8,
9951                106u8,
9952                194u8,
9953                28u8,
9954                254u8,
9955                113u8,
9956                123u8,
9957                158u8,
9958                231u8,
9959                16u8,
9960                6u8,
9961            ],
9962            [
9963                42u8,
9964                137u8,
9965                178u8,
9966                227u8,
9967                213u8,
9968                128u8,
9969                57u8,
9970                141u8,
9971                109u8,
9972                194u8,
9973                219u8,
9974                94u8,
9975                15u8,
9976                51u8,
9977                107u8,
9978                82u8,
9979                96u8,
9980                43u8,
9981                186u8,
9982                165u8,
9983                26u8,
9984                250u8,
9985                155u8,
9986                181u8,
9987                205u8,
9988                245u8,
9989                146u8,
9990                57u8,
9991                207u8,
9992                13u8,
9993                43u8,
9994                234u8,
9995            ],
9996            [
9997                56u8,
9998                251u8,
9999                8u8,
10000                26u8,
10001                11u8,
10002                72u8,
10003                68u8,
10004                6u8,
10005                151u8,
10006                123u8,
10007                217u8,
10008                79u8,
10009                248u8,
10010                237u8,
10011                183u8,
10012                155u8,
10013                228u8,
10014                75u8,
10015                92u8,
10016                165u8,
10017                20u8,
10018                19u8,
10019                3u8,
10020                97u8,
10021                24u8,
10022                37u8,
10023                22u8,
10024                179u8,
10025                158u8,
10026                44u8,
10027                69u8,
10028                40u8,
10029            ],
10030            [
10031                58u8,
10032                209u8,
10033                107u8,
10034                181u8,
10035                135u8,
10036                18u8,
10037                170u8,
10038                50u8,
10039                153u8,
10040                72u8,
10041                215u8,
10042                97u8,
10043                70u8,
10044                176u8,
10045                150u8,
10046                164u8,
10047                244u8,
10048                184u8,
10049                94u8,
10050                2u8,
10051                77u8,
10052                153u8,
10053                71u8,
10054                61u8,
10055                197u8,
10056                11u8,
10057                205u8,
10058                53u8,
10059                136u8,
10060                17u8,
10061                184u8,
10062                108u8,
10063            ],
10064            [
10065                67u8,
10066                6u8,
10067                72u8,
10068                222u8,
10069                23u8,
10070                49u8,
10071                87u8,
10072                224u8,
10073                105u8,
10074                32u8,
10075                28u8,
10076                148u8,
10077                58u8,
10078                219u8,
10079                45u8,
10080                78u8,
10081                52u8,
10082                14u8,
10083                124u8,
10084                245u8,
10085                178u8,
10086                123u8,
10087                27u8,
10088                9u8,
10089                201u8,
10090                203u8,
10091                133u8,
10092                47u8,
10093                3u8,
10094                214u8,
10095                59u8,
10096                86u8,
10097            ],
10098            [
10099                76u8,
10100                38u8,
10101                228u8,
10102                222u8,
10103                105u8,
10104                30u8,
10105                38u8,
10106                91u8,
10107                230u8,
10108                207u8,
10109                3u8,
10110                230u8,
10111                57u8,
10112                117u8,
10113                72u8,
10114                57u8,
10115                144u8,
10116                123u8,
10117                247u8,
10118                70u8,
10119                135u8,
10120                205u8,
10121                82u8,
10122                74u8,
10123                103u8,
10124                52u8,
10125                133u8,
10126                19u8,
10127                49u8,
10128                82u8,
10129                127u8,
10130                253u8,
10131            ],
10132            [
10133                156u8,
10134                213u8,
10135                124u8,
10136                250u8,
10137                46u8,
10138                18u8,
10139                163u8,
10140                114u8,
10141                21u8,
10142                202u8,
10143                188u8,
10144                104u8,
10145                151u8,
10146                57u8,
10147                109u8,
10148                178u8,
10149                101u8,
10150                65u8,
10151                155u8,
10152                215u8,
10153                240u8,
10154                106u8,
10155                218u8,
10156                208u8,
10157                98u8,
10158                39u8,
10159                162u8,
10160                177u8,
10161                99u8,
10162                236u8,
10163                214u8,
10164                163u8,
10165            ],
10166            [
10167                197u8,
10168                18u8,
10169                249u8,
10170                208u8,
10171                187u8,
10172                38u8,
10173                39u8,
10174                9u8,
10175                100u8,
10176                145u8,
10177                241u8,
10178                7u8,
10179                74u8,
10180                244u8,
10181                42u8,
10182                80u8,
10183                50u8,
10184                254u8,
10185                54u8,
10186                239u8,
10187                93u8,
10188                202u8,
10189                231u8,
10190                194u8,
10191                22u8,
10192                207u8,
10193                195u8,
10194                79u8,
10195                110u8,
10196                164u8,
10197                116u8,
10198                214u8,
10199            ],
10200            [
10201                200u8,
10202                32u8,
10203                166u8,
10204                109u8,
10205                59u8,
10206                221u8,
10207                80u8,
10208                164u8,
10209                92u8,
10210                241u8,
10211                44u8,
10212                218u8,
10213                109u8,
10214                200u8,
10215                236u8,
10216                158u8,
10217                148u8,
10218                251u8,
10219                81u8,
10220                35u8,
10221                237u8,
10222                215u8,
10223                218u8,
10224                115u8,
10225                110u8,
10226                234u8,
10227                24u8,
10228                49u8,
10229                111u8,
10230                133u8,
10231                35u8,
10232                160u8,
10233            ],
10234            [
10235                206u8,
10236                205u8,
10237                52u8,
10238                157u8,
10239                152u8,
10240                102u8,
10241                69u8,
10242                225u8,
10243                117u8,
10244                142u8,
10245                193u8,
10246                53u8,
10247                249u8,
10248                31u8,
10249                26u8,
10250                210u8,
10251                5u8,
10252                100u8,
10253                168u8,
10254                188u8,
10255                198u8,
10256                194u8,
10257                181u8,
10258                165u8,
10259                234u8,
10260                202u8,
10261                155u8,
10262                9u8,
10263                132u8,
10264                20u8,
10265                149u8,
10266                197u8,
10267            ],
10268            [
10269                207u8,
10270                121u8,
10271                224u8,
10272                226u8,
10273                124u8,
10274                140u8,
10275                53u8,
10276                211u8,
10277                155u8,
10278                217u8,
10279                183u8,
10280                39u8,
10281                243u8,
10282                94u8,
10283                111u8,
10284                121u8,
10285                87u8,
10286                53u8,
10287                151u8,
10288                246u8,
10289                96u8,
10290                200u8,
10291                139u8,
10292                175u8,
10293                72u8,
10294                63u8,
10295                193u8,
10296                81u8,
10297                28u8,
10298                73u8,
10299                32u8,
10300                60u8,
10301            ],
10302        ];
10303    }
10304    #[automatically_derived]
10305    impl alloy_sol_types::SolEventInterface for IDealV2Events {
10306        const NAME: &'static str = "IDealV2Events";
10307        const COUNT: usize = 12usize;
10308        fn decode_raw_log(
10309            topics: &[alloy_sol_types::Word],
10310            data: &[u8],
10311            validate: bool,
10312        ) -> alloy_sol_types::Result<Self> {
10313            match topics.first().copied() {
10314                Some(<AppCIDChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
10315                    <AppCIDChanged as alloy_sol_types::SolEvent>::decode_raw_log(
10316                            topics,
10317                            data,
10318                            validate,
10319                        )
10320                        .map(Self::AppCIDChanged)
10321                }
10322                Some(<DealEnded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
10323                    <DealEnded as alloy_sol_types::SolEvent>::decode_raw_log(
10324                            topics,
10325                            data,
10326                            validate,
10327                        )
10328                        .map(Self::DealEnded)
10329                }
10330                Some(<Deposited as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
10331                    <Deposited as alloy_sol_types::SolEvent>::decode_raw_log(
10332                            topics,
10333                            data,
10334                            validate,
10335                        )
10336                        .map(Self::Deposited)
10337                }
10338                Some(
10339                    <MaxPaidEpochUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
10340                ) => {
10341                    <MaxPaidEpochUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
10342                            topics,
10343                            data,
10344                            validate,
10345                        )
10346                        .map(Self::MaxPaidEpochUpdated)
10347                }
10348                Some(
10349                    <ProviderAddedToAccessList as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
10350                ) => {
10351                    <ProviderAddedToAccessList as alloy_sol_types::SolEvent>::decode_raw_log(
10352                            topics,
10353                            data,
10354                            validate,
10355                        )
10356                        .map(Self::ProviderAddedToAccessList)
10357                }
10358                Some(
10359                    <ProviderRemovedFromAccessList as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
10360                ) => {
10361                    <ProviderRemovedFromAccessList as alloy_sol_types::SolEvent>::decode_raw_log(
10362                            topics,
10363                            data,
10364                            validate,
10365                        )
10366                        .map(Self::ProviderRemovedFromAccessList)
10367                }
10368                Some(
10369                    <ProvidersAccessTypeChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
10370                ) => {
10371                    <ProvidersAccessTypeChanged as alloy_sol_types::SolEvent>::decode_raw_log(
10372                            topics,
10373                            data,
10374                            validate,
10375                        )
10376                        .map(Self::ProvidersAccessTypeChanged)
10377                }
10378                Some(<RewardWithdrawn as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
10379                    <RewardWithdrawn as alloy_sol_types::SolEvent>::decode_raw_log(
10380                            topics,
10381                            data,
10382                            validate,
10383                        )
10384                        .map(Self::RewardWithdrawn)
10385                }
10386                Some(<Withdrawn as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
10387                    <Withdrawn as alloy_sol_types::SolEvent>::decode_raw_log(
10388                            topics,
10389                            data,
10390                            validate,
10391                        )
10392                        .map(Self::Withdrawn)
10393                }
10394                Some(<WorkerIdUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
10395                    <WorkerIdUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
10396                            topics,
10397                            data,
10398                            validate,
10399                        )
10400                        .map(Self::WorkerIdUpdated)
10401                }
10402                Some(<WorkerJoined as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
10403                    <WorkerJoined as alloy_sol_types::SolEvent>::decode_raw_log(
10404                            topics,
10405                            data,
10406                            validate,
10407                        )
10408                        .map(Self::WorkerJoined)
10409                }
10410                Some(<WorkerRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
10411                    <WorkerRemoved as alloy_sol_types::SolEvent>::decode_raw_log(
10412                            topics,
10413                            data,
10414                            validate,
10415                        )
10416                        .map(Self::WorkerRemoved)
10417                }
10418                _ => {
10419                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
10420                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
10421                        log: alloy_sol_types::private::Box::new(
10422                            alloy_sol_types::private::LogData::new_unchecked(
10423                                topics.to_vec(),
10424                                data.to_vec().into(),
10425                            ),
10426                        ),
10427                    })
10428                }
10429            }
10430        }
10431    }
10432    #[automatically_derived]
10433    impl alloy_sol_types::private::IntoLogData for IDealV2Events {
10434        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
10435            match self {
10436                Self::AppCIDChanged(inner) => {
10437                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10438                }
10439                Self::DealEnded(inner) => {
10440                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10441                }
10442                Self::Deposited(inner) => {
10443                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10444                }
10445                Self::MaxPaidEpochUpdated(inner) => {
10446                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10447                }
10448                Self::ProviderAddedToAccessList(inner) => {
10449                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10450                }
10451                Self::ProviderRemovedFromAccessList(inner) => {
10452                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10453                }
10454                Self::ProvidersAccessTypeChanged(inner) => {
10455                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10456                }
10457                Self::RewardWithdrawn(inner) => {
10458                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10459                }
10460                Self::Withdrawn(inner) => {
10461                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10462                }
10463                Self::WorkerIdUpdated(inner) => {
10464                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10465                }
10466                Self::WorkerJoined(inner) => {
10467                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10468                }
10469                Self::WorkerRemoved(inner) => {
10470                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
10471                }
10472            }
10473        }
10474        fn into_log_data(self) -> alloy_sol_types::private::LogData {
10475            match self {
10476                Self::AppCIDChanged(inner) => {
10477                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10478                }
10479                Self::DealEnded(inner) => {
10480                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10481                }
10482                Self::Deposited(inner) => {
10483                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10484                }
10485                Self::MaxPaidEpochUpdated(inner) => {
10486                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10487                }
10488                Self::ProviderAddedToAccessList(inner) => {
10489                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10490                }
10491                Self::ProviderRemovedFromAccessList(inner) => {
10492                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10493                }
10494                Self::ProvidersAccessTypeChanged(inner) => {
10495                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10496                }
10497                Self::RewardWithdrawn(inner) => {
10498                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10499                }
10500                Self::Withdrawn(inner) => {
10501                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10502                }
10503                Self::WorkerIdUpdated(inner) => {
10504                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10505                }
10506                Self::WorkerJoined(inner) => {
10507                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10508                }
10509                Self::WorkerRemoved(inner) => {
10510                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
10511                }
10512            }
10513        }
10514    }
10515    use alloy::contract as alloy_contract;
10516    /**Creates a new wrapper around an on-chain [`IDealV2`](self) contract instance.
10517
10518See the [wrapper's documentation](`IDealV2Instance`) for more details.*/
10519    #[inline]
10520    pub const fn new<
10521        T: alloy_contract::private::Transport + ::core::clone::Clone,
10522        P: alloy_contract::private::Provider<T, N>,
10523        N: alloy_contract::private::Network,
10524    >(
10525        address: alloy_sol_types::private::Address,
10526        provider: P,
10527    ) -> IDealV2Instance<T, P, N> {
10528        IDealV2Instance::<T, P, N>::new(address, provider)
10529    }
10530    /**Deploys this contract using the given `provider` and constructor arguments, if any.
10531
10532Returns a new instance of the contract, if the deployment was successful.
10533
10534For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
10535    #[inline]
10536    pub fn deploy<
10537        T: alloy_contract::private::Transport + ::core::clone::Clone,
10538        P: alloy_contract::private::Provider<T, N>,
10539        N: alloy_contract::private::Network,
10540    >(
10541        provider: P,
10542    ) -> impl ::core::future::Future<
10543        Output = alloy_contract::Result<IDealV2Instance<T, P, N>>,
10544    > {
10545        IDealV2Instance::<T, P, N>::deploy(provider)
10546    }
10547    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
10548and constructor arguments, if any.
10549
10550This is a simple wrapper around creating a `RawCallBuilder` with the data set to
10551the bytecode concatenated with the constructor's ABI-encoded arguments.*/
10552    #[inline]
10553    pub fn deploy_builder<
10554        T: alloy_contract::private::Transport + ::core::clone::Clone,
10555        P: alloy_contract::private::Provider<T, N>,
10556        N: alloy_contract::private::Network,
10557    >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
10558        IDealV2Instance::<T, P, N>::deploy_builder(provider)
10559    }
10560    /**A [`IDealV2`](self) instance.
10561
10562Contains type-safe methods for interacting with an on-chain instance of the
10563[`IDealV2`](self) contract located at a given `address`, using a given
10564provider `P`.
10565
10566If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
10567documentation on how to provide it), the `deploy` and `deploy_builder` methods can
10568be used to deploy a new instance of the contract.
10569
10570See the [module-level documentation](self) for all the available methods.*/
10571    #[derive(Clone)]
10572    pub struct IDealV2Instance<T, P, N = alloy_contract::private::Ethereum> {
10573        address: alloy_sol_types::private::Address,
10574        provider: P,
10575        _network_transport: ::core::marker::PhantomData<(N, T)>,
10576    }
10577    #[automatically_derived]
10578    impl<T, P, N> ::core::fmt::Debug for IDealV2Instance<T, P, N> {
10579        #[inline]
10580        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
10581            f.debug_tuple("IDealV2Instance").field(&self.address).finish()
10582        }
10583    }
10584    /// Instantiation and getters/setters.
10585    #[automatically_derived]
10586    impl<
10587        T: alloy_contract::private::Transport + ::core::clone::Clone,
10588        P: alloy_contract::private::Provider<T, N>,
10589        N: alloy_contract::private::Network,
10590    > IDealV2Instance<T, P, N> {
10591        /**Creates a new wrapper around an on-chain [`IDealV2`](self) contract instance.
10592
10593See the [wrapper's documentation](`IDealV2Instance`) for more details.*/
10594        #[inline]
10595        pub const fn new(
10596            address: alloy_sol_types::private::Address,
10597            provider: P,
10598        ) -> Self {
10599            Self {
10600                address,
10601                provider,
10602                _network_transport: ::core::marker::PhantomData,
10603            }
10604        }
10605        /**Deploys this contract using the given `provider` and constructor arguments, if any.
10606
10607Returns a new instance of the contract, if the deployment was successful.
10608
10609For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
10610        #[inline]
10611        pub async fn deploy(
10612            provider: P,
10613        ) -> alloy_contract::Result<IDealV2Instance<T, P, N>> {
10614            let call_builder = Self::deploy_builder(provider);
10615            let contract_address = call_builder.deploy().await?;
10616            Ok(Self::new(contract_address, call_builder.provider))
10617        }
10618        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
10619and constructor arguments, if any.
10620
10621This is a simple wrapper around creating a `RawCallBuilder` with the data set to
10622the bytecode concatenated with the constructor's ABI-encoded arguments.*/
10623        #[inline]
10624        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
10625            alloy_contract::RawCallBuilder::new_raw_deploy(
10626                provider,
10627                ::core::clone::Clone::clone(&BYTECODE),
10628            )
10629        }
10630        /// Returns a reference to the address.
10631        #[inline]
10632        pub const fn address(&self) -> &alloy_sol_types::private::Address {
10633            &self.address
10634        }
10635        /// Sets the address.
10636        #[inline]
10637        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
10638            self.address = address;
10639        }
10640        /// Sets the address and returns `self`.
10641        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
10642            self.set_address(address);
10643            self
10644        }
10645        /// Returns a reference to the provider.
10646        #[inline]
10647        pub const fn provider(&self) -> &P {
10648            &self.provider
10649        }
10650    }
10651    impl<T, P: ::core::clone::Clone, N> IDealV2Instance<T, &P, N> {
10652        /// Clones the provider and returns a new instance with the cloned provider.
10653        #[inline]
10654        pub fn with_cloned_provider(self) -> IDealV2Instance<T, P, N> {
10655            IDealV2Instance {
10656                address: self.address,
10657                provider: ::core::clone::Clone::clone(&self.provider),
10658                _network_transport: ::core::marker::PhantomData,
10659            }
10660        }
10661    }
10662    /// Function calls.
10663    #[automatically_derived]
10664    impl<
10665        T: alloy_contract::private::Transport + ::core::clone::Clone,
10666        P: alloy_contract::private::Provider<T, N>,
10667        N: alloy_contract::private::Network,
10668    > IDealV2Instance<T, P, N> {
10669        /// Creates a new call builder using this contract instance's provider and address.
10670        ///
10671        /// Note that the call can be any function call, not just those defined in this
10672        /// contract. Prefer using the other methods for building type-safe contract calls.
10673        pub fn call_builder<C: alloy_sol_types::SolCall>(
10674            &self,
10675            call: &C,
10676        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
10677            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
10678        }
10679        ///Creates a new call builder for the [`activateWorker`] function.
10680        pub fn activateWorker(
10681            &self,
10682            onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
10683            offchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
10684        ) -> alloy_contract::SolCallBuilder<T, &P, activateWorkerCall, N> {
10685            self.call_builder(
10686                &activateWorkerCall {
10687                    onchainWorkerId,
10688                    offchainWorkerId,
10689                },
10690            )
10691        }
10692        ///Creates a new call builder for the [`addProviderToAccessList`] function.
10693        pub fn addProviderToAccessList(
10694            &self,
10695            provider: alloy::sol_types::private::Address,
10696        ) -> alloy_contract::SolCallBuilder<T, &P, addProviderToAccessListCall, N> {
10697            self.call_builder(
10698                &addProviderToAccessListCall {
10699                    provider,
10700                },
10701            )
10702        }
10703        ///Creates a new call builder for the [`addWorker`] function.
10704        pub fn addWorker(
10705            &self,
10706            computeProvider: alloy::sol_types::private::Address,
10707            workerData: <IWorkerManagerV2::WorkerDataV2 as alloy::sol_types::SolType>::RustType,
10708            peerId: alloy::sol_types::private::FixedBytes<32>,
10709        ) -> alloy_contract::SolCallBuilder<T, &P, addWorkerCall, N> {
10710            self.call_builder(
10711                &addWorkerCall {
10712                    computeProvider,
10713                    workerData,
10714                    peerId,
10715                },
10716            )
10717        }
10718        ///Creates a new call builder for the [`appCID`] function.
10719        pub fn appCID(&self) -> alloy_contract::SolCallBuilder<T, &P, appCIDCall, N> {
10720            self.call_builder(&appCIDCall {})
10721        }
10722        ///Creates a new call builder for the [`changeProvidersAccessType`] function.
10723        pub fn changeProvidersAccessType(
10724            &self,
10725            accessType: <IConfigV2::AccessTypeV2 as alloy::sol_types::SolType>::RustType,
10726        ) -> alloy_contract::SolCallBuilder<T, &P, changeProvidersAccessTypeCall, N> {
10727            self.call_builder(
10728                &changeProvidersAccessTypeCall {
10729                    accessType,
10730                },
10731            )
10732        }
10733        ///Creates a new call builder for the [`computePeerUsed`] function.
10734        pub fn computePeerUsed(
10735            &self,
10736            peerId: alloy::sol_types::private::FixedBytes<32>,
10737        ) -> alloy_contract::SolCallBuilder<T, &P, computePeerUsedCall, N> {
10738            self.call_builder(&computePeerUsedCall { peerId })
10739        }
10740        ///Creates a new call builder for the [`creationBlock`] function.
10741        pub fn creationBlock(
10742            &self,
10743        ) -> alloy_contract::SolCallBuilder<T, &P, creationBlockCall, N> {
10744            self.call_builder(&creationBlockCall {})
10745        }
10746        ///Creates a new call builder for the [`depositFromOwner`] function.
10747        pub fn depositFromOwner(
10748            &self,
10749            amount: alloy::sol_types::private::primitives::aliases::U256,
10750            reason: <IBalanceKeeper::DealDepositReason as alloy::sol_types::SolType>::RustType,
10751        ) -> alloy_contract::SolCallBuilder<T, &P, depositFromOwnerCall, N> {
10752            self.call_builder(
10753                &depositFromOwnerCall {
10754                    amount,
10755                    reason,
10756                },
10757            )
10758        }
10759        ///Creates a new call builder for the [`getActivatedWorkerCount`] function.
10760        pub fn getActivatedWorkerCount(
10761            &self,
10762        ) -> alloy_contract::SolCallBuilder<T, &P, getActivatedWorkerCountCall, N> {
10763            self.call_builder(&getActivatedWorkerCountCall {})
10764        }
10765        ///Creates a new call builder for the [`getFreeBalance`] function.
10766        pub fn getFreeBalance(
10767            &self,
10768        ) -> alloy_contract::SolCallBuilder<T, &P, getFreeBalanceCall, N> {
10769            self.call_builder(&getFreeBalanceCall {})
10770        }
10771        ///Creates a new call builder for the [`getMaxPaidEpoch`] function.
10772        pub fn getMaxPaidEpoch(
10773            &self,
10774        ) -> alloy_contract::SolCallBuilder<T, &P, getMaxPaidEpochCall, N> {
10775            self.call_builder(&getMaxPaidEpochCall {})
10776        }
10777        ///Creates a new call builder for the [`getProtocolVersion`] function.
10778        pub fn getProtocolVersion(
10779            &self,
10780        ) -> alloy_contract::SolCallBuilder<T, &P, getProtocolVersionCall, N> {
10781            self.call_builder(&getProtocolVersionCall {})
10782        }
10783        ///Creates a new call builder for the [`getRewardAmount`] function.
10784        pub fn getRewardAmount(
10785            &self,
10786            onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
10787        ) -> alloy_contract::SolCallBuilder<T, &P, getRewardAmountCall, N> {
10788            self.call_builder(
10789                &getRewardAmountCall {
10790                    onchainWorkerId,
10791                },
10792            )
10793        }
10794        ///Creates a new call builder for the [`getStatus`] function.
10795        pub fn getStatus(
10796            &self,
10797        ) -> alloy_contract::SolCallBuilder<T, &P, getStatusCall, N> {
10798            self.call_builder(&getStatusCall {})
10799        }
10800        ///Creates a new call builder for the [`getWorkerCount_0`] function.
10801        pub fn getWorkerCount_0(
10802            &self,
10803        ) -> alloy_contract::SolCallBuilder<T, &P, getWorkerCount_0Call, N> {
10804            self.call_builder(&getWorkerCount_0Call {})
10805        }
10806        ///Creates a new call builder for the [`getWorkerCount_1`] function.
10807        pub fn getWorkerCount_1(
10808            &self,
10809            provider: alloy::sol_types::private::Address,
10810        ) -> alloy_contract::SolCallBuilder<T, &P, getWorkerCount_1Call, N> {
10811            self.call_builder(&getWorkerCount_1Call { provider })
10812        }
10813        ///Creates a new call builder for the [`getWorkerIds`] function.
10814        pub fn getWorkerIds(
10815            &self,
10816        ) -> alloy_contract::SolCallBuilder<T, &P, getWorkerIdsCall, N> {
10817            self.call_builder(&getWorkerIdsCall {})
10818        }
10819        ///Creates a new call builder for the [`initialize`] function.
10820        pub fn initialize(
10821            &self,
10822            diamond_: alloy::sol_types::private::Address,
10823            appCID_: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
10824            paymentToken_: alloy::sol_types::private::Address,
10825            targetWorkers_: alloy::sol_types::private::primitives::aliases::U256,
10826            resources_: alloy::sol_types::private::Vec<
10827                <IOfferV2::ResourceRequirement as alloy::sol_types::SolType>::RustType,
10828            >,
10829            pricePerEpoch_: alloy::sol_types::private::primitives::aliases::U256,
10830            maxWorkersPerProvider_: alloy::sol_types::private::primitives::aliases::U256,
10831            providersAccessType_: <IConfigV2::AccessTypeV2 as alloy::sol_types::SolType>::RustType,
10832            providersAccessList_: alloy::sol_types::private::Vec<
10833                alloy::sol_types::private::Address,
10834            >,
10835            protocolVersion_: alloy::sol_types::private::primitives::aliases::U256,
10836            owner_: alloy::sol_types::private::Address,
10837        ) -> alloy_contract::SolCallBuilder<T, &P, initializeCall, N> {
10838            self.call_builder(
10839                &initializeCall {
10840                    diamond_,
10841                    appCID_,
10842                    paymentToken_,
10843                    targetWorkers_,
10844                    resources_,
10845                    pricePerEpoch_,
10846                    maxWorkersPerProvider_,
10847                    providersAccessType_,
10848                    providersAccessList_,
10849                    protocolVersion_,
10850                    owner_,
10851                },
10852            )
10853        }
10854        ///Creates a new call builder for the [`isProviderAllowed`] function.
10855        pub fn isProviderAllowed(
10856            &self,
10857            account: alloy::sol_types::private::Address,
10858        ) -> alloy_contract::SolCallBuilder<T, &P, isProviderAllowedCall, N> {
10859            self.call_builder(&isProviderAllowedCall { account })
10860        }
10861        ///Creates a new call builder for the [`maxWorkersPerProvider`] function.
10862        pub fn maxWorkersPerProvider(
10863            &self,
10864        ) -> alloy_contract::SolCallBuilder<T, &P, maxWorkersPerProviderCall, N> {
10865            self.call_builder(&maxWorkersPerProviderCall {})
10866        }
10867        ///Creates a new call builder for the [`paymentToken`] function.
10868        pub fn paymentToken(
10869            &self,
10870        ) -> alloy_contract::SolCallBuilder<T, &P, paymentTokenCall, N> {
10871            self.call_builder(&paymentTokenCall {})
10872        }
10873        ///Creates a new call builder for the [`pricePerEpoch`] function.
10874        pub fn pricePerEpoch(
10875            &self,
10876        ) -> alloy_contract::SolCallBuilder<T, &P, pricePerEpochCall, N> {
10877            self.call_builder(&pricePerEpochCall {})
10878        }
10879        ///Creates a new call builder for the [`providersAccessType`] function.
10880        pub fn providersAccessType(
10881            &self,
10882        ) -> alloy_contract::SolCallBuilder<T, &P, providersAccessTypeCall, N> {
10883            self.call_builder(&providersAccessTypeCall {})
10884        }
10885        ///Creates a new call builder for the [`removeProviderFromAccessList`] function.
10886        pub fn removeProviderFromAccessList(
10887            &self,
10888            provider: alloy::sol_types::private::Address,
10889        ) -> alloy_contract::SolCallBuilder<T, &P, removeProviderFromAccessListCall, N> {
10890            self.call_builder(
10891                &removeProviderFromAccessListCall {
10892                    provider,
10893                },
10894            )
10895        }
10896        ///Creates a new call builder for the [`removeStaleWorkers`] function.
10897        pub fn removeStaleWorkers(
10898            &self,
10899            onchainWorkerIds: alloy::sol_types::private::Vec<
10900                alloy::sol_types::private::FixedBytes<32>,
10901            >,
10902        ) -> alloy_contract::SolCallBuilder<T, &P, removeStaleWorkersCall, N> {
10903            self.call_builder(
10904                &removeStaleWorkersCall {
10905                    onchainWorkerIds,
10906                },
10907            )
10908        }
10909        ///Creates a new call builder for the [`removeWorker`] function.
10910        pub fn removeWorker(
10911            &self,
10912            onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
10913        ) -> alloy_contract::SolCallBuilder<T, &P, removeWorkerCall, N> {
10914            self.call_builder(
10915                &removeWorkerCall {
10916                    onchainWorkerId,
10917                },
10918            )
10919        }
10920        ///Creates a new call builder for the [`requiredResources`] function.
10921        pub fn requiredResources(
10922            &self,
10923        ) -> alloy_contract::SolCallBuilder<T, &P, requiredResourcesCall, N> {
10924            self.call_builder(&requiredResourcesCall {})
10925        }
10926        ///Creates a new call builder for the [`setAppCID`] function.
10927        pub fn setAppCID(
10928            &self,
10929            appCID_: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
10930        ) -> alloy_contract::SolCallBuilder<T, &P, setAppCIDCall, N> {
10931            self.call_builder(&setAppCIDCall { appCID_ })
10932        }
10933        ///Creates a new call builder for the [`stop`] function.
10934        pub fn stop(&self) -> alloy_contract::SolCallBuilder<T, &P, stopCall, N> {
10935            self.call_builder(&stopCall {})
10936        }
10937        ///Creates a new call builder for the [`targetWorkers`] function.
10938        pub fn targetWorkers(
10939            &self,
10940        ) -> alloy_contract::SolCallBuilder<T, &P, targetWorkersCall, N> {
10941            self.call_builder(&targetWorkersCall {})
10942        }
10943        ///Creates a new call builder for the [`withdraw`] function.
10944        pub fn withdraw(
10945            &self,
10946            amount: alloy::sol_types::private::primitives::aliases::U256,
10947        ) -> alloy_contract::SolCallBuilder<T, &P, withdrawCall, N> {
10948            self.call_builder(&withdrawCall { amount })
10949        }
10950        ///Creates a new call builder for the [`withdrawRewards`] function.
10951        pub fn withdrawRewards(
10952            &self,
10953            onchainWorkerId: alloy::sol_types::private::FixedBytes<32>,
10954        ) -> alloy_contract::SolCallBuilder<T, &P, withdrawRewardsCall, N> {
10955            self.call_builder(
10956                &withdrawRewardsCall {
10957                    onchainWorkerId,
10958                },
10959            )
10960        }
10961    }
10962    /// Event filters.
10963    #[automatically_derived]
10964    impl<
10965        T: alloy_contract::private::Transport + ::core::clone::Clone,
10966        P: alloy_contract::private::Provider<T, N>,
10967        N: alloy_contract::private::Network,
10968    > IDealV2Instance<T, P, N> {
10969        /// Creates a new event filter using this contract instance's provider and address.
10970        ///
10971        /// Note that the type can be any event, not just those defined in this contract.
10972        /// Prefer using the other methods for building type-safe event filters.
10973        pub fn event_filter<E: alloy_sol_types::SolEvent>(
10974            &self,
10975        ) -> alloy_contract::Event<T, &P, E, N> {
10976            alloy_contract::Event::new_sol(&self.provider, &self.address)
10977        }
10978        ///Creates a new event filter for the [`AppCIDChanged`] event.
10979        pub fn AppCIDChanged_filter(
10980            &self,
10981        ) -> alloy_contract::Event<T, &P, AppCIDChanged, N> {
10982            self.event_filter::<AppCIDChanged>()
10983        }
10984        ///Creates a new event filter for the [`DealEnded`] event.
10985        pub fn DealEnded_filter(&self) -> alloy_contract::Event<T, &P, DealEnded, N> {
10986            self.event_filter::<DealEnded>()
10987        }
10988        ///Creates a new event filter for the [`Deposited`] event.
10989        pub fn Deposited_filter(&self) -> alloy_contract::Event<T, &P, Deposited, N> {
10990            self.event_filter::<Deposited>()
10991        }
10992        ///Creates a new event filter for the [`MaxPaidEpochUpdated`] event.
10993        pub fn MaxPaidEpochUpdated_filter(
10994            &self,
10995        ) -> alloy_contract::Event<T, &P, MaxPaidEpochUpdated, N> {
10996            self.event_filter::<MaxPaidEpochUpdated>()
10997        }
10998        ///Creates a new event filter for the [`ProviderAddedToAccessList`] event.
10999        pub fn ProviderAddedToAccessList_filter(
11000            &self,
11001        ) -> alloy_contract::Event<T, &P, ProviderAddedToAccessList, N> {
11002            self.event_filter::<ProviderAddedToAccessList>()
11003        }
11004        ///Creates a new event filter for the [`ProviderRemovedFromAccessList`] event.
11005        pub fn ProviderRemovedFromAccessList_filter(
11006            &self,
11007        ) -> alloy_contract::Event<T, &P, ProviderRemovedFromAccessList, N> {
11008            self.event_filter::<ProviderRemovedFromAccessList>()
11009        }
11010        ///Creates a new event filter for the [`ProvidersAccessTypeChanged`] event.
11011        pub fn ProvidersAccessTypeChanged_filter(
11012            &self,
11013        ) -> alloy_contract::Event<T, &P, ProvidersAccessTypeChanged, N> {
11014            self.event_filter::<ProvidersAccessTypeChanged>()
11015        }
11016        ///Creates a new event filter for the [`RewardWithdrawn`] event.
11017        pub fn RewardWithdrawn_filter(
11018            &self,
11019        ) -> alloy_contract::Event<T, &P, RewardWithdrawn, N> {
11020            self.event_filter::<RewardWithdrawn>()
11021        }
11022        ///Creates a new event filter for the [`Withdrawn`] event.
11023        pub fn Withdrawn_filter(&self) -> alloy_contract::Event<T, &P, Withdrawn, N> {
11024            self.event_filter::<Withdrawn>()
11025        }
11026        ///Creates a new event filter for the [`WorkerIdUpdated`] event.
11027        pub fn WorkerIdUpdated_filter(
11028            &self,
11029        ) -> alloy_contract::Event<T, &P, WorkerIdUpdated, N> {
11030            self.event_filter::<WorkerIdUpdated>()
11031        }
11032        ///Creates a new event filter for the [`WorkerJoined`] event.
11033        pub fn WorkerJoined_filter(
11034            &self,
11035        ) -> alloy_contract::Event<T, &P, WorkerJoined, N> {
11036            self.event_filter::<WorkerJoined>()
11037        }
11038        ///Creates a new event filter for the [`WorkerRemoved`] event.
11039        pub fn WorkerRemoved_filter(
11040            &self,
11041        ) -> alloy_contract::Event<T, &P, WorkerRemoved, N> {
11042            self.event_filter::<WorkerRemoved>()
11043        }
11044    }
11045}
fluence_marketplace_api_draft/idealv2.rs

fluence_marketplace_api_draft/
idealv2.rs
