cartesi_rollups_contracts/
inputs.rs

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

cartesi_rollups_contracts/
inputs.rs
