pod_contracts/
profileregistry.rs

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

pod_contracts/
profileregistry.rs
