hotshot_contract_adapter/bindings/
ownableupgradeable.rs

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

hotshot_contract_adapter/bindings/
ownableupgradeable.rs
