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

hotshot_contract_adapter/bindings/
ownable_upgradeable.rs
