cartesi_rollups_contracts/
errors.rs

1/**
2
3Generated by the following Solidity interface...
4```solidity
5interface Errors {
6    error FailedCall();
7    error FailedDeployment();
8    error InsufficientBalance(uint256 balance, uint256 needed);
9    error MissingPrecompile(address);
10}
11```
12
13...which was generated by the following JSON ABI:
14```json
15[
16  {
17    "type": "error",
18    "name": "FailedCall",
19    "inputs": []
20  },
21  {
22    "type": "error",
23    "name": "FailedDeployment",
24    "inputs": []
25  },
26  {
27    "type": "error",
28    "name": "InsufficientBalance",
29    "inputs": [
30      {
31        "name": "balance",
32        "type": "uint256",
33        "internalType": "uint256"
34      },
35      {
36        "name": "needed",
37        "type": "uint256",
38        "internalType": "uint256"
39      }
40    ]
41  },
42  {
43    "type": "error",
44    "name": "MissingPrecompile",
45    "inputs": [
46      {
47        "name": "",
48        "type": "address",
49        "internalType": "address"
50      }
51    ]
52  }
53]
54```*/
55#[allow(
56    non_camel_case_types,
57    non_snake_case,
58    clippy::pub_underscore_fields,
59    clippy::style,
60    clippy::empty_structs_with_brackets
61)]
62pub mod Errors {
63    use super::*;
64    use alloy::sol_types as alloy_sol_types;
65    /// The creation / init bytecode of the contract.
66    ///
67    /// ```text
68    ///0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea264697066735822122071250a303554a9ecb9fc46685c7384e689be39711f33bbea6c1a2bb7df4d173464736f6c634300081e0033
69    /// ```
70    #[rustfmt::skip]
71    #[allow(clippy::all)]
72    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
73        b"`\x80\x80`@R4`\x17W`9\x90\x81`\x1C\x8290\x81PP\xF3[_\x80\xFD\xFE_\x80\xFD\xFE\xA2dipfsX\"\x12 q%\n05T\xA9\xEC\xB9\xFCFh\\s\x84\xE6\x89\xBE9q\x1F3\xBB\xEAl\x1A+\xB7\xDFM\x174dsolcC\0\x08\x1E\x003",
74    );
75    /// The runtime bytecode of the contract, as deployed on the network.
76    ///
77    /// ```text
78    ///0x5f80fdfea264697066735822122071250a303554a9ecb9fc46685c7384e689be39711f33bbea6c1a2bb7df4d173464736f6c634300081e0033
79    /// ```
80    #[rustfmt::skip]
81    #[allow(clippy::all)]
82    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
83        b"_\x80\xFD\xFE\xA2dipfsX\"\x12 q%\n05T\xA9\xEC\xB9\xFCFh\\s\x84\xE6\x89\xBE9q\x1F3\xBB\xEAl\x1A+\xB7\xDFM\x174dsolcC\0\x08\x1E\x003",
84    );
85    #[derive(serde::Serialize, serde::Deserialize)]
86    #[derive(Default, Debug, PartialEq, Eq, Hash)]
87    /**Custom error with signature `FailedCall()` and selector `0xd6bda275`.
88```solidity
89error FailedCall();
90```*/
91    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
92    #[derive(Clone)]
93    pub struct FailedCall;
94    #[allow(
95        non_camel_case_types,
96        non_snake_case,
97        clippy::pub_underscore_fields,
98        clippy::style
99    )]
100    const _: () = {
101        use alloy::sol_types as alloy_sol_types;
102        #[doc(hidden)]
103        #[allow(dead_code)]
104        type UnderlyingSolTuple<'a> = ();
105        #[doc(hidden)]
106        type UnderlyingRustTuple<'a> = ();
107        #[cfg(test)]
108        #[allow(dead_code, unreachable_patterns)]
109        fn _type_assertion(
110            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
111        ) {
112            match _t {
113                alloy_sol_types::private::AssertTypeEq::<
114                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
115                >(_) => {}
116            }
117        }
118        #[automatically_derived]
119        #[doc(hidden)]
120        impl ::core::convert::From<FailedCall> for UnderlyingRustTuple<'_> {
121            fn from(value: FailedCall) -> Self {
122                ()
123            }
124        }
125        #[automatically_derived]
126        #[doc(hidden)]
127        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedCall {
128            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
129                Self
130            }
131        }
132        #[automatically_derived]
133        impl alloy_sol_types::SolError for FailedCall {
134            type Parameters<'a> = UnderlyingSolTuple<'a>;
135            type Token<'a> = <Self::Parameters<
136                'a,
137            > as alloy_sol_types::SolType>::Token<'a>;
138            const SIGNATURE: &'static str = "FailedCall()";
139            const SELECTOR: [u8; 4] = [214u8, 189u8, 162u8, 117u8];
140            #[inline]
141            fn new<'a>(
142                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
143            ) -> Self {
144                tuple.into()
145            }
146            #[inline]
147            fn tokenize(&self) -> Self::Token<'_> {
148                ()
149            }
150            #[inline]
151            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
152                <Self::Parameters<
153                    '_,
154                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
155                    .map(Self::new)
156            }
157        }
158    };
159    #[derive(serde::Serialize, serde::Deserialize)]
160    #[derive(Default, Debug, PartialEq, Eq, Hash)]
161    /**Custom error with signature `FailedDeployment()` and selector `0xb06ebf3d`.
162```solidity
163error FailedDeployment();
164```*/
165    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
166    #[derive(Clone)]
167    pub struct FailedDeployment;
168    #[allow(
169        non_camel_case_types,
170        non_snake_case,
171        clippy::pub_underscore_fields,
172        clippy::style
173    )]
174    const _: () = {
175        use alloy::sol_types as alloy_sol_types;
176        #[doc(hidden)]
177        #[allow(dead_code)]
178        type UnderlyingSolTuple<'a> = ();
179        #[doc(hidden)]
180        type UnderlyingRustTuple<'a> = ();
181        #[cfg(test)]
182        #[allow(dead_code, unreachable_patterns)]
183        fn _type_assertion(
184            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
185        ) {
186            match _t {
187                alloy_sol_types::private::AssertTypeEq::<
188                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
189                >(_) => {}
190            }
191        }
192        #[automatically_derived]
193        #[doc(hidden)]
194        impl ::core::convert::From<FailedDeployment> for UnderlyingRustTuple<'_> {
195            fn from(value: FailedDeployment) -> Self {
196                ()
197            }
198        }
199        #[automatically_derived]
200        #[doc(hidden)]
201        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedDeployment {
202            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
203                Self
204            }
205        }
206        #[automatically_derived]
207        impl alloy_sol_types::SolError for FailedDeployment {
208            type Parameters<'a> = UnderlyingSolTuple<'a>;
209            type Token<'a> = <Self::Parameters<
210                'a,
211            > as alloy_sol_types::SolType>::Token<'a>;
212            const SIGNATURE: &'static str = "FailedDeployment()";
213            const SELECTOR: [u8; 4] = [176u8, 110u8, 191u8, 61u8];
214            #[inline]
215            fn new<'a>(
216                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
217            ) -> Self {
218                tuple.into()
219            }
220            #[inline]
221            fn tokenize(&self) -> Self::Token<'_> {
222                ()
223            }
224            #[inline]
225            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
226                <Self::Parameters<
227                    '_,
228                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
229                    .map(Self::new)
230            }
231        }
232    };
233    #[derive(serde::Serialize, serde::Deserialize)]
234    #[derive(Default, Debug, PartialEq, Eq, Hash)]
235    /**Custom error with signature `InsufficientBalance(uint256,uint256)` and selector `0xcf479181`.
236```solidity
237error InsufficientBalance(uint256 balance, uint256 needed);
238```*/
239    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
240    #[derive(Clone)]
241    pub struct InsufficientBalance {
242        #[allow(missing_docs)]
243        pub balance: alloy::sol_types::private::primitives::aliases::U256,
244        #[allow(missing_docs)]
245        pub needed: alloy::sol_types::private::primitives::aliases::U256,
246    }
247    #[allow(
248        non_camel_case_types,
249        non_snake_case,
250        clippy::pub_underscore_fields,
251        clippy::style
252    )]
253    const _: () = {
254        use alloy::sol_types as alloy_sol_types;
255        #[doc(hidden)]
256        #[allow(dead_code)]
257        type UnderlyingSolTuple<'a> = (
258            alloy::sol_types::sol_data::Uint<256>,
259            alloy::sol_types::sol_data::Uint<256>,
260        );
261        #[doc(hidden)]
262        type UnderlyingRustTuple<'a> = (
263            alloy::sol_types::private::primitives::aliases::U256,
264            alloy::sol_types::private::primitives::aliases::U256,
265        );
266        #[cfg(test)]
267        #[allow(dead_code, unreachable_patterns)]
268        fn _type_assertion(
269            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
270        ) {
271            match _t {
272                alloy_sol_types::private::AssertTypeEq::<
273                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
274                >(_) => {}
275            }
276        }
277        #[automatically_derived]
278        #[doc(hidden)]
279        impl ::core::convert::From<InsufficientBalance> for UnderlyingRustTuple<'_> {
280            fn from(value: InsufficientBalance) -> Self {
281                (value.balance, value.needed)
282            }
283        }
284        #[automatically_derived]
285        #[doc(hidden)]
286        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientBalance {
287            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
288                Self {
289                    balance: tuple.0,
290                    needed: tuple.1,
291                }
292            }
293        }
294        #[automatically_derived]
295        impl alloy_sol_types::SolError for InsufficientBalance {
296            type Parameters<'a> = UnderlyingSolTuple<'a>;
297            type Token<'a> = <Self::Parameters<
298                'a,
299            > as alloy_sol_types::SolType>::Token<'a>;
300            const SIGNATURE: &'static str = "InsufficientBalance(uint256,uint256)";
301            const SELECTOR: [u8; 4] = [207u8, 71u8, 145u8, 129u8];
302            #[inline]
303            fn new<'a>(
304                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
305            ) -> Self {
306                tuple.into()
307            }
308            #[inline]
309            fn tokenize(&self) -> Self::Token<'_> {
310                (
311                    <alloy::sol_types::sol_data::Uint<
312                        256,
313                    > as alloy_sol_types::SolType>::tokenize(&self.balance),
314                    <alloy::sol_types::sol_data::Uint<
315                        256,
316                    > as alloy_sol_types::SolType>::tokenize(&self.needed),
317                )
318            }
319            #[inline]
320            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
321                <Self::Parameters<
322                    '_,
323                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
324                    .map(Self::new)
325            }
326        }
327    };
328    #[derive(serde::Serialize, serde::Deserialize)]
329    #[derive(Default, Debug, PartialEq, Eq, Hash)]
330    /**Custom error with signature `MissingPrecompile(address)` and selector `0x42b01bce`.
331```solidity
332error MissingPrecompile(address);
333```*/
334    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
335    #[derive(Clone)]
336    pub struct MissingPrecompile(pub alloy::sol_types::private::Address);
337    #[allow(
338        non_camel_case_types,
339        non_snake_case,
340        clippy::pub_underscore_fields,
341        clippy::style
342    )]
343    const _: () = {
344        use alloy::sol_types as alloy_sol_types;
345        #[doc(hidden)]
346        #[allow(dead_code)]
347        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
348        #[doc(hidden)]
349        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
350        #[cfg(test)]
351        #[allow(dead_code, unreachable_patterns)]
352        fn _type_assertion(
353            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
354        ) {
355            match _t {
356                alloy_sol_types::private::AssertTypeEq::<
357                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
358                >(_) => {}
359            }
360        }
361        #[automatically_derived]
362        #[doc(hidden)]
363        impl ::core::convert::From<MissingPrecompile> for UnderlyingRustTuple<'_> {
364            fn from(value: MissingPrecompile) -> Self {
365                (value.0,)
366            }
367        }
368        #[automatically_derived]
369        #[doc(hidden)]
370        impl ::core::convert::From<UnderlyingRustTuple<'_>> for MissingPrecompile {
371            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
372                Self(tuple.0)
373            }
374        }
375        #[automatically_derived]
376        impl alloy_sol_types::SolError for MissingPrecompile {
377            type Parameters<'a> = UnderlyingSolTuple<'a>;
378            type Token<'a> = <Self::Parameters<
379                'a,
380            > as alloy_sol_types::SolType>::Token<'a>;
381            const SIGNATURE: &'static str = "MissingPrecompile(address)";
382            const SELECTOR: [u8; 4] = [66u8, 176u8, 27u8, 206u8];
383            #[inline]
384            fn new<'a>(
385                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
386            ) -> Self {
387                tuple.into()
388            }
389            #[inline]
390            fn tokenize(&self) -> Self::Token<'_> {
391                (
392                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
393                        &self.0,
394                    ),
395                )
396            }
397            #[inline]
398            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
399                <Self::Parameters<
400                    '_,
401                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
402                    .map(Self::new)
403            }
404        }
405    };
406    ///Container for all the [`Errors`](self) custom errors.
407    #[derive(Clone)]
408    #[derive(serde::Serialize, serde::Deserialize)]
409    #[derive(Debug, PartialEq, Eq, Hash)]
410    pub enum ErrorsErrors {
411        #[allow(missing_docs)]
412        FailedCall(FailedCall),
413        #[allow(missing_docs)]
414        FailedDeployment(FailedDeployment),
415        #[allow(missing_docs)]
416        InsufficientBalance(InsufficientBalance),
417        #[allow(missing_docs)]
418        MissingPrecompile(MissingPrecompile),
419    }
420    impl ErrorsErrors {
421        /// All the selectors of this enum.
422        ///
423        /// Note that the selectors might not be in the same order as the variants.
424        /// No guarantees are made about the order of the selectors.
425        ///
426        /// Prefer using `SolInterface` methods instead.
427        pub const SELECTORS: &'static [[u8; 4usize]] = &[
428            [66u8, 176u8, 27u8, 206u8],
429            [176u8, 110u8, 191u8, 61u8],
430            [207u8, 71u8, 145u8, 129u8],
431            [214u8, 189u8, 162u8, 117u8],
432        ];
433        /// The names of the variants in the same order as `SELECTORS`.
434        pub const VARIANT_NAMES: &'static [&'static str] = &[
435            ::core::stringify!(MissingPrecompile),
436            ::core::stringify!(FailedDeployment),
437            ::core::stringify!(InsufficientBalance),
438            ::core::stringify!(FailedCall),
439        ];
440        /// The signatures in the same order as `SELECTORS`.
441        pub const SIGNATURES: &'static [&'static str] = &[
442            <MissingPrecompile as alloy_sol_types::SolError>::SIGNATURE,
443            <FailedDeployment as alloy_sol_types::SolError>::SIGNATURE,
444            <InsufficientBalance as alloy_sol_types::SolError>::SIGNATURE,
445            <FailedCall as alloy_sol_types::SolError>::SIGNATURE,
446        ];
447        /// Returns the signature for the given selector, if known.
448        #[inline]
449        pub fn signature_by_selector(
450            selector: [u8; 4usize],
451        ) -> ::core::option::Option<&'static str> {
452            match Self::SELECTORS.binary_search(&selector) {
453                ::core::result::Result::Ok(idx) => {
454                    ::core::option::Option::Some(Self::SIGNATURES[idx])
455                }
456                ::core::result::Result::Err(_) => ::core::option::Option::None,
457            }
458        }
459        /// Returns the enum variant name for the given selector, if known.
460        #[inline]
461        pub fn name_by_selector(
462            selector: [u8; 4usize],
463        ) -> ::core::option::Option<&'static str> {
464            let sig = Self::signature_by_selector(selector)?;
465            sig.split_once('(').map(|(name, _)| name)
466        }
467    }
468    #[automatically_derived]
469    impl alloy_sol_types::SolInterface for ErrorsErrors {
470        const NAME: &'static str = "ErrorsErrors";
471        const MIN_DATA_LENGTH: usize = 0usize;
472        const COUNT: usize = 4usize;
473        #[inline]
474        fn selector(&self) -> [u8; 4] {
475            match self {
476                Self::FailedCall(_) => {
477                    <FailedCall as alloy_sol_types::SolError>::SELECTOR
478                }
479                Self::FailedDeployment(_) => {
480                    <FailedDeployment as alloy_sol_types::SolError>::SELECTOR
481                }
482                Self::InsufficientBalance(_) => {
483                    <InsufficientBalance as alloy_sol_types::SolError>::SELECTOR
484                }
485                Self::MissingPrecompile(_) => {
486                    <MissingPrecompile as alloy_sol_types::SolError>::SELECTOR
487                }
488            }
489        }
490        #[inline]
491        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
492            Self::SELECTORS.get(i).copied()
493        }
494        #[inline]
495        fn valid_selector(selector: [u8; 4]) -> bool {
496            Self::SELECTORS.binary_search(&selector).is_ok()
497        }
498        #[inline]
499        #[allow(non_snake_case)]
500        fn abi_decode_raw(
501            selector: [u8; 4],
502            data: &[u8],
503        ) -> alloy_sol_types::Result<Self> {
504            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ErrorsErrors>] = &[
505                {
506                    fn MissingPrecompile(
507                        data: &[u8],
508                    ) -> alloy_sol_types::Result<ErrorsErrors> {
509                        <MissingPrecompile as alloy_sol_types::SolError>::abi_decode_raw(
510                                data,
511                            )
512                            .map(ErrorsErrors::MissingPrecompile)
513                    }
514                    MissingPrecompile
515                },
516                {
517                    fn FailedDeployment(
518                        data: &[u8],
519                    ) -> alloy_sol_types::Result<ErrorsErrors> {
520                        <FailedDeployment as alloy_sol_types::SolError>::abi_decode_raw(
521                                data,
522                            )
523                            .map(ErrorsErrors::FailedDeployment)
524                    }
525                    FailedDeployment
526                },
527                {
528                    fn InsufficientBalance(
529                        data: &[u8],
530                    ) -> alloy_sol_types::Result<ErrorsErrors> {
531                        <InsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw(
532                                data,
533                            )
534                            .map(ErrorsErrors::InsufficientBalance)
535                    }
536                    InsufficientBalance
537                },
538                {
539                    fn FailedCall(data: &[u8]) -> alloy_sol_types::Result<ErrorsErrors> {
540                        <FailedCall as alloy_sol_types::SolError>::abi_decode_raw(data)
541                            .map(ErrorsErrors::FailedCall)
542                    }
543                    FailedCall
544                },
545            ];
546            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
547                return Err(
548                    alloy_sol_types::Error::unknown_selector(
549                        <Self as alloy_sol_types::SolInterface>::NAME,
550                        selector,
551                    ),
552                );
553            };
554            DECODE_SHIMS[idx](data)
555        }
556        #[inline]
557        #[allow(non_snake_case)]
558        fn abi_decode_raw_validate(
559            selector: [u8; 4],
560            data: &[u8],
561        ) -> alloy_sol_types::Result<Self> {
562            static DECODE_VALIDATE_SHIMS: &[fn(
563                &[u8],
564            ) -> alloy_sol_types::Result<ErrorsErrors>] = &[
565                {
566                    fn MissingPrecompile(
567                        data: &[u8],
568                    ) -> alloy_sol_types::Result<ErrorsErrors> {
569                        <MissingPrecompile as alloy_sol_types::SolError>::abi_decode_raw_validate(
570                                data,
571                            )
572                            .map(ErrorsErrors::MissingPrecompile)
573                    }
574                    MissingPrecompile
575                },
576                {
577                    fn FailedDeployment(
578                        data: &[u8],
579                    ) -> alloy_sol_types::Result<ErrorsErrors> {
580                        <FailedDeployment as alloy_sol_types::SolError>::abi_decode_raw_validate(
581                                data,
582                            )
583                            .map(ErrorsErrors::FailedDeployment)
584                    }
585                    FailedDeployment
586                },
587                {
588                    fn InsufficientBalance(
589                        data: &[u8],
590                    ) -> alloy_sol_types::Result<ErrorsErrors> {
591                        <InsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw_validate(
592                                data,
593                            )
594                            .map(ErrorsErrors::InsufficientBalance)
595                    }
596                    InsufficientBalance
597                },
598                {
599                    fn FailedCall(data: &[u8]) -> alloy_sol_types::Result<ErrorsErrors> {
600                        <FailedCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
601                                data,
602                            )
603                            .map(ErrorsErrors::FailedCall)
604                    }
605                    FailedCall
606                },
607            ];
608            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
609                return Err(
610                    alloy_sol_types::Error::unknown_selector(
611                        <Self as alloy_sol_types::SolInterface>::NAME,
612                        selector,
613                    ),
614                );
615            };
616            DECODE_VALIDATE_SHIMS[idx](data)
617        }
618        #[inline]
619        fn abi_encoded_size(&self) -> usize {
620            match self {
621                Self::FailedCall(inner) => {
622                    <FailedCall as alloy_sol_types::SolError>::abi_encoded_size(inner)
623                }
624                Self::FailedDeployment(inner) => {
625                    <FailedDeployment as alloy_sol_types::SolError>::abi_encoded_size(
626                        inner,
627                    )
628                }
629                Self::InsufficientBalance(inner) => {
630                    <InsufficientBalance as alloy_sol_types::SolError>::abi_encoded_size(
631                        inner,
632                    )
633                }
634                Self::MissingPrecompile(inner) => {
635                    <MissingPrecompile as alloy_sol_types::SolError>::abi_encoded_size(
636                        inner,
637                    )
638                }
639            }
640        }
641        #[inline]
642        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
643            match self {
644                Self::FailedCall(inner) => {
645                    <FailedCall as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
646                }
647                Self::FailedDeployment(inner) => {
648                    <FailedDeployment as alloy_sol_types::SolError>::abi_encode_raw(
649                        inner,
650                        out,
651                    )
652                }
653                Self::InsufficientBalance(inner) => {
654                    <InsufficientBalance as alloy_sol_types::SolError>::abi_encode_raw(
655                        inner,
656                        out,
657                    )
658                }
659                Self::MissingPrecompile(inner) => {
660                    <MissingPrecompile as alloy_sol_types::SolError>::abi_encode_raw(
661                        inner,
662                        out,
663                    )
664                }
665            }
666        }
667    }
668    use alloy::contract as alloy_contract;
669    /**Creates a new wrapper around an on-chain [`Errors`](self) contract instance.
670
671See the [wrapper's documentation](`ErrorsInstance`) for more details.*/
672    #[inline]
673    pub const fn new<
674        P: alloy_contract::private::Provider<N>,
675        N: alloy_contract::private::Network,
676    >(
677        address: alloy_sol_types::private::Address,
678        __provider: P,
679    ) -> ErrorsInstance<P, N> {
680        ErrorsInstance::<P, N>::new(address, __provider)
681    }
682    /**Deploys this contract using the given `provider` and constructor arguments, if any.
683
684Returns a new instance of the contract, if the deployment was successful.
685
686For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
687    #[inline]
688    pub fn deploy<
689        P: alloy_contract::private::Provider<N>,
690        N: alloy_contract::private::Network,
691    >(
692        __provider: P,
693    ) -> impl ::core::future::Future<
694        Output = alloy_contract::Result<ErrorsInstance<P, N>>,
695    > {
696        ErrorsInstance::<P, N>::deploy(__provider)
697    }
698    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
699and constructor arguments, if any.
700
701This is a simple wrapper around creating a `RawCallBuilder` with the data set to
702the bytecode concatenated with the constructor's ABI-encoded arguments.*/
703    #[inline]
704    pub fn deploy_builder<
705        P: alloy_contract::private::Provider<N>,
706        N: alloy_contract::private::Network,
707    >(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
708        ErrorsInstance::<P, N>::deploy_builder(__provider)
709    }
710    /**A [`Errors`](self) instance.
711
712Contains type-safe methods for interacting with an on-chain instance of the
713[`Errors`](self) contract located at a given `address`, using a given
714provider `P`.
715
716If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
717documentation on how to provide it), the `deploy` and `deploy_builder` methods can
718be used to deploy a new instance of the contract.
719
720See the [module-level documentation](self) for all the available methods.*/
721    #[derive(Clone)]
722    pub struct ErrorsInstance<P, N = alloy_contract::private::Ethereum> {
723        address: alloy_sol_types::private::Address,
724        provider: P,
725        _network: ::core::marker::PhantomData<N>,
726    }
727    #[automatically_derived]
728    impl<P, N> ::core::fmt::Debug for ErrorsInstance<P, N> {
729        #[inline]
730        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
731            f.debug_tuple("ErrorsInstance").field(&self.address).finish()
732        }
733    }
734    /// Instantiation and getters/setters.
735    impl<
736        P: alloy_contract::private::Provider<N>,
737        N: alloy_contract::private::Network,
738    > ErrorsInstance<P, N> {
739        /**Creates a new wrapper around an on-chain [`Errors`](self) contract instance.
740
741See the [wrapper's documentation](`ErrorsInstance`) for more details.*/
742        #[inline]
743        pub const fn new(
744            address: alloy_sol_types::private::Address,
745            __provider: P,
746        ) -> Self {
747            Self {
748                address,
749                provider: __provider,
750                _network: ::core::marker::PhantomData,
751            }
752        }
753        /**Deploys this contract using the given `provider` and constructor arguments, if any.
754
755Returns a new instance of the contract, if the deployment was successful.
756
757For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
758        #[inline]
759        pub async fn deploy(
760            __provider: P,
761        ) -> alloy_contract::Result<ErrorsInstance<P, N>> {
762            let call_builder = Self::deploy_builder(__provider);
763            let contract_address = call_builder.deploy().await?;
764            Ok(Self::new(contract_address, call_builder.provider))
765        }
766        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
767and constructor arguments, if any.
768
769This is a simple wrapper around creating a `RawCallBuilder` with the data set to
770the bytecode concatenated with the constructor's ABI-encoded arguments.*/
771        #[inline]
772        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
773            alloy_contract::RawCallBuilder::new_raw_deploy(
774                __provider,
775                ::core::clone::Clone::clone(&BYTECODE),
776            )
777        }
778        /// Returns a reference to the address.
779        #[inline]
780        pub const fn address(&self) -> &alloy_sol_types::private::Address {
781            &self.address
782        }
783        /// Sets the address.
784        #[inline]
785        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
786            self.address = address;
787        }
788        /// Sets the address and returns `self`.
789        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
790            self.set_address(address);
791            self
792        }
793        /// Returns a reference to the provider.
794        #[inline]
795        pub const fn provider(&self) -> &P {
796            &self.provider
797        }
798    }
799    impl<P: ::core::clone::Clone, N> ErrorsInstance<&P, N> {
800        /// Clones the provider and returns a new instance with the cloned provider.
801        #[inline]
802        pub fn with_cloned_provider(self) -> ErrorsInstance<P, N> {
803            ErrorsInstance {
804                address: self.address,
805                provider: ::core::clone::Clone::clone(&self.provider),
806                _network: ::core::marker::PhantomData,
807            }
808        }
809    }
810    /// Function calls.
811    impl<
812        P: alloy_contract::private::Provider<N>,
813        N: alloy_contract::private::Network,
814    > ErrorsInstance<P, N> {
815        /// Creates a new call builder using this contract instance's provider and address.
816        ///
817        /// Note that the call can be any function call, not just those defined in this
818        /// contract. Prefer using the other methods for building type-safe contract calls.
819        pub fn call_builder<C: alloy_sol_types::SolCall>(
820            &self,
821            call: &C,
822        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
823            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
824        }
825    }
826    /// Event filters.
827    impl<
828        P: alloy_contract::private::Provider<N>,
829        N: alloy_contract::private::Network,
830    > ErrorsInstance<P, N> {
831        /// Creates a new event filter using this contract instance's provider and address.
832        ///
833        /// Note that the type can be any event, not just those defined in this contract.
834        /// Prefer using the other methods for building type-safe event filters.
835        pub fn event_filter<E: alloy_sol_types::SolEvent>(
836            &self,
837        ) -> alloy_contract::Event<&P, E, N> {
838            alloy_contract::Event::new_sol(&self.provider, &self.address)
839        }
840    }
841}
cartesi_rollups_contracts/errors.rs

cartesi_rollups_contracts/
errors.rs
