Skip to main content

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::abi_decode_raw_with_config(
220                    data,
221                    alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
222                )
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::abi_decode_raw_with_config(
294                    data,
295                    alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
296                )
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::abi_decode_raw_with_config(
375                    data,
376                    alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
377                )
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::abi_decode_raw_with_config(
458                    data,
459                    alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
460                )
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_with_config(
822                data: &[u8],
823                config: alloy_sol_types::abi::AbiDecoderConfig,
824            ) -> alloy_sol_types::Result<Self::Return> {
825                <Self::ReturnTuple<
826                    '_,
827                > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
828                        data,
829                        config,
830                    )
831                    .map(|r| {
832                        let r: ownerReturn = r.into();
833                        r._0
834                    })
835            }
836            #[inline]
837            fn abi_decode_returns_validate(
838                data: &[u8],
839            ) -> alloy_sol_types::Result<Self::Return> {
840                Self::abi_decode_returns_with_config(
841                    data,
842                    alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
843                )
844            }
845        }
846    };
847    #[derive(serde::Serialize, serde::Deserialize)]
848    #[derive(Default, Debug, PartialEq, Eq, Hash)]
849    /**Function with signature `renounceOwnership()` and selector `0x715018a6`.
850```solidity
851function renounceOwnership() external;
852```*/
853    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
854    #[derive(Clone)]
855    pub struct renounceOwnershipCall;
856    ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function.
857    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
858    #[derive(Clone)]
859    pub struct renounceOwnershipReturn {}
860    #[allow(
861        non_camel_case_types,
862        non_snake_case,
863        clippy::pub_underscore_fields,
864        clippy::style
865    )]
866    const _: () = {
867        use alloy::sol_types as alloy_sol_types;
868        {
869            #[doc(hidden)]
870            #[allow(dead_code)]
871            type UnderlyingSolTuple<'a> = ();
872            #[doc(hidden)]
873            type UnderlyingRustTuple<'a> = ();
874            #[cfg(test)]
875            #[allow(dead_code, unreachable_patterns)]
876            fn _type_assertion(
877                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
878            ) {
879                match _t {
880                    alloy_sol_types::private::AssertTypeEq::<
881                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
882                    >(_) => {}
883                }
884            }
885            #[automatically_derived]
886            #[doc(hidden)]
887            impl ::core::convert::From<renounceOwnershipCall>
888            for UnderlyingRustTuple<'_> {
889                fn from(value: renounceOwnershipCall) -> Self {
890                    ()
891                }
892            }
893            #[automatically_derived]
894            #[doc(hidden)]
895            impl ::core::convert::From<UnderlyingRustTuple<'_>>
896            for renounceOwnershipCall {
897                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
898                    Self
899                }
900            }
901        }
902        {
903            #[doc(hidden)]
904            #[allow(dead_code)]
905            type UnderlyingSolTuple<'a> = ();
906            #[doc(hidden)]
907            type UnderlyingRustTuple<'a> = ();
908            #[cfg(test)]
909            #[allow(dead_code, unreachable_patterns)]
910            fn _type_assertion(
911                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
912            ) {
913                match _t {
914                    alloy_sol_types::private::AssertTypeEq::<
915                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
916                    >(_) => {}
917                }
918            }
919            #[automatically_derived]
920            #[doc(hidden)]
921            impl ::core::convert::From<renounceOwnershipReturn>
922            for UnderlyingRustTuple<'_> {
923                fn from(value: renounceOwnershipReturn) -> Self {
924                    ()
925                }
926            }
927            #[automatically_derived]
928            #[doc(hidden)]
929            impl ::core::convert::From<UnderlyingRustTuple<'_>>
930            for renounceOwnershipReturn {
931                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
932                    Self {}
933                }
934            }
935        }
936        impl renounceOwnershipReturn {
937            fn _tokenize(
938                &self,
939            ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
940                ()
941            }
942        }
943        #[automatically_derived]
944        impl alloy_sol_types::SolCall for renounceOwnershipCall {
945            type Parameters<'a> = ();
946            type Token<'a> = <Self::Parameters<
947                'a,
948            > as alloy_sol_types::SolType>::Token<'a>;
949            type Return = renounceOwnershipReturn;
950            type ReturnTuple<'a> = ();
951            type ReturnToken<'a> = <Self::ReturnTuple<
952                'a,
953            > as alloy_sol_types::SolType>::Token<'a>;
954            const SIGNATURE: &'static str = "renounceOwnership()";
955            const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
956            #[inline]
957            fn new<'a>(
958                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
959            ) -> Self {
960                tuple.into()
961            }
962            #[inline]
963            fn tokenize(&self) -> Self::Token<'_> {
964                ()
965            }
966            #[inline]
967            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
968                renounceOwnershipReturn::_tokenize(ret)
969            }
970            #[inline]
971            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
972                <Self::ReturnTuple<
973                    '_,
974                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
975                    .map(Into::into)
976            }
977            #[inline]
978            fn abi_decode_returns_with_config(
979                data: &[u8],
980                config: alloy_sol_types::abi::AbiDecoderConfig,
981            ) -> alloy_sol_types::Result<Self::Return> {
982                <Self::ReturnTuple<
983                    '_,
984                > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
985                        data,
986                        config,
987                    )
988                    .map(Into::into)
989            }
990            #[inline]
991            fn abi_decode_returns_validate(
992                data: &[u8],
993            ) -> alloy_sol_types::Result<Self::Return> {
994                Self::abi_decode_returns_with_config(
995                    data,
996                    alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
997                )
998            }
999        }
1000    };
1001    #[derive(serde::Serialize, serde::Deserialize)]
1002    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1003    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
1004```solidity
1005function transferOwnership(address newOwner) external;
1006```*/
1007    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1008    #[derive(Clone)]
1009    pub struct transferOwnershipCall {
1010        #[allow(missing_docs)]
1011        pub newOwner: alloy::sol_types::private::Address,
1012    }
1013    ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function.
1014    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1015    #[derive(Clone)]
1016    pub struct transferOwnershipReturn {}
1017    #[allow(
1018        non_camel_case_types,
1019        non_snake_case,
1020        clippy::pub_underscore_fields,
1021        clippy::style
1022    )]
1023    const _: () = {
1024        use alloy::sol_types as alloy_sol_types;
1025        {
1026            #[doc(hidden)]
1027            #[allow(dead_code)]
1028            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1029            #[doc(hidden)]
1030            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1031            #[cfg(test)]
1032            #[allow(dead_code, unreachable_patterns)]
1033            fn _type_assertion(
1034                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1035            ) {
1036                match _t {
1037                    alloy_sol_types::private::AssertTypeEq::<
1038                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1039                    >(_) => {}
1040                }
1041            }
1042            #[automatically_derived]
1043            #[doc(hidden)]
1044            impl ::core::convert::From<transferOwnershipCall>
1045            for UnderlyingRustTuple<'_> {
1046                fn from(value: transferOwnershipCall) -> Self {
1047                    (value.newOwner,)
1048                }
1049            }
1050            #[automatically_derived]
1051            #[doc(hidden)]
1052            impl ::core::convert::From<UnderlyingRustTuple<'_>>
1053            for transferOwnershipCall {
1054                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1055                    Self { newOwner: tuple.0 }
1056                }
1057            }
1058        }
1059        {
1060            #[doc(hidden)]
1061            #[allow(dead_code)]
1062            type UnderlyingSolTuple<'a> = ();
1063            #[doc(hidden)]
1064            type UnderlyingRustTuple<'a> = ();
1065            #[cfg(test)]
1066            #[allow(dead_code, unreachable_patterns)]
1067            fn _type_assertion(
1068                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1069            ) {
1070                match _t {
1071                    alloy_sol_types::private::AssertTypeEq::<
1072                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1073                    >(_) => {}
1074                }
1075            }
1076            #[automatically_derived]
1077            #[doc(hidden)]
1078            impl ::core::convert::From<transferOwnershipReturn>
1079            for UnderlyingRustTuple<'_> {
1080                fn from(value: transferOwnershipReturn) -> Self {
1081                    ()
1082                }
1083            }
1084            #[automatically_derived]
1085            #[doc(hidden)]
1086            impl ::core::convert::From<UnderlyingRustTuple<'_>>
1087            for transferOwnershipReturn {
1088                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1089                    Self {}
1090                }
1091            }
1092        }
1093        impl transferOwnershipReturn {
1094            fn _tokenize(
1095                &self,
1096            ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1097                ()
1098            }
1099        }
1100        #[automatically_derived]
1101        impl alloy_sol_types::SolCall for transferOwnershipCall {
1102            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1103            type Token<'a> = <Self::Parameters<
1104                'a,
1105            > as alloy_sol_types::SolType>::Token<'a>;
1106            type Return = transferOwnershipReturn;
1107            type ReturnTuple<'a> = ();
1108            type ReturnToken<'a> = <Self::ReturnTuple<
1109                'a,
1110            > as alloy_sol_types::SolType>::Token<'a>;
1111            const SIGNATURE: &'static str = "transferOwnership(address)";
1112            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
1113            #[inline]
1114            fn new<'a>(
1115                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1116            ) -> Self {
1117                tuple.into()
1118            }
1119            #[inline]
1120            fn tokenize(&self) -> Self::Token<'_> {
1121                (
1122                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1123                        &self.newOwner,
1124                    ),
1125                )
1126            }
1127            #[inline]
1128            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1129                transferOwnershipReturn::_tokenize(ret)
1130            }
1131            #[inline]
1132            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1133                <Self::ReturnTuple<
1134                    '_,
1135                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1136                    .map(Into::into)
1137            }
1138            #[inline]
1139            fn abi_decode_returns_with_config(
1140                data: &[u8],
1141                config: alloy_sol_types::abi::AbiDecoderConfig,
1142            ) -> alloy_sol_types::Result<Self::Return> {
1143                <Self::ReturnTuple<
1144                    '_,
1145                > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
1146                        data,
1147                        config,
1148                    )
1149                    .map(Into::into)
1150            }
1151            #[inline]
1152            fn abi_decode_returns_validate(
1153                data: &[u8],
1154            ) -> alloy_sol_types::Result<Self::Return> {
1155                Self::abi_decode_returns_with_config(
1156                    data,
1157                    alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1158                )
1159            }
1160        }
1161    };
1162    ///Container for all the [`OwnableUpgradeable`](self) function calls.
1163    #[derive(Clone)]
1164    #[derive(serde::Serialize, serde::Deserialize)]
1165    #[derive(Debug, PartialEq, Eq, Hash)]
1166    pub enum OwnableUpgradeableCalls {
1167        #[allow(missing_docs)]
1168        owner(ownerCall),
1169        #[allow(missing_docs)]
1170        renounceOwnership(renounceOwnershipCall),
1171        #[allow(missing_docs)]
1172        transferOwnership(transferOwnershipCall),
1173    }
1174    impl OwnableUpgradeableCalls {
1175        /// All the selectors of this enum.
1176        ///
1177        /// Note that the selectors might not be in the same order as the variants.
1178        /// No guarantees are made about the order of the selectors.
1179        ///
1180        /// Prefer using `SolInterface` methods instead.
1181        pub const SELECTORS: &'static [[u8; 4usize]] = &[
1182            [113u8, 80u8, 24u8, 166u8],
1183            [141u8, 165u8, 203u8, 91u8],
1184            [242u8, 253u8, 227u8, 139u8],
1185        ];
1186        /// The names of the variants in the same order as `SELECTORS`.
1187        pub const VARIANT_NAMES: &'static [&'static str] = &[
1188            ::core::stringify!(renounceOwnership),
1189            ::core::stringify!(owner),
1190            ::core::stringify!(transferOwnership),
1191        ];
1192        /// The signatures in the same order as `SELECTORS`.
1193        pub const SIGNATURES: &'static [&'static str] = &[
1194            <renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
1195            <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
1196            <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
1197        ];
1198        /// Returns the signature for the given selector, if known.
1199        #[inline]
1200        pub fn signature_by_selector(
1201            selector: [u8; 4usize],
1202        ) -> ::core::option::Option<&'static str> {
1203            match Self::SELECTORS.binary_search(&selector) {
1204                ::core::result::Result::Ok(idx) => {
1205                    ::core::option::Option::Some(Self::SIGNATURES[idx])
1206                }
1207                ::core::result::Result::Err(_) => ::core::option::Option::None,
1208            }
1209        }
1210        /// Returns the enum variant name for the given selector, if known.
1211        #[inline]
1212        pub fn name_by_selector(
1213            selector: [u8; 4usize],
1214        ) -> ::core::option::Option<&'static str> {
1215            let sig = Self::signature_by_selector(selector)?;
1216            sig.split_once('(').map(|(name, _)| name)
1217        }
1218    }
1219    #[automatically_derived]
1220    impl alloy_sol_types::SolInterface for OwnableUpgradeableCalls {
1221        const NAME: &'static str = "OwnableUpgradeableCalls";
1222        const MIN_DATA_LENGTH: usize = 0usize;
1223        const COUNT: usize = 3usize;
1224        #[inline]
1225        fn selector(&self) -> [u8; 4] {
1226            match self {
1227                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
1228                Self::renounceOwnership(_) => {
1229                    <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1230                }
1231                Self::transferOwnership(_) => {
1232                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1233                }
1234            }
1235        }
1236        #[inline]
1237        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1238            Self::SELECTORS.get(i).copied()
1239        }
1240        #[inline]
1241        fn valid_selector(selector: [u8; 4]) -> bool {
1242            Self::SELECTORS.binary_search(&selector).is_ok()
1243        }
1244        #[inline]
1245        #[allow(non_snake_case)]
1246        fn abi_decode_raw(
1247            selector: [u8; 4],
1248            data: &[u8],
1249        ) -> alloy_sol_types::Result<Self> {
1250            Self::abi_decode_raw_with_config(
1251                selector,
1252                data,
1253                alloy_sol_types::abi::AbiDecoderConfig::default(),
1254            )
1255        }
1256        #[inline]
1257        #[allow(non_snake_case)]
1258        fn abi_decode_raw_with_config(
1259            selector: [u8; 4],
1260            data: &[u8],
1261            config: alloy_sol_types::abi::AbiDecoderConfig,
1262        ) -> alloy_sol_types::Result<Self> {
1263            static DECODE_SHIMS: &[fn(
1264                &[u8],
1265                alloy_sol_types::abi::AbiDecoderConfig,
1266            ) -> alloy_sol_types::Result<OwnableUpgradeableCalls>] = &[
1267                {
1268                    fn renounceOwnership(
1269                        data: &[u8],
1270                        config: alloy_sol_types::abi::AbiDecoderConfig,
1271                    ) -> alloy_sol_types::Result<OwnableUpgradeableCalls> {
1272                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
1273                                data,
1274                                config,
1275                            )
1276                            .map(OwnableUpgradeableCalls::renounceOwnership)
1277                    }
1278                    renounceOwnership
1279                },
1280                {
1281                    fn owner(
1282                        data: &[u8],
1283                        config: alloy_sol_types::abi::AbiDecoderConfig,
1284                    ) -> alloy_sol_types::Result<OwnableUpgradeableCalls> {
1285                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
1286                                data,
1287                                config,
1288                            )
1289                            .map(OwnableUpgradeableCalls::owner)
1290                    }
1291                    owner
1292                },
1293                {
1294                    fn transferOwnership(
1295                        data: &[u8],
1296                        config: alloy_sol_types::abi::AbiDecoderConfig,
1297                    ) -> alloy_sol_types::Result<OwnableUpgradeableCalls> {
1298                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
1299                                data,
1300                                config,
1301                            )
1302                            .map(OwnableUpgradeableCalls::transferOwnership)
1303                    }
1304                    transferOwnership
1305                },
1306            ];
1307            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1308                return Err(
1309                    alloy_sol_types::Error::unknown_selector(
1310                        <Self as alloy_sol_types::SolInterface>::NAME,
1311                        selector,
1312                    ),
1313                );
1314            };
1315            DECODE_SHIMS[idx](data, config)
1316        }
1317        #[inline]
1318        #[allow(non_snake_case)]
1319        fn abi_decode_raw_validate(
1320            selector: [u8; 4],
1321            data: &[u8],
1322        ) -> alloy_sol_types::Result<Self> {
1323            Self::abi_decode_raw_with_config(
1324                selector,
1325                data,
1326                alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1327            )
1328        }
1329        #[inline]
1330        fn abi_encoded_size(&self) -> usize {
1331            match self {
1332                Self::owner(inner) => {
1333                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1334                }
1335                Self::renounceOwnership(inner) => {
1336                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
1337                        inner,
1338                    )
1339                }
1340                Self::transferOwnership(inner) => {
1341                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
1342                        inner,
1343                    )
1344                }
1345            }
1346        }
1347        #[inline]
1348        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1349            match self {
1350                Self::owner(inner) => {
1351                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
1352                }
1353                Self::renounceOwnership(inner) => {
1354                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
1355                        inner,
1356                        out,
1357                    )
1358                }
1359                Self::transferOwnership(inner) => {
1360                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
1361                        inner,
1362                        out,
1363                    )
1364                }
1365            }
1366        }
1367    }
1368    ///Container for all the [`OwnableUpgradeable`](self) custom errors.
1369    #[derive(Clone)]
1370    #[derive(serde::Serialize, serde::Deserialize)]
1371    #[derive(Debug, PartialEq, Eq, Hash)]
1372    pub enum OwnableUpgradeableErrors {
1373        #[allow(missing_docs)]
1374        InvalidInitialization(InvalidInitialization),
1375        #[allow(missing_docs)]
1376        NotInitializing(NotInitializing),
1377        #[allow(missing_docs)]
1378        OwnableInvalidOwner(OwnableInvalidOwner),
1379        #[allow(missing_docs)]
1380        OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
1381    }
1382    impl OwnableUpgradeableErrors {
1383        /// All the selectors of this enum.
1384        ///
1385        /// Note that the selectors might not be in the same order as the variants.
1386        /// No guarantees are made about the order of the selectors.
1387        ///
1388        /// Prefer using `SolInterface` methods instead.
1389        pub const SELECTORS: &'static [[u8; 4usize]] = &[
1390            [17u8, 140u8, 218u8, 167u8],
1391            [30u8, 79u8, 189u8, 247u8],
1392            [215u8, 230u8, 188u8, 248u8],
1393            [249u8, 46u8, 232u8, 169u8],
1394        ];
1395        /// The names of the variants in the same order as `SELECTORS`.
1396        pub const VARIANT_NAMES: &'static [&'static str] = &[
1397            ::core::stringify!(OwnableUnauthorizedAccount),
1398            ::core::stringify!(OwnableInvalidOwner),
1399            ::core::stringify!(NotInitializing),
1400            ::core::stringify!(InvalidInitialization),
1401        ];
1402        /// The signatures in the same order as `SELECTORS`.
1403        pub const SIGNATURES: &'static [&'static str] = &[
1404            <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SIGNATURE,
1405            <OwnableInvalidOwner as alloy_sol_types::SolError>::SIGNATURE,
1406            <NotInitializing as alloy_sol_types::SolError>::SIGNATURE,
1407            <InvalidInitialization as alloy_sol_types::SolError>::SIGNATURE,
1408        ];
1409        /// Returns the signature for the given selector, if known.
1410        #[inline]
1411        pub fn signature_by_selector(
1412            selector: [u8; 4usize],
1413        ) -> ::core::option::Option<&'static str> {
1414            match Self::SELECTORS.binary_search(&selector) {
1415                ::core::result::Result::Ok(idx) => {
1416                    ::core::option::Option::Some(Self::SIGNATURES[idx])
1417                }
1418                ::core::result::Result::Err(_) => ::core::option::Option::None,
1419            }
1420        }
1421        /// Returns the enum variant name for the given selector, if known.
1422        #[inline]
1423        pub fn name_by_selector(
1424            selector: [u8; 4usize],
1425        ) -> ::core::option::Option<&'static str> {
1426            let sig = Self::signature_by_selector(selector)?;
1427            sig.split_once('(').map(|(name, _)| name)
1428        }
1429    }
1430    #[automatically_derived]
1431    impl alloy_sol_types::SolInterface for OwnableUpgradeableErrors {
1432        const NAME: &'static str = "OwnableUpgradeableErrors";
1433        const MIN_DATA_LENGTH: usize = 0usize;
1434        const COUNT: usize = 4usize;
1435        #[inline]
1436        fn selector(&self) -> [u8; 4] {
1437            match self {
1438                Self::InvalidInitialization(_) => {
1439                    <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
1440                }
1441                Self::NotInitializing(_) => {
1442                    <NotInitializing as alloy_sol_types::SolError>::SELECTOR
1443                }
1444                Self::OwnableInvalidOwner(_) => {
1445                    <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
1446                }
1447                Self::OwnableUnauthorizedAccount(_) => {
1448                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
1449                }
1450            }
1451        }
1452        #[inline]
1453        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1454            Self::SELECTORS.get(i).copied()
1455        }
1456        #[inline]
1457        fn valid_selector(selector: [u8; 4]) -> bool {
1458            Self::SELECTORS.binary_search(&selector).is_ok()
1459        }
1460        #[inline]
1461        #[allow(non_snake_case)]
1462        fn abi_decode_raw(
1463            selector: [u8; 4],
1464            data: &[u8],
1465        ) -> alloy_sol_types::Result<Self> {
1466            Self::abi_decode_raw_with_config(
1467                selector,
1468                data,
1469                alloy_sol_types::abi::AbiDecoderConfig::default(),
1470            )
1471        }
1472        #[inline]
1473        #[allow(non_snake_case)]
1474        fn abi_decode_raw_with_config(
1475            selector: [u8; 4],
1476            data: &[u8],
1477            config: alloy_sol_types::abi::AbiDecoderConfig,
1478        ) -> alloy_sol_types::Result<Self> {
1479            static DECODE_SHIMS: &[fn(
1480                &[u8],
1481                alloy_sol_types::abi::AbiDecoderConfig,
1482            ) -> alloy_sol_types::Result<OwnableUpgradeableErrors>] = &[
1483                {
1484                    fn OwnableUnauthorizedAccount(
1485                        data: &[u8],
1486                        config: alloy_sol_types::abi::AbiDecoderConfig,
1487                    ) -> alloy_sol_types::Result<OwnableUpgradeableErrors> {
1488                        <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw_with_config(
1489                                data,
1490                                config,
1491                            )
1492                            .map(OwnableUpgradeableErrors::OwnableUnauthorizedAccount)
1493                    }
1494                    OwnableUnauthorizedAccount
1495                },
1496                {
1497                    fn OwnableInvalidOwner(
1498                        data: &[u8],
1499                        config: alloy_sol_types::abi::AbiDecoderConfig,
1500                    ) -> alloy_sol_types::Result<OwnableUpgradeableErrors> {
1501                        <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw_with_config(
1502                                data,
1503                                config,
1504                            )
1505                            .map(OwnableUpgradeableErrors::OwnableInvalidOwner)
1506                    }
1507                    OwnableInvalidOwner
1508                },
1509                {
1510                    fn NotInitializing(
1511                        data: &[u8],
1512                        config: alloy_sol_types::abi::AbiDecoderConfig,
1513                    ) -> alloy_sol_types::Result<OwnableUpgradeableErrors> {
1514                        <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw_with_config(
1515                                data,
1516                                config,
1517                            )
1518                            .map(OwnableUpgradeableErrors::NotInitializing)
1519                    }
1520                    NotInitializing
1521                },
1522                {
1523                    fn InvalidInitialization(
1524                        data: &[u8],
1525                        config: alloy_sol_types::abi::AbiDecoderConfig,
1526                    ) -> alloy_sol_types::Result<OwnableUpgradeableErrors> {
1527                        <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw_with_config(
1528                                data,
1529                                config,
1530                            )
1531                            .map(OwnableUpgradeableErrors::InvalidInitialization)
1532                    }
1533                    InvalidInitialization
1534                },
1535            ];
1536            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1537                return Err(
1538                    alloy_sol_types::Error::unknown_selector(
1539                        <Self as alloy_sol_types::SolInterface>::NAME,
1540                        selector,
1541                    ),
1542                );
1543            };
1544            DECODE_SHIMS[idx](data, config)
1545        }
1546        #[inline]
1547        #[allow(non_snake_case)]
1548        fn abi_decode_raw_validate(
1549            selector: [u8; 4],
1550            data: &[u8],
1551        ) -> alloy_sol_types::Result<Self> {
1552            Self::abi_decode_raw_with_config(
1553                selector,
1554                data,
1555                alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1556            )
1557        }
1558        #[inline]
1559        fn abi_encoded_size(&self) -> usize {
1560            match self {
1561                Self::InvalidInitialization(inner) => {
1562                    <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(
1563                        inner,
1564                    )
1565                }
1566                Self::NotInitializing(inner) => {
1567                    <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(
1568                        inner,
1569                    )
1570                }
1571                Self::OwnableInvalidOwner(inner) => {
1572                    <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
1573                        inner,
1574                    )
1575                }
1576                Self::OwnableUnauthorizedAccount(inner) => {
1577                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
1578                        inner,
1579                    )
1580                }
1581            }
1582        }
1583        #[inline]
1584        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1585            match self {
1586                Self::InvalidInitialization(inner) => {
1587                    <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(
1588                        inner,
1589                        out,
1590                    )
1591                }
1592                Self::NotInitializing(inner) => {
1593                    <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(
1594                        inner,
1595                        out,
1596                    )
1597                }
1598                Self::OwnableInvalidOwner(inner) => {
1599                    <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
1600                        inner,
1601                        out,
1602                    )
1603                }
1604                Self::OwnableUnauthorizedAccount(inner) => {
1605                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
1606                        inner,
1607                        out,
1608                    )
1609                }
1610            }
1611        }
1612    }
1613    #[automatically_derived]
1614    impl OwnableUpgradeableErrors {
1615        /**Creates a [`InvalidInitialization`] error.
1616
1617```solidity
1618error InvalidInitialization()
1619```*/
1620        #[inline]
1621        pub fn invalid_initialization() -> Self {
1622            Self::InvalidInitialization(InvalidInitialization)
1623        }
1624        /**Creates a [`NotInitializing`] error.
1625
1626```solidity
1627error NotInitializing()
1628```*/
1629        #[inline]
1630        pub fn not_initializing() -> Self {
1631            Self::NotInitializing(NotInitializing)
1632        }
1633        /**Creates a [`OwnableInvalidOwner`] error.
1634
1635```solidity
1636error OwnableInvalidOwner(address)
1637```*/
1638        #[inline]
1639        pub fn ownable_invalid_owner(owner: alloy::sol_types::private::Address) -> Self {
1640            Self::OwnableInvalidOwner(OwnableInvalidOwner {
1641                owner: owner,
1642            })
1643        }
1644        /**Creates a [`OwnableUnauthorizedAccount`] error.
1645
1646```solidity
1647error OwnableUnauthorizedAccount(address)
1648```*/
1649        #[inline]
1650        pub fn ownable_unauthorized_account(
1651            account: alloy::sol_types::private::Address,
1652        ) -> Self {
1653            Self::OwnableUnauthorizedAccount(OwnableUnauthorizedAccount {
1654                account: account,
1655            })
1656        }
1657    }
1658    ///Container for all the [`OwnableUpgradeable`](self) events.
1659    #[derive(Clone)]
1660    #[derive(serde::Serialize, serde::Deserialize)]
1661    #[derive(Debug, PartialEq, Eq, Hash)]
1662    pub enum OwnableUpgradeableEvents {
1663        #[allow(missing_docs)]
1664        Initialized(Initialized),
1665        #[allow(missing_docs)]
1666        OwnershipTransferred(OwnershipTransferred),
1667    }
1668    impl OwnableUpgradeableEvents {
1669        /// All the selectors of this enum.
1670        ///
1671        /// Note that the selectors might not be in the same order as the variants.
1672        /// No guarantees are made about the order of the selectors.
1673        ///
1674        /// Prefer using `SolInterface` methods instead.
1675        pub const SELECTORS: &'static [[u8; 32usize]] = &[
1676            [
1677                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
1678                31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
1679                218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
1680            ],
1681            [
1682                199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
1683                19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
1684                33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
1685            ],
1686        ];
1687        /// The names of the variants in the same order as `SELECTORS`.
1688        pub const VARIANT_NAMES: &'static [&'static str] = &[
1689            ::core::stringify!(OwnershipTransferred),
1690            ::core::stringify!(Initialized),
1691        ];
1692        /// The signatures in the same order as `SELECTORS`.
1693        pub const SIGNATURES: &'static [&'static str] = &[
1694            <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
1695            <Initialized as alloy_sol_types::SolEvent>::SIGNATURE,
1696        ];
1697        /// Returns the signature for the given selector, if known.
1698        #[inline]
1699        pub fn signature_by_selector(
1700            selector: [u8; 32usize],
1701        ) -> ::core::option::Option<&'static str> {
1702            match Self::SELECTORS.binary_search(&selector) {
1703                ::core::result::Result::Ok(idx) => {
1704                    ::core::option::Option::Some(Self::SIGNATURES[idx])
1705                }
1706                ::core::result::Result::Err(_) => ::core::option::Option::None,
1707            }
1708        }
1709        /// Returns the enum variant name for the given selector, if known.
1710        #[inline]
1711        pub fn name_by_selector(
1712            selector: [u8; 32usize],
1713        ) -> ::core::option::Option<&'static str> {
1714            let sig = Self::signature_by_selector(selector)?;
1715            sig.split_once('(').map(|(name, _)| name)
1716        }
1717    }
1718    #[automatically_derived]
1719    impl alloy_sol_types::SolEventInterface for OwnableUpgradeableEvents {
1720        const NAME: &'static str = "OwnableUpgradeableEvents";
1721        const COUNT: usize = 2usize;
1722        fn decode_raw_log(
1723            topics: &[alloy_sol_types::Word],
1724            data: &[u8],
1725        ) -> alloy_sol_types::Result<Self> {
1726            <Self as alloy_sol_types::SolEventInterface>::decode_raw_log_with_config(
1727                topics,
1728                data,
1729                alloy_sol_types::abi::AbiDecoderConfig::default(),
1730            )
1731        }
1732        fn decode_raw_log_with_config(
1733            topics: &[alloy_sol_types::Word],
1734            data: &[u8],
1735            config: alloy_sol_types::abi::AbiDecoderConfig,
1736        ) -> alloy_sol_types::Result<Self> {
1737            match topics.first().copied() {
1738                Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
1739                    <Initialized as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
1740                            topics,
1741                            data,
1742                            config,
1743                        )
1744                        .map(Self::Initialized)
1745                }
1746                Some(
1747                    <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
1748                ) => {
1749                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
1750                            topics,
1751                            data,
1752                            config,
1753                        )
1754                        .map(Self::OwnershipTransferred)
1755                }
1756                _ => {
1757                    if topics
1758                        .len()
1759                        .checked_mul(alloy_sol_types::Word::len_bytes())
1760                        .and_then(|len| len.checked_add(data.len()))
1761                        .is_none_or(|len| len > config.get_memory_limit())
1762                    {
1763                        return alloy_sol_types::private::Err(
1764                            alloy_sol_types::Error::MemoryLimitExceeded(
1765                                config.get_memory_limit(),
1766                            ),
1767                        );
1768                    }
1769                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
1770                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
1771                        log: alloy_sol_types::private::Box::new(
1772                            alloy_sol_types::private::LogData::new_unchecked(
1773                                topics.to_vec(),
1774                                data.to_vec().into(),
1775                            ),
1776                        ),
1777                    })
1778                }
1779            }
1780        }
1781    }
1782    #[automatically_derived]
1783    impl alloy_sol_types::private::IntoLogData for OwnableUpgradeableEvents {
1784        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1785            match self {
1786                Self::Initialized(inner) => {
1787                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
1788                }
1789                Self::OwnershipTransferred(inner) => {
1790                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
1791                }
1792            }
1793        }
1794        fn into_log_data(self) -> alloy_sol_types::private::LogData {
1795            match self {
1796                Self::Initialized(inner) => {
1797                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
1798                }
1799                Self::OwnershipTransferred(inner) => {
1800                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
1801                }
1802            }
1803        }
1804    }
1805    #[automatically_derived]
1806    impl OwnableUpgradeableEvents {
1807        /**Creates a [`Initialized`] event.
1808
1809```solidity
1810event Initialized(uint64)
1811```*/
1812        #[inline]
1813        pub fn initialized(version: u64) -> Self {
1814            Self::Initialized(Initialized { version: version })
1815        }
1816        /**Creates a [`OwnershipTransferred`] event.
1817
1818```solidity
1819event OwnershipTransferred(address,address)
1820```*/
1821        #[inline]
1822        pub fn ownership_transferred(
1823            previous_owner: alloy::sol_types::private::Address,
1824            new_owner: alloy::sol_types::private::Address,
1825        ) -> Self {
1826            Self::OwnershipTransferred(OwnershipTransferred {
1827                previousOwner: previous_owner,
1828                newOwner: new_owner,
1829            })
1830        }
1831    }
1832    use alloy::contract as alloy_contract;
1833    /**Creates a new wrapper around an on-chain [`OwnableUpgradeable`](self) contract instance.
1834
1835See the [wrapper's documentation](`OwnableUpgradeableInstance`) for more details.*/
1836    #[inline]
1837    pub const fn new<
1838        P: alloy_contract::private::Provider<N>,
1839        N: alloy_contract::private::Network,
1840    >(
1841        address: alloy_sol_types::private::Address,
1842        __provider: P,
1843    ) -> OwnableUpgradeableInstance<P, N> {
1844        OwnableUpgradeableInstance::<P, N>::new(address, __provider)
1845    }
1846    /**Deploys this contract using the given `provider` and constructor arguments, if any.
1847
1848Returns a new instance of the contract, if the deployment was successful.
1849
1850For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1851    #[inline]
1852    pub fn deploy<
1853        P: alloy_contract::private::Provider<N>,
1854        N: alloy_contract::private::Network,
1855    >(
1856        __provider: P,
1857    ) -> impl ::core::future::Future<
1858        Output = alloy_contract::Result<OwnableUpgradeableInstance<P, N>>,
1859    > {
1860        OwnableUpgradeableInstance::<P, N>::deploy(__provider)
1861    }
1862    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1863and constructor arguments, if any.
1864
1865This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1866the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1867    #[inline]
1868    pub fn deploy_builder<
1869        P: alloy_contract::private::Provider<N>,
1870        N: alloy_contract::private::Network,
1871    >(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
1872        OwnableUpgradeableInstance::<P, N>::deploy_builder(__provider)
1873    }
1874    /**A [`OwnableUpgradeable`](self) instance.
1875
1876Contains type-safe methods for interacting with an on-chain instance of the
1877[`OwnableUpgradeable`](self) contract located at a given `address`, using a given
1878provider `P`.
1879
1880If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1881documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1882be used to deploy a new instance of the contract.
1883
1884See the [module-level documentation](self) for all the available methods.*/
1885    #[derive(Clone)]
1886    pub struct OwnableUpgradeableInstance<P, N = alloy_contract::private::Ethereum> {
1887        address: alloy_sol_types::private::Address,
1888        provider: P,
1889        _network: ::core::marker::PhantomData<N>,
1890    }
1891    #[automatically_derived]
1892    impl<P, N> ::core::fmt::Debug for OwnableUpgradeableInstance<P, N> {
1893        #[inline]
1894        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1895            f.debug_tuple("OwnableUpgradeableInstance").field(&self.address).finish()
1896        }
1897    }
1898    /// Instantiation and getters/setters.
1899    impl<
1900        P: alloy_contract::private::Provider<N>,
1901        N: alloy_contract::private::Network,
1902    > OwnableUpgradeableInstance<P, N> {
1903        /**Creates a new wrapper around an on-chain [`OwnableUpgradeable`](self) contract instance.
1904
1905See the [wrapper's documentation](`OwnableUpgradeableInstance`) for more details.*/
1906        #[inline]
1907        pub const fn new(
1908            address: alloy_sol_types::private::Address,
1909            __provider: P,
1910        ) -> Self {
1911            Self {
1912                address,
1913                provider: __provider,
1914                _network: ::core::marker::PhantomData,
1915            }
1916        }
1917        /**Deploys this contract using the given `provider` and constructor arguments, if any.
1918
1919Returns a new instance of the contract, if the deployment was successful.
1920
1921For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1922        #[inline]
1923        pub async fn deploy(
1924            __provider: P,
1925        ) -> alloy_contract::Result<OwnableUpgradeableInstance<P, N>> {
1926            let call_builder = Self::deploy_builder(__provider);
1927            let contract_address = call_builder.deploy().await?;
1928            Ok(Self::new(contract_address, call_builder.provider))
1929        }
1930        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1931and constructor arguments, if any.
1932
1933This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1934the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1935        #[inline]
1936        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
1937            alloy_contract::RawCallBuilder::new_raw_deploy(
1938                __provider,
1939                ::core::clone::Clone::clone(&BYTECODE),
1940            )
1941        }
1942        /// Returns a reference to the address.
1943        #[inline]
1944        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1945            &self.address
1946        }
1947        /// Sets the address.
1948        #[inline]
1949        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1950            self.address = address;
1951        }
1952        /// Sets the address and returns `self`.
1953        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1954            self.set_address(address);
1955            self
1956        }
1957        /// Returns a reference to the provider.
1958        #[inline]
1959        pub const fn provider(&self) -> &P {
1960            &self.provider
1961        }
1962    }
1963    impl<P: ::core::clone::Clone, N> OwnableUpgradeableInstance<&P, N> {
1964        /// Clones the provider and returns a new instance with the cloned provider.
1965        #[inline]
1966        pub fn with_cloned_provider(self) -> OwnableUpgradeableInstance<P, N> {
1967            OwnableUpgradeableInstance {
1968                address: self.address,
1969                provider: ::core::clone::Clone::clone(&self.provider),
1970                _network: ::core::marker::PhantomData,
1971            }
1972        }
1973    }
1974    /// Function calls.
1975    impl<
1976        P: alloy_contract::private::Provider<N>,
1977        N: alloy_contract::private::Network,
1978    > OwnableUpgradeableInstance<P, N> {
1979        /// Creates a new call builder using this contract instance's provider and address.
1980        ///
1981        /// Note that the call can be any function call, not just those defined in this
1982        /// contract. Prefer using the other methods for building type-safe contract calls.
1983        pub fn call_builder<C: alloy_sol_types::SolCall>(
1984            &self,
1985            call: &C,
1986        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1987            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1988        }
1989        ///Creates a new call builder for the [`owner`] function.
1990        pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
1991            self.call_builder(&ownerCall)
1992        }
1993        ///Creates a new call builder for the [`renounceOwnership`] function.
1994        pub fn renounceOwnership(
1995            &self,
1996        ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
1997            self.call_builder(&renounceOwnershipCall)
1998        }
1999        ///Creates a new call builder for the [`transferOwnership`] function.
2000        pub fn transferOwnership(
2001            &self,
2002            newOwner: alloy::sol_types::private::Address,
2003        ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
2004            self.call_builder(&transferOwnershipCall { newOwner })
2005        }
2006    }
2007    /// Event filters.
2008    impl<
2009        P: alloy_contract::private::Provider<N>,
2010        N: alloy_contract::private::Network,
2011    > OwnableUpgradeableInstance<P, N> {
2012        /// Creates a new event filter using this contract instance's provider and address.
2013        ///
2014        /// Note that the type can be any event, not just those defined in this contract.
2015        /// Prefer using the other methods for building type-safe event filters.
2016        pub fn event_filter<E: alloy_sol_types::SolEvent>(
2017            &self,
2018        ) -> alloy_contract::Event<&P, E, N> {
2019            alloy_contract::Event::new_sol(&self.provider, &self.address)
2020        }
2021        ///Creates a new event filter for the [`Initialized`] event.
2022        pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
2023            self.event_filter::<Initialized>()
2024        }
2025        ///Creates a new event filter for the [`OwnershipTransferred`] event.
2026        pub fn OwnershipTransferred_filter(
2027            &self,
2028        ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
2029            self.event_filter::<OwnershipTransferred>()
2030        }
2031    }
2032}