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

hotshot_contract_adapter/bindings/
ownable_upgradeable.rs
