hotshot_contract_adapter/bindings/
rewardclaimprototypemock.rs

1///Module containing a contract's types and functions.
2/**
3
4```solidity
5library RewardMerkleTreeVerifier {
6    struct AccruedRewardsProof { bytes32[] siblings; }
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 RewardMerkleTreeVerifier {
17    use super::*;
18    use alloy::sol_types as alloy_sol_types;
19    #[derive(Default, Debug, PartialEq, Eq, Hash)]
20    /**```solidity
21struct AccruedRewardsProof { bytes32[] siblings; }
22```*/
23    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
24    #[derive(Clone)]
25    pub struct AccruedRewardsProof {
26        #[allow(missing_docs)]
27        pub siblings: alloy::sol_types::private::Vec<
28            alloy::sol_types::private::FixedBytes<32>,
29        >,
30    }
31    #[allow(
32        non_camel_case_types,
33        non_snake_case,
34        clippy::pub_underscore_fields,
35        clippy::style
36    )]
37    const _: () = {
38        use alloy::sol_types as alloy_sol_types;
39        #[doc(hidden)]
40        type UnderlyingSolTuple<'a> = (
41            alloy::sol_types::sol_data::Array<
42                alloy::sol_types::sol_data::FixedBytes<32>,
43            >,
44        );
45        #[doc(hidden)]
46        type UnderlyingRustTuple<'a> = (
47            alloy::sol_types::private::Vec<alloy::sol_types::private::FixedBytes<32>>,
48        );
49        #[cfg(test)]
50        #[allow(dead_code, unreachable_patterns)]
51        fn _type_assertion(
52            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
53        ) {
54            match _t {
55                alloy_sol_types::private::AssertTypeEq::<
56                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
57                >(_) => {}
58            }
59        }
60        #[automatically_derived]
61        #[doc(hidden)]
62        impl ::core::convert::From<AccruedRewardsProof> for UnderlyingRustTuple<'_> {
63            fn from(value: AccruedRewardsProof) -> Self {
64                (value.siblings,)
65            }
66        }
67        #[automatically_derived]
68        #[doc(hidden)]
69        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AccruedRewardsProof {
70            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
71                Self { siblings: tuple.0 }
72            }
73        }
74        #[automatically_derived]
75        impl alloy_sol_types::SolValue for AccruedRewardsProof {
76            type SolType = Self;
77        }
78        #[automatically_derived]
79        impl alloy_sol_types::private::SolTypeValue<Self> for AccruedRewardsProof {
80            #[inline]
81            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
82                (
83                    <alloy::sol_types::sol_data::Array<
84                        alloy::sol_types::sol_data::FixedBytes<32>,
85                    > as alloy_sol_types::SolType>::tokenize(&self.siblings),
86                )
87            }
88            #[inline]
89            fn stv_abi_encoded_size(&self) -> usize {
90                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
91                    return size;
92                }
93                let tuple = <UnderlyingRustTuple<
94                    '_,
95                > as ::core::convert::From<Self>>::from(self.clone());
96                <UnderlyingSolTuple<
97                    '_,
98                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
99            }
100            #[inline]
101            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
102                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
103            }
104            #[inline]
105            fn stv_abi_encode_packed_to(
106                &self,
107                out: &mut alloy_sol_types::private::Vec<u8>,
108            ) {
109                let tuple = <UnderlyingRustTuple<
110                    '_,
111                > as ::core::convert::From<Self>>::from(self.clone());
112                <UnderlyingSolTuple<
113                    '_,
114                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
115            }
116            #[inline]
117            fn stv_abi_packed_encoded_size(&self) -> usize {
118                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
119                    return size;
120                }
121                let tuple = <UnderlyingRustTuple<
122                    '_,
123                > as ::core::convert::From<Self>>::from(self.clone());
124                <UnderlyingSolTuple<
125                    '_,
126                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
127            }
128        }
129        #[automatically_derived]
130        impl alloy_sol_types::SolType for AccruedRewardsProof {
131            type RustType = Self;
132            type Token<'a> = <UnderlyingSolTuple<
133                'a,
134            > as alloy_sol_types::SolType>::Token<'a>;
135            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
136            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
137                '_,
138            > as alloy_sol_types::SolType>::ENCODED_SIZE;
139            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
140                '_,
141            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
142            #[inline]
143            fn valid_token(token: &Self::Token<'_>) -> bool {
144                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
145            }
146            #[inline]
147            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
148                let tuple = <UnderlyingSolTuple<
149                    '_,
150                > as alloy_sol_types::SolType>::detokenize(token);
151                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
152            }
153        }
154        #[automatically_derived]
155        impl alloy_sol_types::SolStruct for AccruedRewardsProof {
156            const NAME: &'static str = "AccruedRewardsProof";
157            #[inline]
158            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
159                alloy_sol_types::private::Cow::Borrowed(
160                    "AccruedRewardsProof(bytes32[] siblings)",
161                )
162            }
163            #[inline]
164            fn eip712_components() -> alloy_sol_types::private::Vec<
165                alloy_sol_types::private::Cow<'static, str>,
166            > {
167                alloy_sol_types::private::Vec::new()
168            }
169            #[inline]
170            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
171                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
172            }
173            #[inline]
174            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
175                <alloy::sol_types::sol_data::Array<
176                    alloy::sol_types::sol_data::FixedBytes<32>,
177                > as alloy_sol_types::SolType>::eip712_data_word(&self.siblings)
178                    .0
179                    .to_vec()
180            }
181        }
182        #[automatically_derived]
183        impl alloy_sol_types::EventTopic for AccruedRewardsProof {
184            #[inline]
185            fn topic_preimage_length(rust: &Self::RustType) -> usize {
186                0usize
187                    + <alloy::sol_types::sol_data::Array<
188                        alloy::sol_types::sol_data::FixedBytes<32>,
189                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
190                        &rust.siblings,
191                    )
192            }
193            #[inline]
194            fn encode_topic_preimage(
195                rust: &Self::RustType,
196                out: &mut alloy_sol_types::private::Vec<u8>,
197            ) {
198                out.reserve(
199                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
200                );
201                <alloy::sol_types::sol_data::Array<
202                    alloy::sol_types::sol_data::FixedBytes<32>,
203                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
204                    &rust.siblings,
205                    out,
206                );
207            }
208            #[inline]
209            fn encode_topic(
210                rust: &Self::RustType,
211            ) -> alloy_sol_types::abi::token::WordToken {
212                let mut out = alloy_sol_types::private::Vec::new();
213                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
214                    rust,
215                    &mut out,
216                );
217                alloy_sol_types::abi::token::WordToken(
218                    alloy_sol_types::private::keccak256(out),
219                )
220            }
221        }
222    };
223    use alloy::contract as alloy_contract;
224    /**Creates a new wrapper around an on-chain [`RewardMerkleTreeVerifier`](self) contract instance.
225
226See the [wrapper's documentation](`RewardMerkleTreeVerifierInstance`) for more details.*/
227    #[inline]
228    pub const fn new<
229        T: alloy_contract::private::Transport + ::core::clone::Clone,
230        P: alloy_contract::private::Provider<T, N>,
231        N: alloy_contract::private::Network,
232    >(
233        address: alloy_sol_types::private::Address,
234        provider: P,
235    ) -> RewardMerkleTreeVerifierInstance<T, P, N> {
236        RewardMerkleTreeVerifierInstance::<T, P, N>::new(address, provider)
237    }
238    /**A [`RewardMerkleTreeVerifier`](self) instance.
239
240Contains type-safe methods for interacting with an on-chain instance of the
241[`RewardMerkleTreeVerifier`](self) contract located at a given `address`, using a given
242provider `P`.
243
244If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
245documentation on how to provide it), the `deploy` and `deploy_builder` methods can
246be used to deploy a new instance of the contract.
247
248See the [module-level documentation](self) for all the available methods.*/
249    #[derive(Clone)]
250    pub struct RewardMerkleTreeVerifierInstance<
251        T,
252        P,
253        N = alloy_contract::private::Ethereum,
254    > {
255        address: alloy_sol_types::private::Address,
256        provider: P,
257        _network_transport: ::core::marker::PhantomData<(N, T)>,
258    }
259    #[automatically_derived]
260    impl<T, P, N> ::core::fmt::Debug for RewardMerkleTreeVerifierInstance<T, P, N> {
261        #[inline]
262        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
263            f.debug_tuple("RewardMerkleTreeVerifierInstance")
264                .field(&self.address)
265                .finish()
266        }
267    }
268    /// Instantiation and getters/setters.
269    #[automatically_derived]
270    impl<
271        T: alloy_contract::private::Transport + ::core::clone::Clone,
272        P: alloy_contract::private::Provider<T, N>,
273        N: alloy_contract::private::Network,
274    > RewardMerkleTreeVerifierInstance<T, P, N> {
275        /**Creates a new wrapper around an on-chain [`RewardMerkleTreeVerifier`](self) contract instance.
276
277See the [wrapper's documentation](`RewardMerkleTreeVerifierInstance`) for more details.*/
278        #[inline]
279        pub const fn new(
280            address: alloy_sol_types::private::Address,
281            provider: P,
282        ) -> Self {
283            Self {
284                address,
285                provider,
286                _network_transport: ::core::marker::PhantomData,
287            }
288        }
289        /// Returns a reference to the address.
290        #[inline]
291        pub const fn address(&self) -> &alloy_sol_types::private::Address {
292            &self.address
293        }
294        /// Sets the address.
295        #[inline]
296        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
297            self.address = address;
298        }
299        /// Sets the address and returns `self`.
300        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
301            self.set_address(address);
302            self
303        }
304        /// Returns a reference to the provider.
305        #[inline]
306        pub const fn provider(&self) -> &P {
307            &self.provider
308        }
309    }
310    impl<T, P: ::core::clone::Clone, N> RewardMerkleTreeVerifierInstance<T, &P, N> {
311        /// Clones the provider and returns a new instance with the cloned provider.
312        #[inline]
313        pub fn with_cloned_provider(self) -> RewardMerkleTreeVerifierInstance<T, P, N> {
314            RewardMerkleTreeVerifierInstance {
315                address: self.address,
316                provider: ::core::clone::Clone::clone(&self.provider),
317                _network_transport: ::core::marker::PhantomData,
318            }
319        }
320    }
321    /// Function calls.
322    #[automatically_derived]
323    impl<
324        T: alloy_contract::private::Transport + ::core::clone::Clone,
325        P: alloy_contract::private::Provider<T, N>,
326        N: alloy_contract::private::Network,
327    > RewardMerkleTreeVerifierInstance<T, P, N> {
328        /// Creates a new call builder using this contract instance's provider and address.
329        ///
330        /// Note that the call can be any function call, not just those defined in this
331        /// contract. Prefer using the other methods for building type-safe contract calls.
332        pub fn call_builder<C: alloy_sol_types::SolCall>(
333            &self,
334            call: &C,
335        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
336            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
337        }
338    }
339    /// Event filters.
340    #[automatically_derived]
341    impl<
342        T: alloy_contract::private::Transport + ::core::clone::Clone,
343        P: alloy_contract::private::Provider<T, N>,
344        N: alloy_contract::private::Network,
345    > RewardMerkleTreeVerifierInstance<T, P, N> {
346        /// Creates a new event filter using this contract instance's provider and address.
347        ///
348        /// Note that the type can be any event, not just those defined in this contract.
349        /// Prefer using the other methods for building type-safe event filters.
350        pub fn event_filter<E: alloy_sol_types::SolEvent>(
351            &self,
352        ) -> alloy_contract::Event<T, &P, E, N> {
353            alloy_contract::Event::new_sol(&self.provider, &self.address)
354        }
355    }
356}
357/**
358
359Generated by the following Solidity interface...
360```solidity
361library RewardMerkleTreeVerifier {
362    struct AccruedRewardsProof {
363        bytes32[] siblings;
364    }
365}
366
367interface RewardClaimPrototypeMock {
368    error InvalidProofLength();
369
370    function verifyRewardClaim(bytes32 root, address account, uint256 amount, RewardMerkleTreeVerifier.AccruedRewardsProof memory proof) external pure returns (bool);
371}
372```
373
374...which was generated by the following JSON ABI:
375```json
376[
377  {
378    "type": "function",
379    "name": "verifyRewardClaim",
380    "inputs": [
381      {
382        "name": "root",
383        "type": "bytes32",
384        "internalType": "bytes32"
385      },
386      {
387        "name": "account",
388        "type": "address",
389        "internalType": "address"
390      },
391      {
392        "name": "amount",
393        "type": "uint256",
394        "internalType": "uint256"
395      },
396      {
397        "name": "proof",
398        "type": "tuple",
399        "internalType": "struct RewardMerkleTreeVerifier.AccruedRewardsProof",
400        "components": [
401          {
402            "name": "siblings",
403            "type": "bytes32[]",
404            "internalType": "bytes32[]"
405          }
406        ]
407      }
408    ],
409    "outputs": [
410      {
411        "name": "",
412        "type": "bool",
413        "internalType": "bool"
414      }
415    ],
416    "stateMutability": "pure"
417  },
418  {
419    "type": "error",
420    "name": "InvalidProofLength",
421    "inputs": []
422  }
423]
424```*/
425#[allow(
426    non_camel_case_types,
427    non_snake_case,
428    clippy::pub_underscore_fields,
429    clippy::style,
430    clippy::empty_structs_with_brackets
431)]
432pub mod RewardClaimPrototypeMock {
433    use super::*;
434    use alloy::sol_types as alloy_sol_types;
435    /// The creation / init bytecode of the contract.
436    ///
437    /// ```text
438    ///0x6080604052348015600e575f5ffd5b506102468061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80634c6d20d21461002d575b5f5ffd5b61004061003b36600461016a565b610054565b604051901515815260200160405180910390f35b5f6100618585858561006a565b95945050505050565b5f368161007784806101d8565b909250905060a0811461009d576040516313717da960e21b815260040160405180910390fd5b5f6100a78661011e565b90505f5b60a0811015610110575f8484838181106100c7576100c7610225565b6020029190910135915050600189831c1680156100f4576040805183815260208101869052209350610106565b60408051858152602081018490522093505b50506001016100ab565b509096149695505050505050565b5f5f8260405160200161013391815260200190565b60408051808303601f1901815282825280516020918201208184015281518084038201815292820190915281519101209392505050565b5f5f5f5f6080858703121561017d575f5ffd5b8435935060208501356001600160a01b038116811461019a575f5ffd5b925060408501359150606085013567ffffffffffffffff8111156101bc575f5ffd5b8501602081880312156101cd575f5ffd5b939692955090935050565b5f5f8335601e198436030181126101ed575f5ffd5b83018035915067ffffffffffffffff821115610207575f5ffd5b6020019150600581901b360382131561021e575f5ffd5b9250929050565b634e487b7160e01b5f52603260045260245ffdfea164736f6c634300081c000a
439    /// ```
440    #[rustfmt::skip]
441    #[allow(clippy::all)]
442    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
443        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x02F\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80cLm \xD2\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x01jV[a\0TV[`@Q\x90\x15\x15\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_a\0a\x85\x85\x85\x85a\0jV[\x95\x94PPPPPV[_6\x81a\0w\x84\x80a\x01\xD8V[\x90\x92P\x90P`\xA0\x81\x14a\0\x9DW`@Qc\x13q}\xA9`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\0\xA7\x86a\x01\x1EV[\x90P_[`\xA0\x81\x10\x15a\x01\x10W_\x84\x84\x83\x81\x81\x10a\0\xC7Wa\0\xC7a\x02%V[` \x02\x91\x90\x91\x015\x91PP`\x01\x89\x83\x1C\x16\x80\x15a\0\xF4W`@\x80Q\x83\x81R` \x81\x01\x86\x90R \x93Pa\x01\x06V[`@\x80Q\x85\x81R` \x81\x01\x84\x90R \x93P[PP`\x01\x01a\0\xABV[P\x90\x96\x14\x96\x95PPPPPPV[__\x82`@Q` \x01a\x013\x91\x81R` \x01\x90V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x82\x82R\x80Q` \x91\x82\x01 \x81\x84\x01R\x81Q\x80\x84\x03\x82\x01\x81R\x92\x82\x01\x90\x91R\x81Q\x91\x01 \x93\x92PPPV[____`\x80\x85\x87\x03\x12\x15a\x01}W__\xFD[\x845\x93P` \x85\x015`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x01\x9AW__\xFD[\x92P`@\x85\x015\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\xBCW__\xFD[\x85\x01` \x81\x88\x03\x12\x15a\x01\xCDW__\xFD[\x93\x96\x92\x95P\x90\x93PPV[__\x835`\x1E\x19\x846\x03\x01\x81\x12a\x01\xEDW__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x02\x07W__\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a\x02\x1EW__\xFD[\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD\xFE\xA1dsolcC\0\x08\x1C\0\n",
444    );
445    /// The runtime bytecode of the contract, as deployed on the network.
446    ///
447    /// ```text
448    ///0x608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80634c6d20d21461002d575b5f5ffd5b61004061003b36600461016a565b610054565b604051901515815260200160405180910390f35b5f6100618585858561006a565b95945050505050565b5f368161007784806101d8565b909250905060a0811461009d576040516313717da960e21b815260040160405180910390fd5b5f6100a78661011e565b90505f5b60a0811015610110575f8484838181106100c7576100c7610225565b6020029190910135915050600189831c1680156100f4576040805183815260208101869052209350610106565b60408051858152602081018490522093505b50506001016100ab565b509096149695505050505050565b5f5f8260405160200161013391815260200190565b60408051808303601f1901815282825280516020918201208184015281518084038201815292820190915281519101209392505050565b5f5f5f5f6080858703121561017d575f5ffd5b8435935060208501356001600160a01b038116811461019a575f5ffd5b925060408501359150606085013567ffffffffffffffff8111156101bc575f5ffd5b8501602081880312156101cd575f5ffd5b939692955090935050565b5f5f8335601e198436030181126101ed575f5ffd5b83018035915067ffffffffffffffff821115610207575f5ffd5b6020019150600581901b360382131561021e575f5ffd5b9250929050565b634e487b7160e01b5f52603260045260245ffdfea164736f6c634300081c000a
449    /// ```
450    #[rustfmt::skip]
451    #[allow(clippy::all)]
452    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
453        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80cLm \xD2\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x01jV[a\0TV[`@Q\x90\x15\x15\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_a\0a\x85\x85\x85\x85a\0jV[\x95\x94PPPPPV[_6\x81a\0w\x84\x80a\x01\xD8V[\x90\x92P\x90P`\xA0\x81\x14a\0\x9DW`@Qc\x13q}\xA9`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\0\xA7\x86a\x01\x1EV[\x90P_[`\xA0\x81\x10\x15a\x01\x10W_\x84\x84\x83\x81\x81\x10a\0\xC7Wa\0\xC7a\x02%V[` \x02\x91\x90\x91\x015\x91PP`\x01\x89\x83\x1C\x16\x80\x15a\0\xF4W`@\x80Q\x83\x81R` \x81\x01\x86\x90R \x93Pa\x01\x06V[`@\x80Q\x85\x81R` \x81\x01\x84\x90R \x93P[PP`\x01\x01a\0\xABV[P\x90\x96\x14\x96\x95PPPPPPV[__\x82`@Q` \x01a\x013\x91\x81R` \x01\x90V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x82\x82R\x80Q` \x91\x82\x01 \x81\x84\x01R\x81Q\x80\x84\x03\x82\x01\x81R\x92\x82\x01\x90\x91R\x81Q\x91\x01 \x93\x92PPPV[____`\x80\x85\x87\x03\x12\x15a\x01}W__\xFD[\x845\x93P` \x85\x015`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x01\x9AW__\xFD[\x92P`@\x85\x015\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\xBCW__\xFD[\x85\x01` \x81\x88\x03\x12\x15a\x01\xCDW__\xFD[\x93\x96\x92\x95P\x90\x93PPV[__\x835`\x1E\x19\x846\x03\x01\x81\x12a\x01\xEDW__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x02\x07W__\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a\x02\x1EW__\xFD[\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD\xFE\xA1dsolcC\0\x08\x1C\0\n",
454    );
455    #[derive(Default, Debug, PartialEq, Eq, Hash)]
456    /**Custom error with signature `InvalidProofLength()` and selector `0x4dc5f6a4`.
457```solidity
458error InvalidProofLength();
459```*/
460    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
461    #[derive(Clone)]
462    pub struct InvalidProofLength {}
463    #[allow(
464        non_camel_case_types,
465        non_snake_case,
466        clippy::pub_underscore_fields,
467        clippy::style
468    )]
469    const _: () = {
470        use alloy::sol_types as alloy_sol_types;
471        #[doc(hidden)]
472        type UnderlyingSolTuple<'a> = ();
473        #[doc(hidden)]
474        type UnderlyingRustTuple<'a> = ();
475        #[cfg(test)]
476        #[allow(dead_code, unreachable_patterns)]
477        fn _type_assertion(
478            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
479        ) {
480            match _t {
481                alloy_sol_types::private::AssertTypeEq::<
482                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
483                >(_) => {}
484            }
485        }
486        #[automatically_derived]
487        #[doc(hidden)]
488        impl ::core::convert::From<InvalidProofLength> for UnderlyingRustTuple<'_> {
489            fn from(value: InvalidProofLength) -> Self {
490                ()
491            }
492        }
493        #[automatically_derived]
494        #[doc(hidden)]
495        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidProofLength {
496            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
497                Self {}
498            }
499        }
500        #[automatically_derived]
501        impl alloy_sol_types::SolError for InvalidProofLength {
502            type Parameters<'a> = UnderlyingSolTuple<'a>;
503            type Token<'a> = <Self::Parameters<
504                'a,
505            > as alloy_sol_types::SolType>::Token<'a>;
506            const SIGNATURE: &'static str = "InvalidProofLength()";
507            const SELECTOR: [u8; 4] = [77u8, 197u8, 246u8, 164u8];
508            #[inline]
509            fn new<'a>(
510                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
511            ) -> Self {
512                tuple.into()
513            }
514            #[inline]
515            fn tokenize(&self) -> Self::Token<'_> {
516                ()
517            }
518        }
519    };
520    #[derive(Default, Debug, PartialEq, Eq, Hash)]
521    /**Function with signature `verifyRewardClaim(bytes32,address,uint256,(bytes32[]))` and selector `0x4c6d20d2`.
522```solidity
523function verifyRewardClaim(bytes32 root, address account, uint256 amount, RewardMerkleTreeVerifier.AccruedRewardsProof memory proof) external pure returns (bool);
524```*/
525    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
526    #[derive(Clone)]
527    pub struct verifyRewardClaimCall {
528        #[allow(missing_docs)]
529        pub root: alloy::sol_types::private::FixedBytes<32>,
530        #[allow(missing_docs)]
531        pub account: alloy::sol_types::private::Address,
532        #[allow(missing_docs)]
533        pub amount: alloy::sol_types::private::primitives::aliases::U256,
534        #[allow(missing_docs)]
535        pub proof: <RewardMerkleTreeVerifier::AccruedRewardsProof as alloy::sol_types::SolType>::RustType,
536    }
537    #[derive(Default, Debug, PartialEq, Eq, Hash)]
538    ///Container type for the return parameters of the [`verifyRewardClaim(bytes32,address,uint256,(bytes32[]))`](verifyRewardClaimCall) function.
539    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
540    #[derive(Clone)]
541    pub struct verifyRewardClaimReturn {
542        #[allow(missing_docs)]
543        pub _0: bool,
544    }
545    #[allow(
546        non_camel_case_types,
547        non_snake_case,
548        clippy::pub_underscore_fields,
549        clippy::style
550    )]
551    const _: () = {
552        use alloy::sol_types as alloy_sol_types;
553        {
554            #[doc(hidden)]
555            type UnderlyingSolTuple<'a> = (
556                alloy::sol_types::sol_data::FixedBytes<32>,
557                alloy::sol_types::sol_data::Address,
558                alloy::sol_types::sol_data::Uint<256>,
559                RewardMerkleTreeVerifier::AccruedRewardsProof,
560            );
561            #[doc(hidden)]
562            type UnderlyingRustTuple<'a> = (
563                alloy::sol_types::private::FixedBytes<32>,
564                alloy::sol_types::private::Address,
565                alloy::sol_types::private::primitives::aliases::U256,
566                <RewardMerkleTreeVerifier::AccruedRewardsProof as alloy::sol_types::SolType>::RustType,
567            );
568            #[cfg(test)]
569            #[allow(dead_code, unreachable_patterns)]
570            fn _type_assertion(
571                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
572            ) {
573                match _t {
574                    alloy_sol_types::private::AssertTypeEq::<
575                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
576                    >(_) => {}
577                }
578            }
579            #[automatically_derived]
580            #[doc(hidden)]
581            impl ::core::convert::From<verifyRewardClaimCall>
582            for UnderlyingRustTuple<'_> {
583                fn from(value: verifyRewardClaimCall) -> Self {
584                    (value.root, value.account, value.amount, value.proof)
585                }
586            }
587            #[automatically_derived]
588            #[doc(hidden)]
589            impl ::core::convert::From<UnderlyingRustTuple<'_>>
590            for verifyRewardClaimCall {
591                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
592                    Self {
593                        root: tuple.0,
594                        account: tuple.1,
595                        amount: tuple.2,
596                        proof: tuple.3,
597                    }
598                }
599            }
600        }
601        {
602            #[doc(hidden)]
603            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
604            #[doc(hidden)]
605            type UnderlyingRustTuple<'a> = (bool,);
606            #[cfg(test)]
607            #[allow(dead_code, unreachable_patterns)]
608            fn _type_assertion(
609                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
610            ) {
611                match _t {
612                    alloy_sol_types::private::AssertTypeEq::<
613                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
614                    >(_) => {}
615                }
616            }
617            #[automatically_derived]
618            #[doc(hidden)]
619            impl ::core::convert::From<verifyRewardClaimReturn>
620            for UnderlyingRustTuple<'_> {
621                fn from(value: verifyRewardClaimReturn) -> Self {
622                    (value._0,)
623                }
624            }
625            #[automatically_derived]
626            #[doc(hidden)]
627            impl ::core::convert::From<UnderlyingRustTuple<'_>>
628            for verifyRewardClaimReturn {
629                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
630                    Self { _0: tuple.0 }
631                }
632            }
633        }
634        #[automatically_derived]
635        impl alloy_sol_types::SolCall for verifyRewardClaimCall {
636            type Parameters<'a> = (
637                alloy::sol_types::sol_data::FixedBytes<32>,
638                alloy::sol_types::sol_data::Address,
639                alloy::sol_types::sol_data::Uint<256>,
640                RewardMerkleTreeVerifier::AccruedRewardsProof,
641            );
642            type Token<'a> = <Self::Parameters<
643                'a,
644            > as alloy_sol_types::SolType>::Token<'a>;
645            type Return = verifyRewardClaimReturn;
646            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
647            type ReturnToken<'a> = <Self::ReturnTuple<
648                'a,
649            > as alloy_sol_types::SolType>::Token<'a>;
650            const SIGNATURE: &'static str = "verifyRewardClaim(bytes32,address,uint256,(bytes32[]))";
651            const SELECTOR: [u8; 4] = [76u8, 109u8, 32u8, 210u8];
652            #[inline]
653            fn new<'a>(
654                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
655            ) -> Self {
656                tuple.into()
657            }
658            #[inline]
659            fn tokenize(&self) -> Self::Token<'_> {
660                (
661                    <alloy::sol_types::sol_data::FixedBytes<
662                        32,
663                    > as alloy_sol_types::SolType>::tokenize(&self.root),
664                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
665                        &self.account,
666                    ),
667                    <alloy::sol_types::sol_data::Uint<
668                        256,
669                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
670                    <RewardMerkleTreeVerifier::AccruedRewardsProof as alloy_sol_types::SolType>::tokenize(
671                        &self.proof,
672                    ),
673                )
674            }
675            #[inline]
676            fn abi_decode_returns(
677                data: &[u8],
678                validate: bool,
679            ) -> alloy_sol_types::Result<Self::Return> {
680                <Self::ReturnTuple<
681                    '_,
682                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
683                    .map(Into::into)
684            }
685        }
686    };
687    ///Container for all the [`RewardClaimPrototypeMock`](self) function calls.
688    #[derive()]
689    pub enum RewardClaimPrototypeMockCalls {
690        #[allow(missing_docs)]
691        verifyRewardClaim(verifyRewardClaimCall),
692    }
693    #[automatically_derived]
694    impl RewardClaimPrototypeMockCalls {
695        /// All the selectors of this enum.
696        ///
697        /// Note that the selectors might not be in the same order as the variants.
698        /// No guarantees are made about the order of the selectors.
699        ///
700        /// Prefer using `SolInterface` methods instead.
701        pub const SELECTORS: &'static [[u8; 4usize]] = &[[76u8, 109u8, 32u8, 210u8]];
702    }
703    #[automatically_derived]
704    impl alloy_sol_types::SolInterface for RewardClaimPrototypeMockCalls {
705        const NAME: &'static str = "RewardClaimPrototypeMockCalls";
706        const MIN_DATA_LENGTH: usize = 160usize;
707        const COUNT: usize = 1usize;
708        #[inline]
709        fn selector(&self) -> [u8; 4] {
710            match self {
711                Self::verifyRewardClaim(_) => {
712                    <verifyRewardClaimCall as alloy_sol_types::SolCall>::SELECTOR
713                }
714            }
715        }
716        #[inline]
717        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
718            Self::SELECTORS.get(i).copied()
719        }
720        #[inline]
721        fn valid_selector(selector: [u8; 4]) -> bool {
722            Self::SELECTORS.binary_search(&selector).is_ok()
723        }
724        #[inline]
725        #[allow(non_snake_case)]
726        fn abi_decode_raw(
727            selector: [u8; 4],
728            data: &[u8],
729            validate: bool,
730        ) -> alloy_sol_types::Result<Self> {
731            static DECODE_SHIMS: &[fn(
732                &[u8],
733                bool,
734            ) -> alloy_sol_types::Result<RewardClaimPrototypeMockCalls>] = &[
735                {
736                    fn verifyRewardClaim(
737                        data: &[u8],
738                        validate: bool,
739                    ) -> alloy_sol_types::Result<RewardClaimPrototypeMockCalls> {
740                        <verifyRewardClaimCall as alloy_sol_types::SolCall>::abi_decode_raw(
741                                data,
742                                validate,
743                            )
744                            .map(RewardClaimPrototypeMockCalls::verifyRewardClaim)
745                    }
746                    verifyRewardClaim
747                },
748            ];
749            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
750                return Err(
751                    alloy_sol_types::Error::unknown_selector(
752                        <Self as alloy_sol_types::SolInterface>::NAME,
753                        selector,
754                    ),
755                );
756            };
757            DECODE_SHIMS[idx](data, validate)
758        }
759        #[inline]
760        fn abi_encoded_size(&self) -> usize {
761            match self {
762                Self::verifyRewardClaim(inner) => {
763                    <verifyRewardClaimCall as alloy_sol_types::SolCall>::abi_encoded_size(
764                        inner,
765                    )
766                }
767            }
768        }
769        #[inline]
770        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
771            match self {
772                Self::verifyRewardClaim(inner) => {
773                    <verifyRewardClaimCall as alloy_sol_types::SolCall>::abi_encode_raw(
774                        inner,
775                        out,
776                    )
777                }
778            }
779        }
780    }
781    ///Container for all the [`RewardClaimPrototypeMock`](self) custom errors.
782    #[derive(Debug, PartialEq, Eq, Hash)]
783    pub enum RewardClaimPrototypeMockErrors {
784        #[allow(missing_docs)]
785        InvalidProofLength(InvalidProofLength),
786    }
787    #[automatically_derived]
788    impl RewardClaimPrototypeMockErrors {
789        /// All the selectors of this enum.
790        ///
791        /// Note that the selectors might not be in the same order as the variants.
792        /// No guarantees are made about the order of the selectors.
793        ///
794        /// Prefer using `SolInterface` methods instead.
795        pub const SELECTORS: &'static [[u8; 4usize]] = &[[77u8, 197u8, 246u8, 164u8]];
796    }
797    #[automatically_derived]
798    impl alloy_sol_types::SolInterface for RewardClaimPrototypeMockErrors {
799        const NAME: &'static str = "RewardClaimPrototypeMockErrors";
800        const MIN_DATA_LENGTH: usize = 0usize;
801        const COUNT: usize = 1usize;
802        #[inline]
803        fn selector(&self) -> [u8; 4] {
804            match self {
805                Self::InvalidProofLength(_) => {
806                    <InvalidProofLength as alloy_sol_types::SolError>::SELECTOR
807                }
808            }
809        }
810        #[inline]
811        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
812            Self::SELECTORS.get(i).copied()
813        }
814        #[inline]
815        fn valid_selector(selector: [u8; 4]) -> bool {
816            Self::SELECTORS.binary_search(&selector).is_ok()
817        }
818        #[inline]
819        #[allow(non_snake_case)]
820        fn abi_decode_raw(
821            selector: [u8; 4],
822            data: &[u8],
823            validate: bool,
824        ) -> alloy_sol_types::Result<Self> {
825            static DECODE_SHIMS: &[fn(
826                &[u8],
827                bool,
828            ) -> alloy_sol_types::Result<RewardClaimPrototypeMockErrors>] = &[
829                {
830                    fn InvalidProofLength(
831                        data: &[u8],
832                        validate: bool,
833                    ) -> alloy_sol_types::Result<RewardClaimPrototypeMockErrors> {
834                        <InvalidProofLength as alloy_sol_types::SolError>::abi_decode_raw(
835                                data,
836                                validate,
837                            )
838                            .map(RewardClaimPrototypeMockErrors::InvalidProofLength)
839                    }
840                    InvalidProofLength
841                },
842            ];
843            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
844                return Err(
845                    alloy_sol_types::Error::unknown_selector(
846                        <Self as alloy_sol_types::SolInterface>::NAME,
847                        selector,
848                    ),
849                );
850            };
851            DECODE_SHIMS[idx](data, validate)
852        }
853        #[inline]
854        fn abi_encoded_size(&self) -> usize {
855            match self {
856                Self::InvalidProofLength(inner) => {
857                    <InvalidProofLength as alloy_sol_types::SolError>::abi_encoded_size(
858                        inner,
859                    )
860                }
861            }
862        }
863        #[inline]
864        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
865            match self {
866                Self::InvalidProofLength(inner) => {
867                    <InvalidProofLength as alloy_sol_types::SolError>::abi_encode_raw(
868                        inner,
869                        out,
870                    )
871                }
872            }
873        }
874    }
875    use alloy::contract as alloy_contract;
876    /**Creates a new wrapper around an on-chain [`RewardClaimPrototypeMock`](self) contract instance.
877
878See the [wrapper's documentation](`RewardClaimPrototypeMockInstance`) for more details.*/
879    #[inline]
880    pub const fn new<
881        T: alloy_contract::private::Transport + ::core::clone::Clone,
882        P: alloy_contract::private::Provider<T, N>,
883        N: alloy_contract::private::Network,
884    >(
885        address: alloy_sol_types::private::Address,
886        provider: P,
887    ) -> RewardClaimPrototypeMockInstance<T, P, N> {
888        RewardClaimPrototypeMockInstance::<T, P, N>::new(address, provider)
889    }
890    /**Deploys this contract using the given `provider` and constructor arguments, if any.
891
892Returns a new instance of the contract, if the deployment was successful.
893
894For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
895    #[inline]
896    pub fn deploy<
897        T: alloy_contract::private::Transport + ::core::clone::Clone,
898        P: alloy_contract::private::Provider<T, N>,
899        N: alloy_contract::private::Network,
900    >(
901        provider: P,
902    ) -> impl ::core::future::Future<
903        Output = alloy_contract::Result<RewardClaimPrototypeMockInstance<T, P, N>>,
904    > {
905        RewardClaimPrototypeMockInstance::<T, P, N>::deploy(provider)
906    }
907    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
908and constructor arguments, if any.
909
910This is a simple wrapper around creating a `RawCallBuilder` with the data set to
911the bytecode concatenated with the constructor's ABI-encoded arguments.*/
912    #[inline]
913    pub fn deploy_builder<
914        T: alloy_contract::private::Transport + ::core::clone::Clone,
915        P: alloy_contract::private::Provider<T, N>,
916        N: alloy_contract::private::Network,
917    >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
918        RewardClaimPrototypeMockInstance::<T, P, N>::deploy_builder(provider)
919    }
920    /**A [`RewardClaimPrototypeMock`](self) instance.
921
922Contains type-safe methods for interacting with an on-chain instance of the
923[`RewardClaimPrototypeMock`](self) contract located at a given `address`, using a given
924provider `P`.
925
926If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
927documentation on how to provide it), the `deploy` and `deploy_builder` methods can
928be used to deploy a new instance of the contract.
929
930See the [module-level documentation](self) for all the available methods.*/
931    #[derive(Clone)]
932    pub struct RewardClaimPrototypeMockInstance<
933        T,
934        P,
935        N = alloy_contract::private::Ethereum,
936    > {
937        address: alloy_sol_types::private::Address,
938        provider: P,
939        _network_transport: ::core::marker::PhantomData<(N, T)>,
940    }
941    #[automatically_derived]
942    impl<T, P, N> ::core::fmt::Debug for RewardClaimPrototypeMockInstance<T, P, N> {
943        #[inline]
944        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
945            f.debug_tuple("RewardClaimPrototypeMockInstance")
946                .field(&self.address)
947                .finish()
948        }
949    }
950    /// Instantiation and getters/setters.
951    #[automatically_derived]
952    impl<
953        T: alloy_contract::private::Transport + ::core::clone::Clone,
954        P: alloy_contract::private::Provider<T, N>,
955        N: alloy_contract::private::Network,
956    > RewardClaimPrototypeMockInstance<T, P, N> {
957        /**Creates a new wrapper around an on-chain [`RewardClaimPrototypeMock`](self) contract instance.
958
959See the [wrapper's documentation](`RewardClaimPrototypeMockInstance`) for more details.*/
960        #[inline]
961        pub const fn new(
962            address: alloy_sol_types::private::Address,
963            provider: P,
964        ) -> Self {
965            Self {
966                address,
967                provider,
968                _network_transport: ::core::marker::PhantomData,
969            }
970        }
971        /**Deploys this contract using the given `provider` and constructor arguments, if any.
972
973Returns a new instance of the contract, if the deployment was successful.
974
975For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
976        #[inline]
977        pub async fn deploy(
978            provider: P,
979        ) -> alloy_contract::Result<RewardClaimPrototypeMockInstance<T, P, N>> {
980            let call_builder = Self::deploy_builder(provider);
981            let contract_address = call_builder.deploy().await?;
982            Ok(Self::new(contract_address, call_builder.provider))
983        }
984        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
985and constructor arguments, if any.
986
987This is a simple wrapper around creating a `RawCallBuilder` with the data set to
988the bytecode concatenated with the constructor's ABI-encoded arguments.*/
989        #[inline]
990        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
991            alloy_contract::RawCallBuilder::new_raw_deploy(
992                provider,
993                ::core::clone::Clone::clone(&BYTECODE),
994            )
995        }
996        /// Returns a reference to the address.
997        #[inline]
998        pub const fn address(&self) -> &alloy_sol_types::private::Address {
999            &self.address
1000        }
1001        /// Sets the address.
1002        #[inline]
1003        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1004            self.address = address;
1005        }
1006        /// Sets the address and returns `self`.
1007        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1008            self.set_address(address);
1009            self
1010        }
1011        /// Returns a reference to the provider.
1012        #[inline]
1013        pub const fn provider(&self) -> &P {
1014            &self.provider
1015        }
1016    }
1017    impl<T, P: ::core::clone::Clone, N> RewardClaimPrototypeMockInstance<T, &P, N> {
1018        /// Clones the provider and returns a new instance with the cloned provider.
1019        #[inline]
1020        pub fn with_cloned_provider(self) -> RewardClaimPrototypeMockInstance<T, P, N> {
1021            RewardClaimPrototypeMockInstance {
1022                address: self.address,
1023                provider: ::core::clone::Clone::clone(&self.provider),
1024                _network_transport: ::core::marker::PhantomData,
1025            }
1026        }
1027    }
1028    /// Function calls.
1029    #[automatically_derived]
1030    impl<
1031        T: alloy_contract::private::Transport + ::core::clone::Clone,
1032        P: alloy_contract::private::Provider<T, N>,
1033        N: alloy_contract::private::Network,
1034    > RewardClaimPrototypeMockInstance<T, P, N> {
1035        /// Creates a new call builder using this contract instance's provider and address.
1036        ///
1037        /// Note that the call can be any function call, not just those defined in this
1038        /// contract. Prefer using the other methods for building type-safe contract calls.
1039        pub fn call_builder<C: alloy_sol_types::SolCall>(
1040            &self,
1041            call: &C,
1042        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
1043            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1044        }
1045        ///Creates a new call builder for the [`verifyRewardClaim`] function.
1046        pub fn verifyRewardClaim(
1047            &self,
1048            root: alloy::sol_types::private::FixedBytes<32>,
1049            account: alloy::sol_types::private::Address,
1050            amount: alloy::sol_types::private::primitives::aliases::U256,
1051            proof: <RewardMerkleTreeVerifier::AccruedRewardsProof as alloy::sol_types::SolType>::RustType,
1052        ) -> alloy_contract::SolCallBuilder<T, &P, verifyRewardClaimCall, N> {
1053            self.call_builder(
1054                &verifyRewardClaimCall {
1055                    root,
1056                    account,
1057                    amount,
1058                    proof,
1059                },
1060            )
1061        }
1062    }
1063    /// Event filters.
1064    #[automatically_derived]
1065    impl<
1066        T: alloy_contract::private::Transport + ::core::clone::Clone,
1067        P: alloy_contract::private::Provider<T, N>,
1068        N: alloy_contract::private::Network,
1069    > RewardClaimPrototypeMockInstance<T, P, N> {
1070        /// Creates a new event filter using this contract instance's provider and address.
1071        ///
1072        /// Note that the type can be any event, not just those defined in this contract.
1073        /// Prefer using the other methods for building type-safe event filters.
1074        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1075            &self,
1076        ) -> alloy_contract::Event<T, &P, E, N> {
1077            alloy_contract::Event::new_sol(&self.provider, &self.address)
1078        }
1079    }
1080}
hotshot_contract_adapter/bindings/rewardclaimprototypemock.rs

hotshot_contract_adapter/bindings/
rewardclaimprototypemock.rs
