hotshot_contract_adapter/bindings/
ownable_upgradeable.rs

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

hotshot_contract_adapter/bindings/
ownable_upgradeable.rs
