hotshot_contract_adapter/bindings/
i_reward_claim.rs

1/**
2
3Generated by the following Solidity interface...
4```solidity
5interface IRewardClaim {
6    error AlreadyClaimed();
7    error DailyLimitExceeded();
8    error InvalidAuthRoot();
9    error InvalidRewardAmount();
10
11    event RewardsClaimed(address indexed user, uint256 amount);
12
13    function claimRewards(uint256 lifetimeRewards, bytes memory authData) external;
14    function claimedRewards(address claimer) external view returns (uint256);
15    function totalClaimed() external view returns (uint256);
16}
17```
18
19...which was generated by the following JSON ABI:
20```json
21[
22  {
23    "type": "function",
24    "name": "claimRewards",
25    "inputs": [
26      {
27        "name": "lifetimeRewards",
28        "type": "uint256",
29        "internalType": "uint256"
30      },
31      {
32        "name": "authData",
33        "type": "bytes",
34        "internalType": "bytes"
35      }
36    ],
37    "outputs": [],
38    "stateMutability": "nonpayable"
39  },
40  {
41    "type": "function",
42    "name": "claimedRewards",
43    "inputs": [
44      {
45        "name": "claimer",
46        "type": "address",
47        "internalType": "address"
48      }
49    ],
50    "outputs": [
51      {
52        "name": "",
53        "type": "uint256",
54        "internalType": "uint256"
55      }
56    ],
57    "stateMutability": "view"
58  },
59  {
60    "type": "function",
61    "name": "totalClaimed",
62    "inputs": [],
63    "outputs": [
64      {
65        "name": "",
66        "type": "uint256",
67        "internalType": "uint256"
68      }
69    ],
70    "stateMutability": "view"
71  },
72  {
73    "type": "event",
74    "name": "RewardsClaimed",
75    "inputs": [
76      {
77        "name": "user",
78        "type": "address",
79        "indexed": true,
80        "internalType": "address"
81      },
82      {
83        "name": "amount",
84        "type": "uint256",
85        "indexed": false,
86        "internalType": "uint256"
87      }
88    ],
89    "anonymous": false
90  },
91  {
92    "type": "error",
93    "name": "AlreadyClaimed",
94    "inputs": []
95  },
96  {
97    "type": "error",
98    "name": "DailyLimitExceeded",
99    "inputs": []
100  },
101  {
102    "type": "error",
103    "name": "InvalidAuthRoot",
104    "inputs": []
105  },
106  {
107    "type": "error",
108    "name": "InvalidRewardAmount",
109    "inputs": []
110  }
111]
112```*/
113#[allow(
114    non_camel_case_types,
115    non_snake_case,
116    clippy::pub_underscore_fields,
117    clippy::style,
118    clippy::empty_structs_with_brackets
119)]
120pub mod IRewardClaim {
121    use super::*;
122    use alloy::sol_types as alloy_sol_types;
123    /// The creation / init bytecode of the contract.
124    ///
125    /// ```text
126    ///0x
127    /// ```
128    #[rustfmt::skip]
129    #[allow(clippy::all)]
130    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
131        b"",
132    );
133    /// The runtime bytecode of the contract, as deployed on the network.
134    ///
135    /// ```text
136    ///0x
137    /// ```
138    #[rustfmt::skip]
139    #[allow(clippy::all)]
140    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
141        b"",
142    );
143    #[derive(serde::Serialize, serde::Deserialize)]
144    #[derive(Default, Debug, PartialEq, Eq, Hash)]
145    /**Custom error with signature `AlreadyClaimed()` and selector `0x646cf558`.
146```solidity
147error AlreadyClaimed();
148```*/
149    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
150    #[derive(Clone)]
151    pub struct AlreadyClaimed;
152    #[allow(
153        non_camel_case_types,
154        non_snake_case,
155        clippy::pub_underscore_fields,
156        clippy::style
157    )]
158    const _: () = {
159        use alloy::sol_types as alloy_sol_types;
160        #[doc(hidden)]
161        type UnderlyingSolTuple<'a> = ();
162        #[doc(hidden)]
163        type UnderlyingRustTuple<'a> = ();
164        #[cfg(test)]
165        #[allow(dead_code, unreachable_patterns)]
166        fn _type_assertion(
167            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
168        ) {
169            match _t {
170                alloy_sol_types::private::AssertTypeEq::<
171                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
172                >(_) => {}
173            }
174        }
175        #[automatically_derived]
176        #[doc(hidden)]
177        impl ::core::convert::From<AlreadyClaimed> for UnderlyingRustTuple<'_> {
178            fn from(value: AlreadyClaimed) -> Self {
179                ()
180            }
181        }
182        #[automatically_derived]
183        #[doc(hidden)]
184        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AlreadyClaimed {
185            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
186                Self
187            }
188        }
189        #[automatically_derived]
190        impl alloy_sol_types::SolError for AlreadyClaimed {
191            type Parameters<'a> = UnderlyingSolTuple<'a>;
192            type Token<'a> = <Self::Parameters<
193                'a,
194            > as alloy_sol_types::SolType>::Token<'a>;
195            const SIGNATURE: &'static str = "AlreadyClaimed()";
196            const SELECTOR: [u8; 4] = [100u8, 108u8, 245u8, 88u8];
197            #[inline]
198            fn new<'a>(
199                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
200            ) -> Self {
201                tuple.into()
202            }
203            #[inline]
204            fn tokenize(&self) -> Self::Token<'_> {
205                ()
206            }
207            #[inline]
208            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
209                <Self::Parameters<
210                    '_,
211                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
212                    .map(Self::new)
213            }
214        }
215    };
216    #[derive(serde::Serialize, serde::Deserialize)]
217    #[derive(Default, Debug, PartialEq, Eq, Hash)]
218    /**Custom error with signature `DailyLimitExceeded()` and selector `0x194bd314`.
219```solidity
220error DailyLimitExceeded();
221```*/
222    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
223    #[derive(Clone)]
224    pub struct DailyLimitExceeded;
225    #[allow(
226        non_camel_case_types,
227        non_snake_case,
228        clippy::pub_underscore_fields,
229        clippy::style
230    )]
231    const _: () = {
232        use alloy::sol_types as alloy_sol_types;
233        #[doc(hidden)]
234        type UnderlyingSolTuple<'a> = ();
235        #[doc(hidden)]
236        type UnderlyingRustTuple<'a> = ();
237        #[cfg(test)]
238        #[allow(dead_code, unreachable_patterns)]
239        fn _type_assertion(
240            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
241        ) {
242            match _t {
243                alloy_sol_types::private::AssertTypeEq::<
244                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
245                >(_) => {}
246            }
247        }
248        #[automatically_derived]
249        #[doc(hidden)]
250        impl ::core::convert::From<DailyLimitExceeded> for UnderlyingRustTuple<'_> {
251            fn from(value: DailyLimitExceeded) -> Self {
252                ()
253            }
254        }
255        #[automatically_derived]
256        #[doc(hidden)]
257        impl ::core::convert::From<UnderlyingRustTuple<'_>> for DailyLimitExceeded {
258            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
259                Self
260            }
261        }
262        #[automatically_derived]
263        impl alloy_sol_types::SolError for DailyLimitExceeded {
264            type Parameters<'a> = UnderlyingSolTuple<'a>;
265            type Token<'a> = <Self::Parameters<
266                'a,
267            > as alloy_sol_types::SolType>::Token<'a>;
268            const SIGNATURE: &'static str = "DailyLimitExceeded()";
269            const SELECTOR: [u8; 4] = [25u8, 75u8, 211u8, 20u8];
270            #[inline]
271            fn new<'a>(
272                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
273            ) -> Self {
274                tuple.into()
275            }
276            #[inline]
277            fn tokenize(&self) -> Self::Token<'_> {
278                ()
279            }
280            #[inline]
281            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
282                <Self::Parameters<
283                    '_,
284                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
285                    .map(Self::new)
286            }
287        }
288    };
289    #[derive(serde::Serialize, serde::Deserialize)]
290    #[derive(Default, Debug, PartialEq, Eq, Hash)]
291    /**Custom error with signature `InvalidAuthRoot()` and selector `0x328b8878`.
292```solidity
293error InvalidAuthRoot();
294```*/
295    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
296    #[derive(Clone)]
297    pub struct InvalidAuthRoot;
298    #[allow(
299        non_camel_case_types,
300        non_snake_case,
301        clippy::pub_underscore_fields,
302        clippy::style
303    )]
304    const _: () = {
305        use alloy::sol_types as alloy_sol_types;
306        #[doc(hidden)]
307        type UnderlyingSolTuple<'a> = ();
308        #[doc(hidden)]
309        type UnderlyingRustTuple<'a> = ();
310        #[cfg(test)]
311        #[allow(dead_code, unreachable_patterns)]
312        fn _type_assertion(
313            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
314        ) {
315            match _t {
316                alloy_sol_types::private::AssertTypeEq::<
317                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
318                >(_) => {}
319            }
320        }
321        #[automatically_derived]
322        #[doc(hidden)]
323        impl ::core::convert::From<InvalidAuthRoot> for UnderlyingRustTuple<'_> {
324            fn from(value: InvalidAuthRoot) -> Self {
325                ()
326            }
327        }
328        #[automatically_derived]
329        #[doc(hidden)]
330        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAuthRoot {
331            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
332                Self
333            }
334        }
335        #[automatically_derived]
336        impl alloy_sol_types::SolError for InvalidAuthRoot {
337            type Parameters<'a> = UnderlyingSolTuple<'a>;
338            type Token<'a> = <Self::Parameters<
339                'a,
340            > as alloy_sol_types::SolType>::Token<'a>;
341            const SIGNATURE: &'static str = "InvalidAuthRoot()";
342            const SELECTOR: [u8; 4] = [50u8, 139u8, 136u8, 120u8];
343            #[inline]
344            fn new<'a>(
345                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
346            ) -> Self {
347                tuple.into()
348            }
349            #[inline]
350            fn tokenize(&self) -> Self::Token<'_> {
351                ()
352            }
353            #[inline]
354            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
355                <Self::Parameters<
356                    '_,
357                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
358                    .map(Self::new)
359            }
360        }
361    };
362    #[derive(serde::Serialize, serde::Deserialize)]
363    #[derive(Default, Debug, PartialEq, Eq, Hash)]
364    /**Custom error with signature `InvalidRewardAmount()` and selector `0x38539865`.
365```solidity
366error InvalidRewardAmount();
367```*/
368    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
369    #[derive(Clone)]
370    pub struct InvalidRewardAmount;
371    #[allow(
372        non_camel_case_types,
373        non_snake_case,
374        clippy::pub_underscore_fields,
375        clippy::style
376    )]
377    const _: () = {
378        use alloy::sol_types as alloy_sol_types;
379        #[doc(hidden)]
380        type UnderlyingSolTuple<'a> = ();
381        #[doc(hidden)]
382        type UnderlyingRustTuple<'a> = ();
383        #[cfg(test)]
384        #[allow(dead_code, unreachable_patterns)]
385        fn _type_assertion(
386            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
387        ) {
388            match _t {
389                alloy_sol_types::private::AssertTypeEq::<
390                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
391                >(_) => {}
392            }
393        }
394        #[automatically_derived]
395        #[doc(hidden)]
396        impl ::core::convert::From<InvalidRewardAmount> for UnderlyingRustTuple<'_> {
397            fn from(value: InvalidRewardAmount) -> Self {
398                ()
399            }
400        }
401        #[automatically_derived]
402        #[doc(hidden)]
403        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidRewardAmount {
404            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
405                Self
406            }
407        }
408        #[automatically_derived]
409        impl alloy_sol_types::SolError for InvalidRewardAmount {
410            type Parameters<'a> = UnderlyingSolTuple<'a>;
411            type Token<'a> = <Self::Parameters<
412                'a,
413            > as alloy_sol_types::SolType>::Token<'a>;
414            const SIGNATURE: &'static str = "InvalidRewardAmount()";
415            const SELECTOR: [u8; 4] = [56u8, 83u8, 152u8, 101u8];
416            #[inline]
417            fn new<'a>(
418                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
419            ) -> Self {
420                tuple.into()
421            }
422            #[inline]
423            fn tokenize(&self) -> Self::Token<'_> {
424                ()
425            }
426            #[inline]
427            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
428                <Self::Parameters<
429                    '_,
430                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
431                    .map(Self::new)
432            }
433        }
434    };
435    #[derive(serde::Serialize, serde::Deserialize)]
436    #[derive(Default, Debug, PartialEq, Eq, Hash)]
437    /**Event with signature `RewardsClaimed(address,uint256)` and selector `0xfc30cddea38e2bf4d6ea7d3f9ed3b6ad7f176419f4963bd81318067a4aee73fe`.
438```solidity
439event RewardsClaimed(address indexed user, uint256 amount);
440```*/
441    #[allow(
442        non_camel_case_types,
443        non_snake_case,
444        clippy::pub_underscore_fields,
445        clippy::style
446    )]
447    #[derive(Clone)]
448    pub struct RewardsClaimed {
449        #[allow(missing_docs)]
450        pub user: alloy::sol_types::private::Address,
451        #[allow(missing_docs)]
452        pub amount: alloy::sol_types::private::primitives::aliases::U256,
453    }
454    #[allow(
455        non_camel_case_types,
456        non_snake_case,
457        clippy::pub_underscore_fields,
458        clippy::style
459    )]
460    const _: () = {
461        use alloy::sol_types as alloy_sol_types;
462        #[automatically_derived]
463        impl alloy_sol_types::SolEvent for RewardsClaimed {
464            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
465            type DataToken<'a> = <Self::DataTuple<
466                'a,
467            > as alloy_sol_types::SolType>::Token<'a>;
468            type TopicList = (
469                alloy_sol_types::sol_data::FixedBytes<32>,
470                alloy::sol_types::sol_data::Address,
471            );
472            const SIGNATURE: &'static str = "RewardsClaimed(address,uint256)";
473            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
474                252u8, 48u8, 205u8, 222u8, 163u8, 142u8, 43u8, 244u8, 214u8, 234u8,
475                125u8, 63u8, 158u8, 211u8, 182u8, 173u8, 127u8, 23u8, 100u8, 25u8, 244u8,
476                150u8, 59u8, 216u8, 19u8, 24u8, 6u8, 122u8, 74u8, 238u8, 115u8, 254u8,
477            ]);
478            const ANONYMOUS: bool = false;
479            #[allow(unused_variables)]
480            #[inline]
481            fn new(
482                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
483                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
484            ) -> Self {
485                Self {
486                    user: topics.1,
487                    amount: data.0,
488                }
489            }
490            #[inline]
491            fn check_signature(
492                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
493            ) -> alloy_sol_types::Result<()> {
494                if topics.0 != Self::SIGNATURE_HASH {
495                    return Err(
496                        alloy_sol_types::Error::invalid_event_signature_hash(
497                            Self::SIGNATURE,
498                            topics.0,
499                            Self::SIGNATURE_HASH,
500                        ),
501                    );
502                }
503                Ok(())
504            }
505            #[inline]
506            fn tokenize_body(&self) -> Self::DataToken<'_> {
507                (
508                    <alloy::sol_types::sol_data::Uint<
509                        256,
510                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
511                )
512            }
513            #[inline]
514            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
515                (Self::SIGNATURE_HASH.into(), self.user.clone())
516            }
517            #[inline]
518            fn encode_topics_raw(
519                &self,
520                out: &mut [alloy_sol_types::abi::token::WordToken],
521            ) -> alloy_sol_types::Result<()> {
522                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
523                    return Err(alloy_sol_types::Error::Overrun);
524                }
525                out[0usize] = alloy_sol_types::abi::token::WordToken(
526                    Self::SIGNATURE_HASH,
527                );
528                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
529                    &self.user,
530                );
531                Ok(())
532            }
533        }
534        #[automatically_derived]
535        impl alloy_sol_types::private::IntoLogData for RewardsClaimed {
536            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
537                From::from(self)
538            }
539            fn into_log_data(self) -> alloy_sol_types::private::LogData {
540                From::from(&self)
541            }
542        }
543        #[automatically_derived]
544        impl From<&RewardsClaimed> for alloy_sol_types::private::LogData {
545            #[inline]
546            fn from(this: &RewardsClaimed) -> alloy_sol_types::private::LogData {
547                alloy_sol_types::SolEvent::encode_log_data(this)
548            }
549        }
550    };
551    #[derive(serde::Serialize, serde::Deserialize)]
552    #[derive(Default, Debug, PartialEq, Eq, Hash)]
553    /**Function with signature `claimRewards(uint256,bytes)` and selector `0x549dd8c3`.
554```solidity
555function claimRewards(uint256 lifetimeRewards, bytes memory authData) external;
556```*/
557    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
558    #[derive(Clone)]
559    pub struct claimRewardsCall {
560        #[allow(missing_docs)]
561        pub lifetimeRewards: alloy::sol_types::private::primitives::aliases::U256,
562        #[allow(missing_docs)]
563        pub authData: alloy::sol_types::private::Bytes,
564    }
565    ///Container type for the return parameters of the [`claimRewards(uint256,bytes)`](claimRewardsCall) function.
566    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
567    #[derive(Clone)]
568    pub struct claimRewardsReturn {}
569    #[allow(
570        non_camel_case_types,
571        non_snake_case,
572        clippy::pub_underscore_fields,
573        clippy::style
574    )]
575    const _: () = {
576        use alloy::sol_types as alloy_sol_types;
577        {
578            #[doc(hidden)]
579            type UnderlyingSolTuple<'a> = (
580                alloy::sol_types::sol_data::Uint<256>,
581                alloy::sol_types::sol_data::Bytes,
582            );
583            #[doc(hidden)]
584            type UnderlyingRustTuple<'a> = (
585                alloy::sol_types::private::primitives::aliases::U256,
586                alloy::sol_types::private::Bytes,
587            );
588            #[cfg(test)]
589            #[allow(dead_code, unreachable_patterns)]
590            fn _type_assertion(
591                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
592            ) {
593                match _t {
594                    alloy_sol_types::private::AssertTypeEq::<
595                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
596                    >(_) => {}
597                }
598            }
599            #[automatically_derived]
600            #[doc(hidden)]
601            impl ::core::convert::From<claimRewardsCall> for UnderlyingRustTuple<'_> {
602                fn from(value: claimRewardsCall) -> Self {
603                    (value.lifetimeRewards, value.authData)
604                }
605            }
606            #[automatically_derived]
607            #[doc(hidden)]
608            impl ::core::convert::From<UnderlyingRustTuple<'_>> for claimRewardsCall {
609                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
610                    Self {
611                        lifetimeRewards: tuple.0,
612                        authData: tuple.1,
613                    }
614                }
615            }
616        }
617        {
618            #[doc(hidden)]
619            type UnderlyingSolTuple<'a> = ();
620            #[doc(hidden)]
621            type UnderlyingRustTuple<'a> = ();
622            #[cfg(test)]
623            #[allow(dead_code, unreachable_patterns)]
624            fn _type_assertion(
625                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
626            ) {
627                match _t {
628                    alloy_sol_types::private::AssertTypeEq::<
629                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
630                    >(_) => {}
631                }
632            }
633            #[automatically_derived]
634            #[doc(hidden)]
635            impl ::core::convert::From<claimRewardsReturn> for UnderlyingRustTuple<'_> {
636                fn from(value: claimRewardsReturn) -> Self {
637                    ()
638                }
639            }
640            #[automatically_derived]
641            #[doc(hidden)]
642            impl ::core::convert::From<UnderlyingRustTuple<'_>> for claimRewardsReturn {
643                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
644                    Self {}
645                }
646            }
647        }
648        impl claimRewardsReturn {
649            fn _tokenize(
650                &self,
651            ) -> <claimRewardsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
652                ()
653            }
654        }
655        #[automatically_derived]
656        impl alloy_sol_types::SolCall for claimRewardsCall {
657            type Parameters<'a> = (
658                alloy::sol_types::sol_data::Uint<256>,
659                alloy::sol_types::sol_data::Bytes,
660            );
661            type Token<'a> = <Self::Parameters<
662                'a,
663            > as alloy_sol_types::SolType>::Token<'a>;
664            type Return = claimRewardsReturn;
665            type ReturnTuple<'a> = ();
666            type ReturnToken<'a> = <Self::ReturnTuple<
667                'a,
668            > as alloy_sol_types::SolType>::Token<'a>;
669            const SIGNATURE: &'static str = "claimRewards(uint256,bytes)";
670            const SELECTOR: [u8; 4] = [84u8, 157u8, 216u8, 195u8];
671            #[inline]
672            fn new<'a>(
673                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
674            ) -> Self {
675                tuple.into()
676            }
677            #[inline]
678            fn tokenize(&self) -> Self::Token<'_> {
679                (
680                    <alloy::sol_types::sol_data::Uint<
681                        256,
682                    > as alloy_sol_types::SolType>::tokenize(&self.lifetimeRewards),
683                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
684                        &self.authData,
685                    ),
686                )
687            }
688            #[inline]
689            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
690                claimRewardsReturn::_tokenize(ret)
691            }
692            #[inline]
693            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
694                <Self::ReturnTuple<
695                    '_,
696                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
697                    .map(Into::into)
698            }
699            #[inline]
700            fn abi_decode_returns_validate(
701                data: &[u8],
702            ) -> alloy_sol_types::Result<Self::Return> {
703                <Self::ReturnTuple<
704                    '_,
705                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
706                    .map(Into::into)
707            }
708        }
709    };
710    #[derive(serde::Serialize, serde::Deserialize)]
711    #[derive(Default, Debug, PartialEq, Eq, Hash)]
712    /**Function with signature `claimedRewards(address)` and selector `0xbd834345`.
713```solidity
714function claimedRewards(address claimer) external view returns (uint256);
715```*/
716    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
717    #[derive(Clone)]
718    pub struct claimedRewardsCall {
719        #[allow(missing_docs)]
720        pub claimer: alloy::sol_types::private::Address,
721    }
722    #[derive(serde::Serialize, serde::Deserialize)]
723    #[derive(Default, Debug, PartialEq, Eq, Hash)]
724    ///Container type for the return parameters of the [`claimedRewards(address)`](claimedRewardsCall) function.
725    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
726    #[derive(Clone)]
727    pub struct claimedRewardsReturn {
728        #[allow(missing_docs)]
729        pub _0: alloy::sol_types::private::primitives::aliases::U256,
730    }
731    #[allow(
732        non_camel_case_types,
733        non_snake_case,
734        clippy::pub_underscore_fields,
735        clippy::style
736    )]
737    const _: () = {
738        use alloy::sol_types as alloy_sol_types;
739        {
740            #[doc(hidden)]
741            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
742            #[doc(hidden)]
743            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
744            #[cfg(test)]
745            #[allow(dead_code, unreachable_patterns)]
746            fn _type_assertion(
747                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
748            ) {
749                match _t {
750                    alloy_sol_types::private::AssertTypeEq::<
751                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
752                    >(_) => {}
753                }
754            }
755            #[automatically_derived]
756            #[doc(hidden)]
757            impl ::core::convert::From<claimedRewardsCall> for UnderlyingRustTuple<'_> {
758                fn from(value: claimedRewardsCall) -> Self {
759                    (value.claimer,)
760                }
761            }
762            #[automatically_derived]
763            #[doc(hidden)]
764            impl ::core::convert::From<UnderlyingRustTuple<'_>> for claimedRewardsCall {
765                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
766                    Self { claimer: tuple.0 }
767                }
768            }
769        }
770        {
771            #[doc(hidden)]
772            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
773            #[doc(hidden)]
774            type UnderlyingRustTuple<'a> = (
775                alloy::sol_types::private::primitives::aliases::U256,
776            );
777            #[cfg(test)]
778            #[allow(dead_code, unreachable_patterns)]
779            fn _type_assertion(
780                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
781            ) {
782                match _t {
783                    alloy_sol_types::private::AssertTypeEq::<
784                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
785                    >(_) => {}
786                }
787            }
788            #[automatically_derived]
789            #[doc(hidden)]
790            impl ::core::convert::From<claimedRewardsReturn>
791            for UnderlyingRustTuple<'_> {
792                fn from(value: claimedRewardsReturn) -> Self {
793                    (value._0,)
794                }
795            }
796            #[automatically_derived]
797            #[doc(hidden)]
798            impl ::core::convert::From<UnderlyingRustTuple<'_>>
799            for claimedRewardsReturn {
800                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
801                    Self { _0: tuple.0 }
802                }
803            }
804        }
805        #[automatically_derived]
806        impl alloy_sol_types::SolCall for claimedRewardsCall {
807            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
808            type Token<'a> = <Self::Parameters<
809                'a,
810            > as alloy_sol_types::SolType>::Token<'a>;
811            type Return = alloy::sol_types::private::primitives::aliases::U256;
812            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
813            type ReturnToken<'a> = <Self::ReturnTuple<
814                'a,
815            > as alloy_sol_types::SolType>::Token<'a>;
816            const SIGNATURE: &'static str = "claimedRewards(address)";
817            const SELECTOR: [u8; 4] = [189u8, 131u8, 67u8, 69u8];
818            #[inline]
819            fn new<'a>(
820                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
821            ) -> Self {
822                tuple.into()
823            }
824            #[inline]
825            fn tokenize(&self) -> Self::Token<'_> {
826                (
827                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
828                        &self.claimer,
829                    ),
830                )
831            }
832            #[inline]
833            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
834                (
835                    <alloy::sol_types::sol_data::Uint<
836                        256,
837                    > as alloy_sol_types::SolType>::tokenize(ret),
838                )
839            }
840            #[inline]
841            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
842                <Self::ReturnTuple<
843                    '_,
844                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
845                    .map(|r| {
846                        let r: claimedRewardsReturn = r.into();
847                        r._0
848                    })
849            }
850            #[inline]
851            fn abi_decode_returns_validate(
852                data: &[u8],
853            ) -> alloy_sol_types::Result<Self::Return> {
854                <Self::ReturnTuple<
855                    '_,
856                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
857                    .map(|r| {
858                        let r: claimedRewardsReturn = r.into();
859                        r._0
860                    })
861            }
862        }
863    };
864    #[derive(serde::Serialize, serde::Deserialize)]
865    #[derive(Default, Debug, PartialEq, Eq, Hash)]
866    /**Function with signature `totalClaimed()` and selector `0xd54ad2a1`.
867```solidity
868function totalClaimed() external view returns (uint256);
869```*/
870    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
871    #[derive(Clone)]
872    pub struct totalClaimedCall;
873    #[derive(serde::Serialize, serde::Deserialize)]
874    #[derive(Default, Debug, PartialEq, Eq, Hash)]
875    ///Container type for the return parameters of the [`totalClaimed()`](totalClaimedCall) function.
876    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
877    #[derive(Clone)]
878    pub struct totalClaimedReturn {
879        #[allow(missing_docs)]
880        pub _0: alloy::sol_types::private::primitives::aliases::U256,
881    }
882    #[allow(
883        non_camel_case_types,
884        non_snake_case,
885        clippy::pub_underscore_fields,
886        clippy::style
887    )]
888    const _: () = {
889        use alloy::sol_types as alloy_sol_types;
890        {
891            #[doc(hidden)]
892            type UnderlyingSolTuple<'a> = ();
893            #[doc(hidden)]
894            type UnderlyingRustTuple<'a> = ();
895            #[cfg(test)]
896            #[allow(dead_code, unreachable_patterns)]
897            fn _type_assertion(
898                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
899            ) {
900                match _t {
901                    alloy_sol_types::private::AssertTypeEq::<
902                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
903                    >(_) => {}
904                }
905            }
906            #[automatically_derived]
907            #[doc(hidden)]
908            impl ::core::convert::From<totalClaimedCall> for UnderlyingRustTuple<'_> {
909                fn from(value: totalClaimedCall) -> Self {
910                    ()
911                }
912            }
913            #[automatically_derived]
914            #[doc(hidden)]
915            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalClaimedCall {
916                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
917                    Self
918                }
919            }
920        }
921        {
922            #[doc(hidden)]
923            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
924            #[doc(hidden)]
925            type UnderlyingRustTuple<'a> = (
926                alloy::sol_types::private::primitives::aliases::U256,
927            );
928            #[cfg(test)]
929            #[allow(dead_code, unreachable_patterns)]
930            fn _type_assertion(
931                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
932            ) {
933                match _t {
934                    alloy_sol_types::private::AssertTypeEq::<
935                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
936                    >(_) => {}
937                }
938            }
939            #[automatically_derived]
940            #[doc(hidden)]
941            impl ::core::convert::From<totalClaimedReturn> for UnderlyingRustTuple<'_> {
942                fn from(value: totalClaimedReturn) -> Self {
943                    (value._0,)
944                }
945            }
946            #[automatically_derived]
947            #[doc(hidden)]
948            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalClaimedReturn {
949                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
950                    Self { _0: tuple.0 }
951                }
952            }
953        }
954        #[automatically_derived]
955        impl alloy_sol_types::SolCall for totalClaimedCall {
956            type Parameters<'a> = ();
957            type Token<'a> = <Self::Parameters<
958                'a,
959            > as alloy_sol_types::SolType>::Token<'a>;
960            type Return = alloy::sol_types::private::primitives::aliases::U256;
961            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
962            type ReturnToken<'a> = <Self::ReturnTuple<
963                'a,
964            > as alloy_sol_types::SolType>::Token<'a>;
965            const SIGNATURE: &'static str = "totalClaimed()";
966            const SELECTOR: [u8; 4] = [213u8, 74u8, 210u8, 161u8];
967            #[inline]
968            fn new<'a>(
969                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
970            ) -> Self {
971                tuple.into()
972            }
973            #[inline]
974            fn tokenize(&self) -> Self::Token<'_> {
975                ()
976            }
977            #[inline]
978            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
979                (
980                    <alloy::sol_types::sol_data::Uint<
981                        256,
982                    > as alloy_sol_types::SolType>::tokenize(ret),
983                )
984            }
985            #[inline]
986            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
987                <Self::ReturnTuple<
988                    '_,
989                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
990                    .map(|r| {
991                        let r: totalClaimedReturn = r.into();
992                        r._0
993                    })
994            }
995            #[inline]
996            fn abi_decode_returns_validate(
997                data: &[u8],
998            ) -> alloy_sol_types::Result<Self::Return> {
999                <Self::ReturnTuple<
1000                    '_,
1001                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1002                    .map(|r| {
1003                        let r: totalClaimedReturn = r.into();
1004                        r._0
1005                    })
1006            }
1007        }
1008    };
1009    ///Container for all the [`IRewardClaim`](self) function calls.
1010    #[derive(serde::Serialize, serde::Deserialize)]
1011    #[derive()]
1012    pub enum IRewardClaimCalls {
1013        #[allow(missing_docs)]
1014        claimRewards(claimRewardsCall),
1015        #[allow(missing_docs)]
1016        claimedRewards(claimedRewardsCall),
1017        #[allow(missing_docs)]
1018        totalClaimed(totalClaimedCall),
1019    }
1020    #[automatically_derived]
1021    impl IRewardClaimCalls {
1022        /// All the selectors of this enum.
1023        ///
1024        /// Note that the selectors might not be in the same order as the variants.
1025        /// No guarantees are made about the order of the selectors.
1026        ///
1027        /// Prefer using `SolInterface` methods instead.
1028        pub const SELECTORS: &'static [[u8; 4usize]] = &[
1029            [84u8, 157u8, 216u8, 195u8],
1030            [189u8, 131u8, 67u8, 69u8],
1031            [213u8, 74u8, 210u8, 161u8],
1032        ];
1033    }
1034    #[automatically_derived]
1035    impl alloy_sol_types::SolInterface for IRewardClaimCalls {
1036        const NAME: &'static str = "IRewardClaimCalls";
1037        const MIN_DATA_LENGTH: usize = 0usize;
1038        const COUNT: usize = 3usize;
1039        #[inline]
1040        fn selector(&self) -> [u8; 4] {
1041            match self {
1042                Self::claimRewards(_) => {
1043                    <claimRewardsCall as alloy_sol_types::SolCall>::SELECTOR
1044                }
1045                Self::claimedRewards(_) => {
1046                    <claimedRewardsCall as alloy_sol_types::SolCall>::SELECTOR
1047                }
1048                Self::totalClaimed(_) => {
1049                    <totalClaimedCall as alloy_sol_types::SolCall>::SELECTOR
1050                }
1051            }
1052        }
1053        #[inline]
1054        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1055            Self::SELECTORS.get(i).copied()
1056        }
1057        #[inline]
1058        fn valid_selector(selector: [u8; 4]) -> bool {
1059            Self::SELECTORS.binary_search(&selector).is_ok()
1060        }
1061        #[inline]
1062        #[allow(non_snake_case)]
1063        fn abi_decode_raw(
1064            selector: [u8; 4],
1065            data: &[u8],
1066        ) -> alloy_sol_types::Result<Self> {
1067            static DECODE_SHIMS: &[fn(
1068                &[u8],
1069            ) -> alloy_sol_types::Result<IRewardClaimCalls>] = &[
1070                {
1071                    fn claimRewards(
1072                        data: &[u8],
1073                    ) -> alloy_sol_types::Result<IRewardClaimCalls> {
1074                        <claimRewardsCall as alloy_sol_types::SolCall>::abi_decode_raw(
1075                                data,
1076                            )
1077                            .map(IRewardClaimCalls::claimRewards)
1078                    }
1079                    claimRewards
1080                },
1081                {
1082                    fn claimedRewards(
1083                        data: &[u8],
1084                    ) -> alloy_sol_types::Result<IRewardClaimCalls> {
1085                        <claimedRewardsCall as alloy_sol_types::SolCall>::abi_decode_raw(
1086                                data,
1087                            )
1088                            .map(IRewardClaimCalls::claimedRewards)
1089                    }
1090                    claimedRewards
1091                },
1092                {
1093                    fn totalClaimed(
1094                        data: &[u8],
1095                    ) -> alloy_sol_types::Result<IRewardClaimCalls> {
1096                        <totalClaimedCall as alloy_sol_types::SolCall>::abi_decode_raw(
1097                                data,
1098                            )
1099                            .map(IRewardClaimCalls::totalClaimed)
1100                    }
1101                    totalClaimed
1102                },
1103            ];
1104            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1105                return Err(
1106                    alloy_sol_types::Error::unknown_selector(
1107                        <Self as alloy_sol_types::SolInterface>::NAME,
1108                        selector,
1109                    ),
1110                );
1111            };
1112            DECODE_SHIMS[idx](data)
1113        }
1114        #[inline]
1115        #[allow(non_snake_case)]
1116        fn abi_decode_raw_validate(
1117            selector: [u8; 4],
1118            data: &[u8],
1119        ) -> alloy_sol_types::Result<Self> {
1120            static DECODE_VALIDATE_SHIMS: &[fn(
1121                &[u8],
1122            ) -> alloy_sol_types::Result<IRewardClaimCalls>] = &[
1123                {
1124                    fn claimRewards(
1125                        data: &[u8],
1126                    ) -> alloy_sol_types::Result<IRewardClaimCalls> {
1127                        <claimRewardsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1128                                data,
1129                            )
1130                            .map(IRewardClaimCalls::claimRewards)
1131                    }
1132                    claimRewards
1133                },
1134                {
1135                    fn claimedRewards(
1136                        data: &[u8],
1137                    ) -> alloy_sol_types::Result<IRewardClaimCalls> {
1138                        <claimedRewardsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1139                                data,
1140                            )
1141                            .map(IRewardClaimCalls::claimedRewards)
1142                    }
1143                    claimedRewards
1144                },
1145                {
1146                    fn totalClaimed(
1147                        data: &[u8],
1148                    ) -> alloy_sol_types::Result<IRewardClaimCalls> {
1149                        <totalClaimedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1150                                data,
1151                            )
1152                            .map(IRewardClaimCalls::totalClaimed)
1153                    }
1154                    totalClaimed
1155                },
1156            ];
1157            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1158                return Err(
1159                    alloy_sol_types::Error::unknown_selector(
1160                        <Self as alloy_sol_types::SolInterface>::NAME,
1161                        selector,
1162                    ),
1163                );
1164            };
1165            DECODE_VALIDATE_SHIMS[idx](data)
1166        }
1167        #[inline]
1168        fn abi_encoded_size(&self) -> usize {
1169            match self {
1170                Self::claimRewards(inner) => {
1171                    <claimRewardsCall as alloy_sol_types::SolCall>::abi_encoded_size(
1172                        inner,
1173                    )
1174                }
1175                Self::claimedRewards(inner) => {
1176                    <claimedRewardsCall as alloy_sol_types::SolCall>::abi_encoded_size(
1177                        inner,
1178                    )
1179                }
1180                Self::totalClaimed(inner) => {
1181                    <totalClaimedCall as alloy_sol_types::SolCall>::abi_encoded_size(
1182                        inner,
1183                    )
1184                }
1185            }
1186        }
1187        #[inline]
1188        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1189            match self {
1190                Self::claimRewards(inner) => {
1191                    <claimRewardsCall as alloy_sol_types::SolCall>::abi_encode_raw(
1192                        inner,
1193                        out,
1194                    )
1195                }
1196                Self::claimedRewards(inner) => {
1197                    <claimedRewardsCall as alloy_sol_types::SolCall>::abi_encode_raw(
1198                        inner,
1199                        out,
1200                    )
1201                }
1202                Self::totalClaimed(inner) => {
1203                    <totalClaimedCall as alloy_sol_types::SolCall>::abi_encode_raw(
1204                        inner,
1205                        out,
1206                    )
1207                }
1208            }
1209        }
1210    }
1211    ///Container for all the [`IRewardClaim`](self) custom errors.
1212    #[derive(serde::Serialize, serde::Deserialize)]
1213    #[derive(Debug, PartialEq, Eq, Hash)]
1214    pub enum IRewardClaimErrors {
1215        #[allow(missing_docs)]
1216        AlreadyClaimed(AlreadyClaimed),
1217        #[allow(missing_docs)]
1218        DailyLimitExceeded(DailyLimitExceeded),
1219        #[allow(missing_docs)]
1220        InvalidAuthRoot(InvalidAuthRoot),
1221        #[allow(missing_docs)]
1222        InvalidRewardAmount(InvalidRewardAmount),
1223    }
1224    #[automatically_derived]
1225    impl IRewardClaimErrors {
1226        /// All the selectors of this enum.
1227        ///
1228        /// Note that the selectors might not be in the same order as the variants.
1229        /// No guarantees are made about the order of the selectors.
1230        ///
1231        /// Prefer using `SolInterface` methods instead.
1232        pub const SELECTORS: &'static [[u8; 4usize]] = &[
1233            [25u8, 75u8, 211u8, 20u8],
1234            [50u8, 139u8, 136u8, 120u8],
1235            [56u8, 83u8, 152u8, 101u8],
1236            [100u8, 108u8, 245u8, 88u8],
1237        ];
1238    }
1239    #[automatically_derived]
1240    impl alloy_sol_types::SolInterface for IRewardClaimErrors {
1241        const NAME: &'static str = "IRewardClaimErrors";
1242        const MIN_DATA_LENGTH: usize = 0usize;
1243        const COUNT: usize = 4usize;
1244        #[inline]
1245        fn selector(&self) -> [u8; 4] {
1246            match self {
1247                Self::AlreadyClaimed(_) => {
1248                    <AlreadyClaimed as alloy_sol_types::SolError>::SELECTOR
1249                }
1250                Self::DailyLimitExceeded(_) => {
1251                    <DailyLimitExceeded as alloy_sol_types::SolError>::SELECTOR
1252                }
1253                Self::InvalidAuthRoot(_) => {
1254                    <InvalidAuthRoot as alloy_sol_types::SolError>::SELECTOR
1255                }
1256                Self::InvalidRewardAmount(_) => {
1257                    <InvalidRewardAmount as alloy_sol_types::SolError>::SELECTOR
1258                }
1259            }
1260        }
1261        #[inline]
1262        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1263            Self::SELECTORS.get(i).copied()
1264        }
1265        #[inline]
1266        fn valid_selector(selector: [u8; 4]) -> bool {
1267            Self::SELECTORS.binary_search(&selector).is_ok()
1268        }
1269        #[inline]
1270        #[allow(non_snake_case)]
1271        fn abi_decode_raw(
1272            selector: [u8; 4],
1273            data: &[u8],
1274        ) -> alloy_sol_types::Result<Self> {
1275            static DECODE_SHIMS: &[fn(
1276                &[u8],
1277            ) -> alloy_sol_types::Result<IRewardClaimErrors>] = &[
1278                {
1279                    fn DailyLimitExceeded(
1280                        data: &[u8],
1281                    ) -> alloy_sol_types::Result<IRewardClaimErrors> {
1282                        <DailyLimitExceeded as alloy_sol_types::SolError>::abi_decode_raw(
1283                                data,
1284                            )
1285                            .map(IRewardClaimErrors::DailyLimitExceeded)
1286                    }
1287                    DailyLimitExceeded
1288                },
1289                {
1290                    fn InvalidAuthRoot(
1291                        data: &[u8],
1292                    ) -> alloy_sol_types::Result<IRewardClaimErrors> {
1293                        <InvalidAuthRoot as alloy_sol_types::SolError>::abi_decode_raw(
1294                                data,
1295                            )
1296                            .map(IRewardClaimErrors::InvalidAuthRoot)
1297                    }
1298                    InvalidAuthRoot
1299                },
1300                {
1301                    fn InvalidRewardAmount(
1302                        data: &[u8],
1303                    ) -> alloy_sol_types::Result<IRewardClaimErrors> {
1304                        <InvalidRewardAmount as alloy_sol_types::SolError>::abi_decode_raw(
1305                                data,
1306                            )
1307                            .map(IRewardClaimErrors::InvalidRewardAmount)
1308                    }
1309                    InvalidRewardAmount
1310                },
1311                {
1312                    fn AlreadyClaimed(
1313                        data: &[u8],
1314                    ) -> alloy_sol_types::Result<IRewardClaimErrors> {
1315                        <AlreadyClaimed as alloy_sol_types::SolError>::abi_decode_raw(
1316                                data,
1317                            )
1318                            .map(IRewardClaimErrors::AlreadyClaimed)
1319                    }
1320                    AlreadyClaimed
1321                },
1322            ];
1323            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1324                return Err(
1325                    alloy_sol_types::Error::unknown_selector(
1326                        <Self as alloy_sol_types::SolInterface>::NAME,
1327                        selector,
1328                    ),
1329                );
1330            };
1331            DECODE_SHIMS[idx](data)
1332        }
1333        #[inline]
1334        #[allow(non_snake_case)]
1335        fn abi_decode_raw_validate(
1336            selector: [u8; 4],
1337            data: &[u8],
1338        ) -> alloy_sol_types::Result<Self> {
1339            static DECODE_VALIDATE_SHIMS: &[fn(
1340                &[u8],
1341            ) -> alloy_sol_types::Result<IRewardClaimErrors>] = &[
1342                {
1343                    fn DailyLimitExceeded(
1344                        data: &[u8],
1345                    ) -> alloy_sol_types::Result<IRewardClaimErrors> {
1346                        <DailyLimitExceeded as alloy_sol_types::SolError>::abi_decode_raw_validate(
1347                                data,
1348                            )
1349                            .map(IRewardClaimErrors::DailyLimitExceeded)
1350                    }
1351                    DailyLimitExceeded
1352                },
1353                {
1354                    fn InvalidAuthRoot(
1355                        data: &[u8],
1356                    ) -> alloy_sol_types::Result<IRewardClaimErrors> {
1357                        <InvalidAuthRoot as alloy_sol_types::SolError>::abi_decode_raw_validate(
1358                                data,
1359                            )
1360                            .map(IRewardClaimErrors::InvalidAuthRoot)
1361                    }
1362                    InvalidAuthRoot
1363                },
1364                {
1365                    fn InvalidRewardAmount(
1366                        data: &[u8],
1367                    ) -> alloy_sol_types::Result<IRewardClaimErrors> {
1368                        <InvalidRewardAmount as alloy_sol_types::SolError>::abi_decode_raw_validate(
1369                                data,
1370                            )
1371                            .map(IRewardClaimErrors::InvalidRewardAmount)
1372                    }
1373                    InvalidRewardAmount
1374                },
1375                {
1376                    fn AlreadyClaimed(
1377                        data: &[u8],
1378                    ) -> alloy_sol_types::Result<IRewardClaimErrors> {
1379                        <AlreadyClaimed as alloy_sol_types::SolError>::abi_decode_raw_validate(
1380                                data,
1381                            )
1382                            .map(IRewardClaimErrors::AlreadyClaimed)
1383                    }
1384                    AlreadyClaimed
1385                },
1386            ];
1387            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1388                return Err(
1389                    alloy_sol_types::Error::unknown_selector(
1390                        <Self as alloy_sol_types::SolInterface>::NAME,
1391                        selector,
1392                    ),
1393                );
1394            };
1395            DECODE_VALIDATE_SHIMS[idx](data)
1396        }
1397        #[inline]
1398        fn abi_encoded_size(&self) -> usize {
1399            match self {
1400                Self::AlreadyClaimed(inner) => {
1401                    <AlreadyClaimed as alloy_sol_types::SolError>::abi_encoded_size(
1402                        inner,
1403                    )
1404                }
1405                Self::DailyLimitExceeded(inner) => {
1406                    <DailyLimitExceeded as alloy_sol_types::SolError>::abi_encoded_size(
1407                        inner,
1408                    )
1409                }
1410                Self::InvalidAuthRoot(inner) => {
1411                    <InvalidAuthRoot as alloy_sol_types::SolError>::abi_encoded_size(
1412                        inner,
1413                    )
1414                }
1415                Self::InvalidRewardAmount(inner) => {
1416                    <InvalidRewardAmount as alloy_sol_types::SolError>::abi_encoded_size(
1417                        inner,
1418                    )
1419                }
1420            }
1421        }
1422        #[inline]
1423        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1424            match self {
1425                Self::AlreadyClaimed(inner) => {
1426                    <AlreadyClaimed as alloy_sol_types::SolError>::abi_encode_raw(
1427                        inner,
1428                        out,
1429                    )
1430                }
1431                Self::DailyLimitExceeded(inner) => {
1432                    <DailyLimitExceeded as alloy_sol_types::SolError>::abi_encode_raw(
1433                        inner,
1434                        out,
1435                    )
1436                }
1437                Self::InvalidAuthRoot(inner) => {
1438                    <InvalidAuthRoot as alloy_sol_types::SolError>::abi_encode_raw(
1439                        inner,
1440                        out,
1441                    )
1442                }
1443                Self::InvalidRewardAmount(inner) => {
1444                    <InvalidRewardAmount as alloy_sol_types::SolError>::abi_encode_raw(
1445                        inner,
1446                        out,
1447                    )
1448                }
1449            }
1450        }
1451    }
1452    ///Container for all the [`IRewardClaim`](self) events.
1453    #[derive(serde::Serialize, serde::Deserialize)]
1454    #[derive(Debug, PartialEq, Eq, Hash)]
1455    pub enum IRewardClaimEvents {
1456        #[allow(missing_docs)]
1457        RewardsClaimed(RewardsClaimed),
1458    }
1459    #[automatically_derived]
1460    impl IRewardClaimEvents {
1461        /// All the selectors of this enum.
1462        ///
1463        /// Note that the selectors might not be in the same order as the variants.
1464        /// No guarantees are made about the order of the selectors.
1465        ///
1466        /// Prefer using `SolInterface` methods instead.
1467        pub const SELECTORS: &'static [[u8; 32usize]] = &[
1468            [
1469                252u8, 48u8, 205u8, 222u8, 163u8, 142u8, 43u8, 244u8, 214u8, 234u8,
1470                125u8, 63u8, 158u8, 211u8, 182u8, 173u8, 127u8, 23u8, 100u8, 25u8, 244u8,
1471                150u8, 59u8, 216u8, 19u8, 24u8, 6u8, 122u8, 74u8, 238u8, 115u8, 254u8,
1472            ],
1473        ];
1474    }
1475    #[automatically_derived]
1476    impl alloy_sol_types::SolEventInterface for IRewardClaimEvents {
1477        const NAME: &'static str = "IRewardClaimEvents";
1478        const COUNT: usize = 1usize;
1479        fn decode_raw_log(
1480            topics: &[alloy_sol_types::Word],
1481            data: &[u8],
1482        ) -> alloy_sol_types::Result<Self> {
1483            match topics.first().copied() {
1484                Some(<RewardsClaimed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
1485                    <RewardsClaimed as alloy_sol_types::SolEvent>::decode_raw_log(
1486                            topics,
1487                            data,
1488                        )
1489                        .map(Self::RewardsClaimed)
1490                }
1491                _ => {
1492                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
1493                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
1494                        log: alloy_sol_types::private::Box::new(
1495                            alloy_sol_types::private::LogData::new_unchecked(
1496                                topics.to_vec(),
1497                                data.to_vec().into(),
1498                            ),
1499                        ),
1500                    })
1501                }
1502            }
1503        }
1504    }
1505    #[automatically_derived]
1506    impl alloy_sol_types::private::IntoLogData for IRewardClaimEvents {
1507        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1508            match self {
1509                Self::RewardsClaimed(inner) => {
1510                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
1511                }
1512            }
1513        }
1514        fn into_log_data(self) -> alloy_sol_types::private::LogData {
1515            match self {
1516                Self::RewardsClaimed(inner) => {
1517                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
1518                }
1519            }
1520        }
1521    }
1522    use alloy::contract as alloy_contract;
1523    /**Creates a new wrapper around an on-chain [`IRewardClaim`](self) contract instance.
1524
1525See the [wrapper's documentation](`IRewardClaimInstance`) for more details.*/
1526    #[inline]
1527    pub const fn new<
1528        P: alloy_contract::private::Provider<N>,
1529        N: alloy_contract::private::Network,
1530    >(
1531        address: alloy_sol_types::private::Address,
1532        provider: P,
1533    ) -> IRewardClaimInstance<P, N> {
1534        IRewardClaimInstance::<P, N>::new(address, provider)
1535    }
1536    /**Deploys this contract using the given `provider` and constructor arguments, if any.
1537
1538Returns a new instance of the contract, if the deployment was successful.
1539
1540For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1541    #[inline]
1542    pub fn deploy<
1543        P: alloy_contract::private::Provider<N>,
1544        N: alloy_contract::private::Network,
1545    >(
1546        provider: P,
1547    ) -> impl ::core::future::Future<
1548        Output = alloy_contract::Result<IRewardClaimInstance<P, N>>,
1549    > {
1550        IRewardClaimInstance::<P, N>::deploy(provider)
1551    }
1552    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1553and constructor arguments, if any.
1554
1555This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1556the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1557    #[inline]
1558    pub fn deploy_builder<
1559        P: alloy_contract::private::Provider<N>,
1560        N: alloy_contract::private::Network,
1561    >(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
1562        IRewardClaimInstance::<P, N>::deploy_builder(provider)
1563    }
1564    /**A [`IRewardClaim`](self) instance.
1565
1566Contains type-safe methods for interacting with an on-chain instance of the
1567[`IRewardClaim`](self) contract located at a given `address`, using a given
1568provider `P`.
1569
1570If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1571documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1572be used to deploy a new instance of the contract.
1573
1574See the [module-level documentation](self) for all the available methods.*/
1575    #[derive(Clone)]
1576    pub struct IRewardClaimInstance<P, N = alloy_contract::private::Ethereum> {
1577        address: alloy_sol_types::private::Address,
1578        provider: P,
1579        _network: ::core::marker::PhantomData<N>,
1580    }
1581    #[automatically_derived]
1582    impl<P, N> ::core::fmt::Debug for IRewardClaimInstance<P, N> {
1583        #[inline]
1584        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1585            f.debug_tuple("IRewardClaimInstance").field(&self.address).finish()
1586        }
1587    }
1588    /// Instantiation and getters/setters.
1589    #[automatically_derived]
1590    impl<
1591        P: alloy_contract::private::Provider<N>,
1592        N: alloy_contract::private::Network,
1593    > IRewardClaimInstance<P, N> {
1594        /**Creates a new wrapper around an on-chain [`IRewardClaim`](self) contract instance.
1595
1596See the [wrapper's documentation](`IRewardClaimInstance`) for more details.*/
1597        #[inline]
1598        pub const fn new(
1599            address: alloy_sol_types::private::Address,
1600            provider: P,
1601        ) -> Self {
1602            Self {
1603                address,
1604                provider,
1605                _network: ::core::marker::PhantomData,
1606            }
1607        }
1608        /**Deploys this contract using the given `provider` and constructor arguments, if any.
1609
1610Returns a new instance of the contract, if the deployment was successful.
1611
1612For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1613        #[inline]
1614        pub async fn deploy(
1615            provider: P,
1616        ) -> alloy_contract::Result<IRewardClaimInstance<P, N>> {
1617            let call_builder = Self::deploy_builder(provider);
1618            let contract_address = call_builder.deploy().await?;
1619            Ok(Self::new(contract_address, call_builder.provider))
1620        }
1621        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1622and constructor arguments, if any.
1623
1624This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1625the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1626        #[inline]
1627        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
1628            alloy_contract::RawCallBuilder::new_raw_deploy(
1629                provider,
1630                ::core::clone::Clone::clone(&BYTECODE),
1631            )
1632        }
1633        /// Returns a reference to the address.
1634        #[inline]
1635        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1636            &self.address
1637        }
1638        /// Sets the address.
1639        #[inline]
1640        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1641            self.address = address;
1642        }
1643        /// Sets the address and returns `self`.
1644        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1645            self.set_address(address);
1646            self
1647        }
1648        /// Returns a reference to the provider.
1649        #[inline]
1650        pub const fn provider(&self) -> &P {
1651            &self.provider
1652        }
1653    }
1654    impl<P: ::core::clone::Clone, N> IRewardClaimInstance<&P, N> {
1655        /// Clones the provider and returns a new instance with the cloned provider.
1656        #[inline]
1657        pub fn with_cloned_provider(self) -> IRewardClaimInstance<P, N> {
1658            IRewardClaimInstance {
1659                address: self.address,
1660                provider: ::core::clone::Clone::clone(&self.provider),
1661                _network: ::core::marker::PhantomData,
1662            }
1663        }
1664    }
1665    /// Function calls.
1666    #[automatically_derived]
1667    impl<
1668        P: alloy_contract::private::Provider<N>,
1669        N: alloy_contract::private::Network,
1670    > IRewardClaimInstance<P, N> {
1671        /// Creates a new call builder using this contract instance's provider and address.
1672        ///
1673        /// Note that the call can be any function call, not just those defined in this
1674        /// contract. Prefer using the other methods for building type-safe contract calls.
1675        pub fn call_builder<C: alloy_sol_types::SolCall>(
1676            &self,
1677            call: &C,
1678        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1679            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1680        }
1681        ///Creates a new call builder for the [`claimRewards`] function.
1682        pub fn claimRewards(
1683            &self,
1684            lifetimeRewards: alloy::sol_types::private::primitives::aliases::U256,
1685            authData: alloy::sol_types::private::Bytes,
1686        ) -> alloy_contract::SolCallBuilder<&P, claimRewardsCall, N> {
1687            self.call_builder(
1688                &claimRewardsCall {
1689                    lifetimeRewards,
1690                    authData,
1691                },
1692            )
1693        }
1694        ///Creates a new call builder for the [`claimedRewards`] function.
1695        pub fn claimedRewards(
1696            &self,
1697            claimer: alloy::sol_types::private::Address,
1698        ) -> alloy_contract::SolCallBuilder<&P, claimedRewardsCall, N> {
1699            self.call_builder(&claimedRewardsCall { claimer })
1700        }
1701        ///Creates a new call builder for the [`totalClaimed`] function.
1702        pub fn totalClaimed(
1703            &self,
1704        ) -> alloy_contract::SolCallBuilder<&P, totalClaimedCall, N> {
1705            self.call_builder(&totalClaimedCall)
1706        }
1707    }
1708    /// Event filters.
1709    #[automatically_derived]
1710    impl<
1711        P: alloy_contract::private::Provider<N>,
1712        N: alloy_contract::private::Network,
1713    > IRewardClaimInstance<P, N> {
1714        /// Creates a new event filter using this contract instance's provider and address.
1715        ///
1716        /// Note that the type can be any event, not just those defined in this contract.
1717        /// Prefer using the other methods for building type-safe event filters.
1718        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1719            &self,
1720        ) -> alloy_contract::Event<&P, E, N> {
1721            alloy_contract::Event::new_sol(&self.provider, &self.address)
1722        }
1723        ///Creates a new event filter for the [`RewardsClaimed`] event.
1724        pub fn RewardsClaimed_filter(
1725            &self,
1726        ) -> alloy_contract::Event<&P, RewardsClaimed, N> {
1727            self.event_filter::<RewardsClaimed>()
1728        }
1729    }
1730}
hotshot_contract_adapter/bindings/i_reward_claim.rs

hotshot_contract_adapter/bindings/
i_reward_claim.rs
