pod_contracts/
icounter.rs

1/**
2
3Generated by the following Solidity interface...
4```solidity
5interface ICounter {
6    function increment(bytes32 key, uint256 value) external;
7    function requireGte(bytes32 key, uint256 value) external view;
8}
9```
10
11...which was generated by the following JSON ABI:
12```json
13[
14  {
15    "type": "function",
16    "name": "increment",
17    "inputs": [
18      {
19        "name": "key",
20        "type": "bytes32",
21        "internalType": "bytes32"
22      },
23      {
24        "name": "value",
25        "type": "uint256",
26        "internalType": "uint256"
27      }
28    ],
29    "outputs": [],
30    "stateMutability": "nonpayable"
31  },
32  {
33    "type": "function",
34    "name": "requireGte",
35    "inputs": [
36      {
37        "name": "key",
38        "type": "bytes32",
39        "internalType": "bytes32"
40      },
41      {
42        "name": "value",
43        "type": "uint256",
44        "internalType": "uint256"
45      }
46    ],
47    "outputs": [],
48    "stateMutability": "view"
49  }
50]
51```*/
52#[allow(
53    non_camel_case_types,
54    non_snake_case,
55    clippy::pub_underscore_fields,
56    clippy::style,
57    clippy::empty_structs_with_brackets
58)]
59pub mod ICounter {
60    use super::*;
61    use alloy::sol_types as alloy_sol_types;
62    /// The creation / init bytecode of the contract.
63    ///
64    /// ```text
65    ///0x
66    /// ```
67    #[rustfmt::skip]
68    #[allow(clippy::all)]
69    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
70        b"",
71    );
72    /// The runtime bytecode of the contract, as deployed on the network.
73    ///
74    /// ```text
75    ///0x
76    /// ```
77    #[rustfmt::skip]
78    #[allow(clippy::all)]
79    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
80        b"",
81    );
82    #[derive(Default, Debug, PartialEq, Eq, Hash)]
83    /**Function with signature `increment(bytes32,uint256)` and selector `0x0affc437`.
84```solidity
85function increment(bytes32 key, uint256 value) external;
86```*/
87    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
88    #[derive(Clone)]
89    pub struct incrementCall {
90        #[allow(missing_docs)]
91        pub key: alloy::sol_types::private::FixedBytes<32>,
92        #[allow(missing_docs)]
93        pub value: alloy::sol_types::private::primitives::aliases::U256,
94    }
95    ///Container type for the return parameters of the [`increment(bytes32,uint256)`](incrementCall) function.
96    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
97    #[derive(Clone)]
98    pub struct incrementReturn {}
99    #[allow(
100        non_camel_case_types,
101        non_snake_case,
102        clippy::pub_underscore_fields,
103        clippy::style
104    )]
105    const _: () = {
106        use alloy::sol_types as alloy_sol_types;
107        {
108            #[doc(hidden)]
109            type UnderlyingSolTuple<'a> = (
110                alloy::sol_types::sol_data::FixedBytes<32>,
111                alloy::sol_types::sol_data::Uint<256>,
112            );
113            #[doc(hidden)]
114            type UnderlyingRustTuple<'a> = (
115                alloy::sol_types::private::FixedBytes<32>,
116                alloy::sol_types::private::primitives::aliases::U256,
117            );
118            #[cfg(test)]
119            #[allow(dead_code, unreachable_patterns)]
120            fn _type_assertion(
121                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
122            ) {
123                match _t {
124                    alloy_sol_types::private::AssertTypeEq::<
125                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
126                    >(_) => {}
127                }
128            }
129            #[automatically_derived]
130            #[doc(hidden)]
131            impl ::core::convert::From<incrementCall> for UnderlyingRustTuple<'_> {
132                fn from(value: incrementCall) -> Self {
133                    (value.key, value.value)
134                }
135            }
136            #[automatically_derived]
137            #[doc(hidden)]
138            impl ::core::convert::From<UnderlyingRustTuple<'_>> for incrementCall {
139                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
140                    Self {
141                        key: tuple.0,
142                        value: tuple.1,
143                    }
144                }
145            }
146        }
147        {
148            #[doc(hidden)]
149            type UnderlyingSolTuple<'a> = ();
150            #[doc(hidden)]
151            type UnderlyingRustTuple<'a> = ();
152            #[cfg(test)]
153            #[allow(dead_code, unreachable_patterns)]
154            fn _type_assertion(
155                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
156            ) {
157                match _t {
158                    alloy_sol_types::private::AssertTypeEq::<
159                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
160                    >(_) => {}
161                }
162            }
163            #[automatically_derived]
164            #[doc(hidden)]
165            impl ::core::convert::From<incrementReturn> for UnderlyingRustTuple<'_> {
166                fn from(value: incrementReturn) -> Self {
167                    ()
168                }
169            }
170            #[automatically_derived]
171            #[doc(hidden)]
172            impl ::core::convert::From<UnderlyingRustTuple<'_>> for incrementReturn {
173                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
174                    Self {}
175                }
176            }
177        }
178        #[automatically_derived]
179        impl alloy_sol_types::SolCall for incrementCall {
180            type Parameters<'a> = (
181                alloy::sol_types::sol_data::FixedBytes<32>,
182                alloy::sol_types::sol_data::Uint<256>,
183            );
184            type Token<'a> = <Self::Parameters<
185                'a,
186            > as alloy_sol_types::SolType>::Token<'a>;
187            type Return = incrementReturn;
188            type ReturnTuple<'a> = ();
189            type ReturnToken<'a> = <Self::ReturnTuple<
190                'a,
191            > as alloy_sol_types::SolType>::Token<'a>;
192            const SIGNATURE: &'static str = "increment(bytes32,uint256)";
193            const SELECTOR: [u8; 4] = [10u8, 255u8, 196u8, 55u8];
194            #[inline]
195            fn new<'a>(
196                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
197            ) -> Self {
198                tuple.into()
199            }
200            #[inline]
201            fn tokenize(&self) -> Self::Token<'_> {
202                (
203                    <alloy::sol_types::sol_data::FixedBytes<
204                        32,
205                    > as alloy_sol_types::SolType>::tokenize(&self.key),
206                    <alloy::sol_types::sol_data::Uint<
207                        256,
208                    > as alloy_sol_types::SolType>::tokenize(&self.value),
209                )
210            }
211            #[inline]
212            fn abi_decode_returns(
213                data: &[u8],
214                validate: bool,
215            ) -> alloy_sol_types::Result<Self::Return> {
216                <Self::ReturnTuple<
217                    '_,
218                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
219                    .map(Into::into)
220            }
221        }
222    };
223    #[derive(Default, Debug, PartialEq, Eq, Hash)]
224    /**Function with signature `requireGte(bytes32,uint256)` and selector `0xb14a2676`.
225```solidity
226function requireGte(bytes32 key, uint256 value) external view;
227```*/
228    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
229    #[derive(Clone)]
230    pub struct requireGteCall {
231        #[allow(missing_docs)]
232        pub key: alloy::sol_types::private::FixedBytes<32>,
233        #[allow(missing_docs)]
234        pub value: alloy::sol_types::private::primitives::aliases::U256,
235    }
236    ///Container type for the return parameters of the [`requireGte(bytes32,uint256)`](requireGteCall) function.
237    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
238    #[derive(Clone)]
239    pub struct requireGteReturn {}
240    #[allow(
241        non_camel_case_types,
242        non_snake_case,
243        clippy::pub_underscore_fields,
244        clippy::style
245    )]
246    const _: () = {
247        use alloy::sol_types as alloy_sol_types;
248        {
249            #[doc(hidden)]
250            type UnderlyingSolTuple<'a> = (
251                alloy::sol_types::sol_data::FixedBytes<32>,
252                alloy::sol_types::sol_data::Uint<256>,
253            );
254            #[doc(hidden)]
255            type UnderlyingRustTuple<'a> = (
256                alloy::sol_types::private::FixedBytes<32>,
257                alloy::sol_types::private::primitives::aliases::U256,
258            );
259            #[cfg(test)]
260            #[allow(dead_code, unreachable_patterns)]
261            fn _type_assertion(
262                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
263            ) {
264                match _t {
265                    alloy_sol_types::private::AssertTypeEq::<
266                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
267                    >(_) => {}
268                }
269            }
270            #[automatically_derived]
271            #[doc(hidden)]
272            impl ::core::convert::From<requireGteCall> for UnderlyingRustTuple<'_> {
273                fn from(value: requireGteCall) -> Self {
274                    (value.key, value.value)
275                }
276            }
277            #[automatically_derived]
278            #[doc(hidden)]
279            impl ::core::convert::From<UnderlyingRustTuple<'_>> for requireGteCall {
280                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
281                    Self {
282                        key: tuple.0,
283                        value: tuple.1,
284                    }
285                }
286            }
287        }
288        {
289            #[doc(hidden)]
290            type UnderlyingSolTuple<'a> = ();
291            #[doc(hidden)]
292            type UnderlyingRustTuple<'a> = ();
293            #[cfg(test)]
294            #[allow(dead_code, unreachable_patterns)]
295            fn _type_assertion(
296                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
297            ) {
298                match _t {
299                    alloy_sol_types::private::AssertTypeEq::<
300                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
301                    >(_) => {}
302                }
303            }
304            #[automatically_derived]
305            #[doc(hidden)]
306            impl ::core::convert::From<requireGteReturn> for UnderlyingRustTuple<'_> {
307                fn from(value: requireGteReturn) -> Self {
308                    ()
309                }
310            }
311            #[automatically_derived]
312            #[doc(hidden)]
313            impl ::core::convert::From<UnderlyingRustTuple<'_>> for requireGteReturn {
314                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
315                    Self {}
316                }
317            }
318        }
319        #[automatically_derived]
320        impl alloy_sol_types::SolCall for requireGteCall {
321            type Parameters<'a> = (
322                alloy::sol_types::sol_data::FixedBytes<32>,
323                alloy::sol_types::sol_data::Uint<256>,
324            );
325            type Token<'a> = <Self::Parameters<
326                'a,
327            > as alloy_sol_types::SolType>::Token<'a>;
328            type Return = requireGteReturn;
329            type ReturnTuple<'a> = ();
330            type ReturnToken<'a> = <Self::ReturnTuple<
331                'a,
332            > as alloy_sol_types::SolType>::Token<'a>;
333            const SIGNATURE: &'static str = "requireGte(bytes32,uint256)";
334            const SELECTOR: [u8; 4] = [177u8, 74u8, 38u8, 118u8];
335            #[inline]
336            fn new<'a>(
337                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
338            ) -> Self {
339                tuple.into()
340            }
341            #[inline]
342            fn tokenize(&self) -> Self::Token<'_> {
343                (
344                    <alloy::sol_types::sol_data::FixedBytes<
345                        32,
346                    > as alloy_sol_types::SolType>::tokenize(&self.key),
347                    <alloy::sol_types::sol_data::Uint<
348                        256,
349                    > as alloy_sol_types::SolType>::tokenize(&self.value),
350                )
351            }
352            #[inline]
353            fn abi_decode_returns(
354                data: &[u8],
355                validate: bool,
356            ) -> alloy_sol_types::Result<Self::Return> {
357                <Self::ReturnTuple<
358                    '_,
359                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
360                    .map(Into::into)
361            }
362        }
363    };
364    ///Container for all the [`ICounter`](self) function calls.
365    #[derive()]
366    pub enum ICounterCalls {
367        #[allow(missing_docs)]
368        increment(incrementCall),
369        #[allow(missing_docs)]
370        requireGte(requireGteCall),
371    }
372    #[automatically_derived]
373    impl ICounterCalls {
374        /// All the selectors of this enum.
375        ///
376        /// Note that the selectors might not be in the same order as the variants.
377        /// No guarantees are made about the order of the selectors.
378        ///
379        /// Prefer using `SolInterface` methods instead.
380        pub const SELECTORS: &'static [[u8; 4usize]] = &[
381            [10u8, 255u8, 196u8, 55u8],
382            [177u8, 74u8, 38u8, 118u8],
383        ];
384    }
385    #[automatically_derived]
386    impl alloy_sol_types::SolInterface for ICounterCalls {
387        const NAME: &'static str = "ICounterCalls";
388        const MIN_DATA_LENGTH: usize = 64usize;
389        const COUNT: usize = 2usize;
390        #[inline]
391        fn selector(&self) -> [u8; 4] {
392            match self {
393                Self::increment(_) => {
394                    <incrementCall as alloy_sol_types::SolCall>::SELECTOR
395                }
396                Self::requireGte(_) => {
397                    <requireGteCall as alloy_sol_types::SolCall>::SELECTOR
398                }
399            }
400        }
401        #[inline]
402        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
403            Self::SELECTORS.get(i).copied()
404        }
405        #[inline]
406        fn valid_selector(selector: [u8; 4]) -> bool {
407            Self::SELECTORS.binary_search(&selector).is_ok()
408        }
409        #[inline]
410        #[allow(non_snake_case)]
411        fn abi_decode_raw(
412            selector: [u8; 4],
413            data: &[u8],
414            validate: bool,
415        ) -> alloy_sol_types::Result<Self> {
416            static DECODE_SHIMS: &[fn(
417                &[u8],
418                bool,
419            ) -> alloy_sol_types::Result<ICounterCalls>] = &[
420                {
421                    fn increment(
422                        data: &[u8],
423                        validate: bool,
424                    ) -> alloy_sol_types::Result<ICounterCalls> {
425                        <incrementCall as alloy_sol_types::SolCall>::abi_decode_raw(
426                                data,
427                                validate,
428                            )
429                            .map(ICounterCalls::increment)
430                    }
431                    increment
432                },
433                {
434                    fn requireGte(
435                        data: &[u8],
436                        validate: bool,
437                    ) -> alloy_sol_types::Result<ICounterCalls> {
438                        <requireGteCall as alloy_sol_types::SolCall>::abi_decode_raw(
439                                data,
440                                validate,
441                            )
442                            .map(ICounterCalls::requireGte)
443                    }
444                    requireGte
445                },
446            ];
447            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
448                return Err(
449                    alloy_sol_types::Error::unknown_selector(
450                        <Self as alloy_sol_types::SolInterface>::NAME,
451                        selector,
452                    ),
453                );
454            };
455            DECODE_SHIMS[idx](data, validate)
456        }
457        #[inline]
458        fn abi_encoded_size(&self) -> usize {
459            match self {
460                Self::increment(inner) => {
461                    <incrementCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
462                }
463                Self::requireGte(inner) => {
464                    <requireGteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
465                }
466            }
467        }
468        #[inline]
469        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
470            match self {
471                Self::increment(inner) => {
472                    <incrementCall as alloy_sol_types::SolCall>::abi_encode_raw(
473                        inner,
474                        out,
475                    )
476                }
477                Self::requireGte(inner) => {
478                    <requireGteCall as alloy_sol_types::SolCall>::abi_encode_raw(
479                        inner,
480                        out,
481                    )
482                }
483            }
484        }
485    }
486    use alloy::contract as alloy_contract;
487    /**Creates a new wrapper around an on-chain [`ICounter`](self) contract instance.
488
489See the [wrapper's documentation](`ICounterInstance`) for more details.*/
490    #[inline]
491    pub const fn new<
492        T: alloy_contract::private::Transport + ::core::clone::Clone,
493        P: alloy_contract::private::Provider<T, N>,
494        N: alloy_contract::private::Network,
495    >(
496        address: alloy_sol_types::private::Address,
497        provider: P,
498    ) -> ICounterInstance<T, P, N> {
499        ICounterInstance::<T, P, N>::new(address, provider)
500    }
501    /**Deploys this contract using the given `provider` and constructor arguments, if any.
502
503Returns a new instance of the contract, if the deployment was successful.
504
505For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
506    #[inline]
507    pub fn deploy<
508        T: alloy_contract::private::Transport + ::core::clone::Clone,
509        P: alloy_contract::private::Provider<T, N>,
510        N: alloy_contract::private::Network,
511    >(
512        provider: P,
513    ) -> impl ::core::future::Future<
514        Output = alloy_contract::Result<ICounterInstance<T, P, N>>,
515    > {
516        ICounterInstance::<T, P, N>::deploy(provider)
517    }
518    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
519and constructor arguments, if any.
520
521This is a simple wrapper around creating a `RawCallBuilder` with the data set to
522the bytecode concatenated with the constructor's ABI-encoded arguments.*/
523    #[inline]
524    pub fn deploy_builder<
525        T: alloy_contract::private::Transport + ::core::clone::Clone,
526        P: alloy_contract::private::Provider<T, N>,
527        N: alloy_contract::private::Network,
528    >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
529        ICounterInstance::<T, P, N>::deploy_builder(provider)
530    }
531    /**A [`ICounter`](self) instance.
532
533Contains type-safe methods for interacting with an on-chain instance of the
534[`ICounter`](self) contract located at a given `address`, using a given
535provider `P`.
536
537If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
538documentation on how to provide it), the `deploy` and `deploy_builder` methods can
539be used to deploy a new instance of the contract.
540
541See the [module-level documentation](self) for all the available methods.*/
542    #[derive(Clone)]
543    pub struct ICounterInstance<T, P, N = alloy_contract::private::Ethereum> {
544        address: alloy_sol_types::private::Address,
545        provider: P,
546        _network_transport: ::core::marker::PhantomData<(N, T)>,
547    }
548    #[automatically_derived]
549    impl<T, P, N> ::core::fmt::Debug for ICounterInstance<T, P, N> {
550        #[inline]
551        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
552            f.debug_tuple("ICounterInstance").field(&self.address).finish()
553        }
554    }
555    /// Instantiation and getters/setters.
556    #[automatically_derived]
557    impl<
558        T: alloy_contract::private::Transport + ::core::clone::Clone,
559        P: alloy_contract::private::Provider<T, N>,
560        N: alloy_contract::private::Network,
561    > ICounterInstance<T, P, N> {
562        /**Creates a new wrapper around an on-chain [`ICounter`](self) contract instance.
563
564See the [wrapper's documentation](`ICounterInstance`) for more details.*/
565        #[inline]
566        pub const fn new(
567            address: alloy_sol_types::private::Address,
568            provider: P,
569        ) -> Self {
570            Self {
571                address,
572                provider,
573                _network_transport: ::core::marker::PhantomData,
574            }
575        }
576        /**Deploys this contract using the given `provider` and constructor arguments, if any.
577
578Returns a new instance of the contract, if the deployment was successful.
579
580For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
581        #[inline]
582        pub async fn deploy(
583            provider: P,
584        ) -> alloy_contract::Result<ICounterInstance<T, P, N>> {
585            let call_builder = Self::deploy_builder(provider);
586            let contract_address = call_builder.deploy().await?;
587            Ok(Self::new(contract_address, call_builder.provider))
588        }
589        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
590and constructor arguments, if any.
591
592This is a simple wrapper around creating a `RawCallBuilder` with the data set to
593the bytecode concatenated with the constructor's ABI-encoded arguments.*/
594        #[inline]
595        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
596            alloy_contract::RawCallBuilder::new_raw_deploy(
597                provider,
598                ::core::clone::Clone::clone(&BYTECODE),
599            )
600        }
601        /// Returns a reference to the address.
602        #[inline]
603        pub const fn address(&self) -> &alloy_sol_types::private::Address {
604            &self.address
605        }
606        /// Sets the address.
607        #[inline]
608        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
609            self.address = address;
610        }
611        /// Sets the address and returns `self`.
612        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
613            self.set_address(address);
614            self
615        }
616        /// Returns a reference to the provider.
617        #[inline]
618        pub const fn provider(&self) -> &P {
619            &self.provider
620        }
621    }
622    impl<T, P: ::core::clone::Clone, N> ICounterInstance<T, &P, N> {
623        /// Clones the provider and returns a new instance with the cloned provider.
624        #[inline]
625        pub fn with_cloned_provider(self) -> ICounterInstance<T, P, N> {
626            ICounterInstance {
627                address: self.address,
628                provider: ::core::clone::Clone::clone(&self.provider),
629                _network_transport: ::core::marker::PhantomData,
630            }
631        }
632    }
633    /// Function calls.
634    #[automatically_derived]
635    impl<
636        T: alloy_contract::private::Transport + ::core::clone::Clone,
637        P: alloy_contract::private::Provider<T, N>,
638        N: alloy_contract::private::Network,
639    > ICounterInstance<T, P, N> {
640        /// Creates a new call builder using this contract instance's provider and address.
641        ///
642        /// Note that the call can be any function call, not just those defined in this
643        /// contract. Prefer using the other methods for building type-safe contract calls.
644        pub fn call_builder<C: alloy_sol_types::SolCall>(
645            &self,
646            call: &C,
647        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
648            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
649        }
650        ///Creates a new call builder for the [`increment`] function.
651        pub fn increment(
652            &self,
653            key: alloy::sol_types::private::FixedBytes<32>,
654            value: alloy::sol_types::private::primitives::aliases::U256,
655        ) -> alloy_contract::SolCallBuilder<T, &P, incrementCall, N> {
656            self.call_builder(&incrementCall { key, value })
657        }
658        ///Creates a new call builder for the [`requireGte`] function.
659        pub fn requireGte(
660            &self,
661            key: alloy::sol_types::private::FixedBytes<32>,
662            value: alloy::sol_types::private::primitives::aliases::U256,
663        ) -> alloy_contract::SolCallBuilder<T, &P, requireGteCall, N> {
664            self.call_builder(&requireGteCall { key, value })
665        }
666    }
667    /// Event filters.
668    #[automatically_derived]
669    impl<
670        T: alloy_contract::private::Transport + ::core::clone::Clone,
671        P: alloy_contract::private::Provider<T, N>,
672        N: alloy_contract::private::Network,
673    > ICounterInstance<T, P, N> {
674        /// Creates a new event filter using this contract instance's provider and address.
675        ///
676        /// Note that the type can be any event, not just those defined in this contract.
677        /// Prefer using the other methods for building type-safe event filters.
678        pub fn event_filter<E: alloy_sol_types::SolEvent>(
679            &self,
680        ) -> alloy_contract::Event<T, &P, E, N> {
681            alloy_contract::Event::new_sol(&self.provider, &self.address)
682        }
683    }
684}
pod_contracts/icounter.rs

pod_contracts/
icounter.rs
