1#[allow(
280 non_camel_case_types,
281 non_snake_case,
282 clippy::pub_underscore_fields,
283 clippy::style,
284 clippy::empty_structs_with_brackets
285)]
286pub mod AccessControlUpgradeable {
287 use super::*;
288 use alloy::sol_types as alloy_sol_types;
289 #[rustfmt::skip]
295 #[allow(clippy::all)]
296 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
297 b"",
298 );
299 #[rustfmt::skip]
305 #[allow(clippy::all)]
306 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
307 b"",
308 );
309 #[derive(serde::Serialize, serde::Deserialize)]
310 #[derive(Default, Debug, PartialEq, Eq, Hash)]
311 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
316 #[derive(Clone)]
317 pub struct AccessControlBadConfirmation;
318 #[allow(
319 non_camel_case_types,
320 non_snake_case,
321 clippy::pub_underscore_fields,
322 clippy::style
323 )]
324 const _: () = {
325 use alloy::sol_types as alloy_sol_types;
326 #[doc(hidden)]
327 #[allow(dead_code)]
328 type UnderlyingSolTuple<'a> = ();
329 #[doc(hidden)]
330 type UnderlyingRustTuple<'a> = ();
331 #[cfg(test)]
332 #[allow(dead_code, unreachable_patterns)]
333 fn _type_assertion(
334 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
335 ) {
336 match _t {
337 alloy_sol_types::private::AssertTypeEq::<
338 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
339 >(_) => {}
340 }
341 }
342 #[automatically_derived]
343 #[doc(hidden)]
344 impl ::core::convert::From<AccessControlBadConfirmation>
345 for UnderlyingRustTuple<'_> {
346 fn from(value: AccessControlBadConfirmation) -> Self {
347 ()
348 }
349 }
350 #[automatically_derived]
351 #[doc(hidden)]
352 impl ::core::convert::From<UnderlyingRustTuple<'_>>
353 for AccessControlBadConfirmation {
354 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
355 Self
356 }
357 }
358 #[automatically_derived]
359 impl alloy_sol_types::SolError for AccessControlBadConfirmation {
360 type Parameters<'a> = UnderlyingSolTuple<'a>;
361 type Token<'a> = <Self::Parameters<
362 'a,
363 > as alloy_sol_types::SolType>::Token<'a>;
364 const SIGNATURE: &'static str = "AccessControlBadConfirmation()";
365 const SELECTOR: [u8; 4] = [102u8, 151u8, 178u8, 50u8];
366 #[inline]
367 fn new<'a>(
368 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
369 ) -> Self {
370 tuple.into()
371 }
372 #[inline]
373 fn tokenize(&self) -> Self::Token<'_> {
374 ()
375 }
376 #[inline]
377 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
378 <Self::Parameters<
379 '_,
380 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
381 .map(Self::new)
382 }
383 }
384 };
385 #[derive(serde::Serialize, serde::Deserialize)]
386 #[derive(Default, Debug, PartialEq, Eq, Hash)]
387 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
392 #[derive(Clone)]
393 pub struct AccessControlUnauthorizedAccount {
394 #[allow(missing_docs)]
395 pub account: alloy::sol_types::private::Address,
396 #[allow(missing_docs)]
397 pub neededRole: alloy::sol_types::private::FixedBytes<32>,
398 }
399 #[allow(
400 non_camel_case_types,
401 non_snake_case,
402 clippy::pub_underscore_fields,
403 clippy::style
404 )]
405 const _: () = {
406 use alloy::sol_types as alloy_sol_types;
407 #[doc(hidden)]
408 #[allow(dead_code)]
409 type UnderlyingSolTuple<'a> = (
410 alloy::sol_types::sol_data::Address,
411 alloy::sol_types::sol_data::FixedBytes<32>,
412 );
413 #[doc(hidden)]
414 type UnderlyingRustTuple<'a> = (
415 alloy::sol_types::private::Address,
416 alloy::sol_types::private::FixedBytes<32>,
417 );
418 #[cfg(test)]
419 #[allow(dead_code, unreachable_patterns)]
420 fn _type_assertion(
421 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
422 ) {
423 match _t {
424 alloy_sol_types::private::AssertTypeEq::<
425 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
426 >(_) => {}
427 }
428 }
429 #[automatically_derived]
430 #[doc(hidden)]
431 impl ::core::convert::From<AccessControlUnauthorizedAccount>
432 for UnderlyingRustTuple<'_> {
433 fn from(value: AccessControlUnauthorizedAccount) -> Self {
434 (value.account, value.neededRole)
435 }
436 }
437 #[automatically_derived]
438 #[doc(hidden)]
439 impl ::core::convert::From<UnderlyingRustTuple<'_>>
440 for AccessControlUnauthorizedAccount {
441 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
442 Self {
443 account: tuple.0,
444 neededRole: tuple.1,
445 }
446 }
447 }
448 #[automatically_derived]
449 impl alloy_sol_types::SolError for AccessControlUnauthorizedAccount {
450 type Parameters<'a> = UnderlyingSolTuple<'a>;
451 type Token<'a> = <Self::Parameters<
452 'a,
453 > as alloy_sol_types::SolType>::Token<'a>;
454 const SIGNATURE: &'static str = "AccessControlUnauthorizedAccount(address,bytes32)";
455 const SELECTOR: [u8; 4] = [226u8, 81u8, 125u8, 63u8];
456 #[inline]
457 fn new<'a>(
458 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
459 ) -> Self {
460 tuple.into()
461 }
462 #[inline]
463 fn tokenize(&self) -> Self::Token<'_> {
464 (
465 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
466 &self.account,
467 ),
468 <alloy::sol_types::sol_data::FixedBytes<
469 32,
470 > as alloy_sol_types::SolType>::tokenize(&self.neededRole),
471 )
472 }
473 #[inline]
474 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
475 <Self::Parameters<
476 '_,
477 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
478 .map(Self::new)
479 }
480 }
481 };
482 #[derive(serde::Serialize, serde::Deserialize)]
483 #[derive(Default, Debug, PartialEq, Eq, Hash)]
484 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
489 #[derive(Clone)]
490 pub struct InvalidInitialization;
491 #[allow(
492 non_camel_case_types,
493 non_snake_case,
494 clippy::pub_underscore_fields,
495 clippy::style
496 )]
497 const _: () = {
498 use alloy::sol_types as alloy_sol_types;
499 #[doc(hidden)]
500 #[allow(dead_code)]
501 type UnderlyingSolTuple<'a> = ();
502 #[doc(hidden)]
503 type UnderlyingRustTuple<'a> = ();
504 #[cfg(test)]
505 #[allow(dead_code, unreachable_patterns)]
506 fn _type_assertion(
507 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
508 ) {
509 match _t {
510 alloy_sol_types::private::AssertTypeEq::<
511 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
512 >(_) => {}
513 }
514 }
515 #[automatically_derived]
516 #[doc(hidden)]
517 impl ::core::convert::From<InvalidInitialization> for UnderlyingRustTuple<'_> {
518 fn from(value: InvalidInitialization) -> Self {
519 ()
520 }
521 }
522 #[automatically_derived]
523 #[doc(hidden)]
524 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInitialization {
525 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
526 Self
527 }
528 }
529 #[automatically_derived]
530 impl alloy_sol_types::SolError for InvalidInitialization {
531 type Parameters<'a> = UnderlyingSolTuple<'a>;
532 type Token<'a> = <Self::Parameters<
533 'a,
534 > as alloy_sol_types::SolType>::Token<'a>;
535 const SIGNATURE: &'static str = "InvalidInitialization()";
536 const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8];
537 #[inline]
538 fn new<'a>(
539 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
540 ) -> Self {
541 tuple.into()
542 }
543 #[inline]
544 fn tokenize(&self) -> Self::Token<'_> {
545 ()
546 }
547 #[inline]
548 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
549 <Self::Parameters<
550 '_,
551 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
552 .map(Self::new)
553 }
554 }
555 };
556 #[derive(serde::Serialize, serde::Deserialize)]
557 #[derive(Default, Debug, PartialEq, Eq, Hash)]
558 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
563 #[derive(Clone)]
564 pub struct NotInitializing;
565 #[allow(
566 non_camel_case_types,
567 non_snake_case,
568 clippy::pub_underscore_fields,
569 clippy::style
570 )]
571 const _: () = {
572 use alloy::sol_types as alloy_sol_types;
573 #[doc(hidden)]
574 #[allow(dead_code)]
575 type UnderlyingSolTuple<'a> = ();
576 #[doc(hidden)]
577 type UnderlyingRustTuple<'a> = ();
578 #[cfg(test)]
579 #[allow(dead_code, unreachable_patterns)]
580 fn _type_assertion(
581 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
582 ) {
583 match _t {
584 alloy_sol_types::private::AssertTypeEq::<
585 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
586 >(_) => {}
587 }
588 }
589 #[automatically_derived]
590 #[doc(hidden)]
591 impl ::core::convert::From<NotInitializing> for UnderlyingRustTuple<'_> {
592 fn from(value: NotInitializing) -> Self {
593 ()
594 }
595 }
596 #[automatically_derived]
597 #[doc(hidden)]
598 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotInitializing {
599 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
600 Self
601 }
602 }
603 #[automatically_derived]
604 impl alloy_sol_types::SolError for NotInitializing {
605 type Parameters<'a> = UnderlyingSolTuple<'a>;
606 type Token<'a> = <Self::Parameters<
607 'a,
608 > as alloy_sol_types::SolType>::Token<'a>;
609 const SIGNATURE: &'static str = "NotInitializing()";
610 const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8];
611 #[inline]
612 fn new<'a>(
613 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
614 ) -> Self {
615 tuple.into()
616 }
617 #[inline]
618 fn tokenize(&self) -> Self::Token<'_> {
619 ()
620 }
621 #[inline]
622 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
623 <Self::Parameters<
624 '_,
625 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
626 .map(Self::new)
627 }
628 }
629 };
630 #[derive(serde::Serialize, serde::Deserialize)]
631 #[derive(Default, Debug, PartialEq, Eq, Hash)]
632 #[allow(
637 non_camel_case_types,
638 non_snake_case,
639 clippy::pub_underscore_fields,
640 clippy::style
641 )]
642 #[derive(Clone)]
643 pub struct Initialized {
644 #[allow(missing_docs)]
645 pub version: u64,
646 }
647 #[allow(
648 non_camel_case_types,
649 non_snake_case,
650 clippy::pub_underscore_fields,
651 clippy::style
652 )]
653 const _: () = {
654 use alloy::sol_types as alloy_sol_types;
655 #[automatically_derived]
656 impl alloy_sol_types::SolEvent for Initialized {
657 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
658 type DataToken<'a> = <Self::DataTuple<
659 'a,
660 > as alloy_sol_types::SolType>::Token<'a>;
661 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
662 const SIGNATURE: &'static str = "Initialized(uint64)";
663 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
664 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
665 19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
666 33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
667 ]);
668 const ANONYMOUS: bool = false;
669 #[allow(unused_variables)]
670 #[inline]
671 fn new(
672 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
673 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
674 ) -> Self {
675 Self { version: data.0 }
676 }
677 #[inline]
678 fn check_signature(
679 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
680 ) -> alloy_sol_types::Result<()> {
681 if topics.0 != Self::SIGNATURE_HASH {
682 return Err(
683 alloy_sol_types::Error::invalid_event_signature_hash(
684 Self::SIGNATURE,
685 topics.0,
686 Self::SIGNATURE_HASH,
687 ),
688 );
689 }
690 Ok(())
691 }
692 #[inline]
693 fn tokenize_body(&self) -> Self::DataToken<'_> {
694 (
695 <alloy::sol_types::sol_data::Uint<
696 64,
697 > as alloy_sol_types::SolType>::tokenize(&self.version),
698 )
699 }
700 #[inline]
701 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
702 (Self::SIGNATURE_HASH.into(),)
703 }
704 #[inline]
705 fn encode_topics_raw(
706 &self,
707 out: &mut [alloy_sol_types::abi::token::WordToken],
708 ) -> alloy_sol_types::Result<()> {
709 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
710 return Err(alloy_sol_types::Error::Overrun);
711 }
712 out[0usize] = alloy_sol_types::abi::token::WordToken(
713 Self::SIGNATURE_HASH,
714 );
715 Ok(())
716 }
717 }
718 #[automatically_derived]
719 impl alloy_sol_types::private::IntoLogData for Initialized {
720 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
721 From::from(self)
722 }
723 fn into_log_data(self) -> alloy_sol_types::private::LogData {
724 From::from(&self)
725 }
726 }
727 #[automatically_derived]
728 impl From<&Initialized> for alloy_sol_types::private::LogData {
729 #[inline]
730 fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
731 alloy_sol_types::SolEvent::encode_log_data(this)
732 }
733 }
734 };
735 #[derive(serde::Serialize, serde::Deserialize)]
736 #[derive(Default, Debug, PartialEq, Eq, Hash)]
737 #[allow(
742 non_camel_case_types,
743 non_snake_case,
744 clippy::pub_underscore_fields,
745 clippy::style
746 )]
747 #[derive(Clone)]
748 pub struct RoleAdminChanged {
749 #[allow(missing_docs)]
750 pub role: alloy::sol_types::private::FixedBytes<32>,
751 #[allow(missing_docs)]
752 pub previousAdminRole: alloy::sol_types::private::FixedBytes<32>,
753 #[allow(missing_docs)]
754 pub newAdminRole: alloy::sol_types::private::FixedBytes<32>,
755 }
756 #[allow(
757 non_camel_case_types,
758 non_snake_case,
759 clippy::pub_underscore_fields,
760 clippy::style
761 )]
762 const _: () = {
763 use alloy::sol_types as alloy_sol_types;
764 #[automatically_derived]
765 impl alloy_sol_types::SolEvent for RoleAdminChanged {
766 type DataTuple<'a> = ();
767 type DataToken<'a> = <Self::DataTuple<
768 'a,
769 > as alloy_sol_types::SolType>::Token<'a>;
770 type TopicList = (
771 alloy_sol_types::sol_data::FixedBytes<32>,
772 alloy::sol_types::sol_data::FixedBytes<32>,
773 alloy::sol_types::sol_data::FixedBytes<32>,
774 alloy::sol_types::sol_data::FixedBytes<32>,
775 );
776 const SIGNATURE: &'static str = "RoleAdminChanged(bytes32,bytes32,bytes32)";
777 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
778 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
779 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
780 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
781 ]);
782 const ANONYMOUS: bool = false;
783 #[allow(unused_variables)]
784 #[inline]
785 fn new(
786 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
787 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
788 ) -> Self {
789 Self {
790 role: topics.1,
791 previousAdminRole: topics.2,
792 newAdminRole: topics.3,
793 }
794 }
795 #[inline]
796 fn check_signature(
797 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
798 ) -> alloy_sol_types::Result<()> {
799 if topics.0 != Self::SIGNATURE_HASH {
800 return Err(
801 alloy_sol_types::Error::invalid_event_signature_hash(
802 Self::SIGNATURE,
803 topics.0,
804 Self::SIGNATURE_HASH,
805 ),
806 );
807 }
808 Ok(())
809 }
810 #[inline]
811 fn tokenize_body(&self) -> Self::DataToken<'_> {
812 ()
813 }
814 #[inline]
815 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
816 (
817 Self::SIGNATURE_HASH.into(),
818 self.role.clone(),
819 self.previousAdminRole.clone(),
820 self.newAdminRole.clone(),
821 )
822 }
823 #[inline]
824 fn encode_topics_raw(
825 &self,
826 out: &mut [alloy_sol_types::abi::token::WordToken],
827 ) -> alloy_sol_types::Result<()> {
828 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
829 return Err(alloy_sol_types::Error::Overrun);
830 }
831 out[0usize] = alloy_sol_types::abi::token::WordToken(
832 Self::SIGNATURE_HASH,
833 );
834 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
835 32,
836 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
837 out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
838 32,
839 > as alloy_sol_types::EventTopic>::encode_topic(&self.previousAdminRole);
840 out[3usize] = <alloy::sol_types::sol_data::FixedBytes<
841 32,
842 > as alloy_sol_types::EventTopic>::encode_topic(&self.newAdminRole);
843 Ok(())
844 }
845 }
846 #[automatically_derived]
847 impl alloy_sol_types::private::IntoLogData for RoleAdminChanged {
848 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
849 From::from(self)
850 }
851 fn into_log_data(self) -> alloy_sol_types::private::LogData {
852 From::from(&self)
853 }
854 }
855 #[automatically_derived]
856 impl From<&RoleAdminChanged> for alloy_sol_types::private::LogData {
857 #[inline]
858 fn from(this: &RoleAdminChanged) -> alloy_sol_types::private::LogData {
859 alloy_sol_types::SolEvent::encode_log_data(this)
860 }
861 }
862 };
863 #[derive(serde::Serialize, serde::Deserialize)]
864 #[derive(Default, Debug, PartialEq, Eq, Hash)]
865 #[allow(
870 non_camel_case_types,
871 non_snake_case,
872 clippy::pub_underscore_fields,
873 clippy::style
874 )]
875 #[derive(Clone)]
876 pub struct RoleGranted {
877 #[allow(missing_docs)]
878 pub role: alloy::sol_types::private::FixedBytes<32>,
879 #[allow(missing_docs)]
880 pub account: alloy::sol_types::private::Address,
881 #[allow(missing_docs)]
882 pub sender: alloy::sol_types::private::Address,
883 }
884 #[allow(
885 non_camel_case_types,
886 non_snake_case,
887 clippy::pub_underscore_fields,
888 clippy::style
889 )]
890 const _: () = {
891 use alloy::sol_types as alloy_sol_types;
892 #[automatically_derived]
893 impl alloy_sol_types::SolEvent for RoleGranted {
894 type DataTuple<'a> = ();
895 type DataToken<'a> = <Self::DataTuple<
896 'a,
897 > as alloy_sol_types::SolType>::Token<'a>;
898 type TopicList = (
899 alloy_sol_types::sol_data::FixedBytes<32>,
900 alloy::sol_types::sol_data::FixedBytes<32>,
901 alloy::sol_types::sol_data::Address,
902 alloy::sol_types::sol_data::Address,
903 );
904 const SIGNATURE: &'static str = "RoleGranted(bytes32,address,address)";
905 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
906 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
907 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
908 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
909 ]);
910 const ANONYMOUS: bool = false;
911 #[allow(unused_variables)]
912 #[inline]
913 fn new(
914 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
915 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
916 ) -> Self {
917 Self {
918 role: topics.1,
919 account: topics.2,
920 sender: topics.3,
921 }
922 }
923 #[inline]
924 fn check_signature(
925 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
926 ) -> alloy_sol_types::Result<()> {
927 if topics.0 != Self::SIGNATURE_HASH {
928 return Err(
929 alloy_sol_types::Error::invalid_event_signature_hash(
930 Self::SIGNATURE,
931 topics.0,
932 Self::SIGNATURE_HASH,
933 ),
934 );
935 }
936 Ok(())
937 }
938 #[inline]
939 fn tokenize_body(&self) -> Self::DataToken<'_> {
940 ()
941 }
942 #[inline]
943 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
944 (
945 Self::SIGNATURE_HASH.into(),
946 self.role.clone(),
947 self.account.clone(),
948 self.sender.clone(),
949 )
950 }
951 #[inline]
952 fn encode_topics_raw(
953 &self,
954 out: &mut [alloy_sol_types::abi::token::WordToken],
955 ) -> alloy_sol_types::Result<()> {
956 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
957 return Err(alloy_sol_types::Error::Overrun);
958 }
959 out[0usize] = alloy_sol_types::abi::token::WordToken(
960 Self::SIGNATURE_HASH,
961 );
962 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
963 32,
964 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
965 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
966 &self.account,
967 );
968 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
969 &self.sender,
970 );
971 Ok(())
972 }
973 }
974 #[automatically_derived]
975 impl alloy_sol_types::private::IntoLogData for RoleGranted {
976 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
977 From::from(self)
978 }
979 fn into_log_data(self) -> alloy_sol_types::private::LogData {
980 From::from(&self)
981 }
982 }
983 #[automatically_derived]
984 impl From<&RoleGranted> for alloy_sol_types::private::LogData {
985 #[inline]
986 fn from(this: &RoleGranted) -> alloy_sol_types::private::LogData {
987 alloy_sol_types::SolEvent::encode_log_data(this)
988 }
989 }
990 };
991 #[derive(serde::Serialize, serde::Deserialize)]
992 #[derive(Default, Debug, PartialEq, Eq, Hash)]
993 #[allow(
998 non_camel_case_types,
999 non_snake_case,
1000 clippy::pub_underscore_fields,
1001 clippy::style
1002 )]
1003 #[derive(Clone)]
1004 pub struct RoleRevoked {
1005 #[allow(missing_docs)]
1006 pub role: alloy::sol_types::private::FixedBytes<32>,
1007 #[allow(missing_docs)]
1008 pub account: alloy::sol_types::private::Address,
1009 #[allow(missing_docs)]
1010 pub sender: alloy::sol_types::private::Address,
1011 }
1012 #[allow(
1013 non_camel_case_types,
1014 non_snake_case,
1015 clippy::pub_underscore_fields,
1016 clippy::style
1017 )]
1018 const _: () = {
1019 use alloy::sol_types as alloy_sol_types;
1020 #[automatically_derived]
1021 impl alloy_sol_types::SolEvent for RoleRevoked {
1022 type DataTuple<'a> = ();
1023 type DataToken<'a> = <Self::DataTuple<
1024 'a,
1025 > as alloy_sol_types::SolType>::Token<'a>;
1026 type TopicList = (
1027 alloy_sol_types::sol_data::FixedBytes<32>,
1028 alloy::sol_types::sol_data::FixedBytes<32>,
1029 alloy::sol_types::sol_data::Address,
1030 alloy::sol_types::sol_data::Address,
1031 );
1032 const SIGNATURE: &'static str = "RoleRevoked(bytes32,address,address)";
1033 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1034 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
1035 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
1036 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
1037 ]);
1038 const ANONYMOUS: bool = false;
1039 #[allow(unused_variables)]
1040 #[inline]
1041 fn new(
1042 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1043 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1044 ) -> Self {
1045 Self {
1046 role: topics.1,
1047 account: topics.2,
1048 sender: topics.3,
1049 }
1050 }
1051 #[inline]
1052 fn check_signature(
1053 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1054 ) -> alloy_sol_types::Result<()> {
1055 if topics.0 != Self::SIGNATURE_HASH {
1056 return Err(
1057 alloy_sol_types::Error::invalid_event_signature_hash(
1058 Self::SIGNATURE,
1059 topics.0,
1060 Self::SIGNATURE_HASH,
1061 ),
1062 );
1063 }
1064 Ok(())
1065 }
1066 #[inline]
1067 fn tokenize_body(&self) -> Self::DataToken<'_> {
1068 ()
1069 }
1070 #[inline]
1071 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1072 (
1073 Self::SIGNATURE_HASH.into(),
1074 self.role.clone(),
1075 self.account.clone(),
1076 self.sender.clone(),
1077 )
1078 }
1079 #[inline]
1080 fn encode_topics_raw(
1081 &self,
1082 out: &mut [alloy_sol_types::abi::token::WordToken],
1083 ) -> alloy_sol_types::Result<()> {
1084 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1085 return Err(alloy_sol_types::Error::Overrun);
1086 }
1087 out[0usize] = alloy_sol_types::abi::token::WordToken(
1088 Self::SIGNATURE_HASH,
1089 );
1090 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
1091 32,
1092 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
1093 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1094 &self.account,
1095 );
1096 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1097 &self.sender,
1098 );
1099 Ok(())
1100 }
1101 }
1102 #[automatically_derived]
1103 impl alloy_sol_types::private::IntoLogData for RoleRevoked {
1104 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1105 From::from(self)
1106 }
1107 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1108 From::from(&self)
1109 }
1110 }
1111 #[automatically_derived]
1112 impl From<&RoleRevoked> for alloy_sol_types::private::LogData {
1113 #[inline]
1114 fn from(this: &RoleRevoked) -> alloy_sol_types::private::LogData {
1115 alloy_sol_types::SolEvent::encode_log_data(this)
1116 }
1117 }
1118 };
1119 #[derive(serde::Serialize, serde::Deserialize)]
1120 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1121 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1126 #[derive(Clone)]
1127 pub struct DEFAULT_ADMIN_ROLECall;
1128 #[derive(serde::Serialize, serde::Deserialize)]
1129 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1130 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1132 #[derive(Clone)]
1133 pub struct DEFAULT_ADMIN_ROLEReturn {
1134 #[allow(missing_docs)]
1135 pub _0: alloy::sol_types::private::FixedBytes<32>,
1136 }
1137 #[allow(
1138 non_camel_case_types,
1139 non_snake_case,
1140 clippy::pub_underscore_fields,
1141 clippy::style
1142 )]
1143 const _: () = {
1144 use alloy::sol_types as alloy_sol_types;
1145 {
1146 #[doc(hidden)]
1147 #[allow(dead_code)]
1148 type UnderlyingSolTuple<'a> = ();
1149 #[doc(hidden)]
1150 type UnderlyingRustTuple<'a> = ();
1151 #[cfg(test)]
1152 #[allow(dead_code, unreachable_patterns)]
1153 fn _type_assertion(
1154 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1155 ) {
1156 match _t {
1157 alloy_sol_types::private::AssertTypeEq::<
1158 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1159 >(_) => {}
1160 }
1161 }
1162 #[automatically_derived]
1163 #[doc(hidden)]
1164 impl ::core::convert::From<DEFAULT_ADMIN_ROLECall>
1165 for UnderlyingRustTuple<'_> {
1166 fn from(value: DEFAULT_ADMIN_ROLECall) -> Self {
1167 ()
1168 }
1169 }
1170 #[automatically_derived]
1171 #[doc(hidden)]
1172 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1173 for DEFAULT_ADMIN_ROLECall {
1174 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1175 Self
1176 }
1177 }
1178 }
1179 {
1180 #[doc(hidden)]
1181 #[allow(dead_code)]
1182 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1183 #[doc(hidden)]
1184 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1185 #[cfg(test)]
1186 #[allow(dead_code, unreachable_patterns)]
1187 fn _type_assertion(
1188 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1189 ) {
1190 match _t {
1191 alloy_sol_types::private::AssertTypeEq::<
1192 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1193 >(_) => {}
1194 }
1195 }
1196 #[automatically_derived]
1197 #[doc(hidden)]
1198 impl ::core::convert::From<DEFAULT_ADMIN_ROLEReturn>
1199 for UnderlyingRustTuple<'_> {
1200 fn from(value: DEFAULT_ADMIN_ROLEReturn) -> Self {
1201 (value._0,)
1202 }
1203 }
1204 #[automatically_derived]
1205 #[doc(hidden)]
1206 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1207 for DEFAULT_ADMIN_ROLEReturn {
1208 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1209 Self { _0: tuple.0 }
1210 }
1211 }
1212 }
1213 #[automatically_derived]
1214 impl alloy_sol_types::SolCall for DEFAULT_ADMIN_ROLECall {
1215 type Parameters<'a> = ();
1216 type Token<'a> = <Self::Parameters<
1217 'a,
1218 > as alloy_sol_types::SolType>::Token<'a>;
1219 type Return = alloy::sol_types::private::FixedBytes<32>;
1220 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1221 type ReturnToken<'a> = <Self::ReturnTuple<
1222 'a,
1223 > as alloy_sol_types::SolType>::Token<'a>;
1224 const SIGNATURE: &'static str = "DEFAULT_ADMIN_ROLE()";
1225 const SELECTOR: [u8; 4] = [162u8, 23u8, 253u8, 223u8];
1226 #[inline]
1227 fn new<'a>(
1228 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1229 ) -> Self {
1230 tuple.into()
1231 }
1232 #[inline]
1233 fn tokenize(&self) -> Self::Token<'_> {
1234 ()
1235 }
1236 #[inline]
1237 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1238 (
1239 <alloy::sol_types::sol_data::FixedBytes<
1240 32,
1241 > as alloy_sol_types::SolType>::tokenize(ret),
1242 )
1243 }
1244 #[inline]
1245 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1246 <Self::ReturnTuple<
1247 '_,
1248 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1249 .map(|r| {
1250 let r: DEFAULT_ADMIN_ROLEReturn = r.into();
1251 r._0
1252 })
1253 }
1254 #[inline]
1255 fn abi_decode_returns_validate(
1256 data: &[u8],
1257 ) -> alloy_sol_types::Result<Self::Return> {
1258 <Self::ReturnTuple<
1259 '_,
1260 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1261 .map(|r| {
1262 let r: DEFAULT_ADMIN_ROLEReturn = r.into();
1263 r._0
1264 })
1265 }
1266 }
1267 };
1268 #[derive(serde::Serialize, serde::Deserialize)]
1269 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1270 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1275 #[derive(Clone)]
1276 pub struct getRoleAdminCall {
1277 #[allow(missing_docs)]
1278 pub role: alloy::sol_types::private::FixedBytes<32>,
1279 }
1280 #[derive(serde::Serialize, serde::Deserialize)]
1281 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1282 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1284 #[derive(Clone)]
1285 pub struct getRoleAdminReturn {
1286 #[allow(missing_docs)]
1287 pub _0: alloy::sol_types::private::FixedBytes<32>,
1288 }
1289 #[allow(
1290 non_camel_case_types,
1291 non_snake_case,
1292 clippy::pub_underscore_fields,
1293 clippy::style
1294 )]
1295 const _: () = {
1296 use alloy::sol_types as alloy_sol_types;
1297 {
1298 #[doc(hidden)]
1299 #[allow(dead_code)]
1300 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1301 #[doc(hidden)]
1302 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1303 #[cfg(test)]
1304 #[allow(dead_code, unreachable_patterns)]
1305 fn _type_assertion(
1306 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1307 ) {
1308 match _t {
1309 alloy_sol_types::private::AssertTypeEq::<
1310 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1311 >(_) => {}
1312 }
1313 }
1314 #[automatically_derived]
1315 #[doc(hidden)]
1316 impl ::core::convert::From<getRoleAdminCall> for UnderlyingRustTuple<'_> {
1317 fn from(value: getRoleAdminCall) -> Self {
1318 (value.role,)
1319 }
1320 }
1321 #[automatically_derived]
1322 #[doc(hidden)]
1323 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminCall {
1324 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1325 Self { role: tuple.0 }
1326 }
1327 }
1328 }
1329 {
1330 #[doc(hidden)]
1331 #[allow(dead_code)]
1332 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1333 #[doc(hidden)]
1334 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1335 #[cfg(test)]
1336 #[allow(dead_code, unreachable_patterns)]
1337 fn _type_assertion(
1338 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1339 ) {
1340 match _t {
1341 alloy_sol_types::private::AssertTypeEq::<
1342 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1343 >(_) => {}
1344 }
1345 }
1346 #[automatically_derived]
1347 #[doc(hidden)]
1348 impl ::core::convert::From<getRoleAdminReturn> for UnderlyingRustTuple<'_> {
1349 fn from(value: getRoleAdminReturn) -> Self {
1350 (value._0,)
1351 }
1352 }
1353 #[automatically_derived]
1354 #[doc(hidden)]
1355 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminReturn {
1356 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1357 Self { _0: tuple.0 }
1358 }
1359 }
1360 }
1361 #[automatically_derived]
1362 impl alloy_sol_types::SolCall for getRoleAdminCall {
1363 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1364 type Token<'a> = <Self::Parameters<
1365 'a,
1366 > as alloy_sol_types::SolType>::Token<'a>;
1367 type Return = alloy::sol_types::private::FixedBytes<32>;
1368 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1369 type ReturnToken<'a> = <Self::ReturnTuple<
1370 'a,
1371 > as alloy_sol_types::SolType>::Token<'a>;
1372 const SIGNATURE: &'static str = "getRoleAdmin(bytes32)";
1373 const SELECTOR: [u8; 4] = [36u8, 138u8, 156u8, 163u8];
1374 #[inline]
1375 fn new<'a>(
1376 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1377 ) -> Self {
1378 tuple.into()
1379 }
1380 #[inline]
1381 fn tokenize(&self) -> Self::Token<'_> {
1382 (
1383 <alloy::sol_types::sol_data::FixedBytes<
1384 32,
1385 > as alloy_sol_types::SolType>::tokenize(&self.role),
1386 )
1387 }
1388 #[inline]
1389 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1390 (
1391 <alloy::sol_types::sol_data::FixedBytes<
1392 32,
1393 > as alloy_sol_types::SolType>::tokenize(ret),
1394 )
1395 }
1396 #[inline]
1397 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1398 <Self::ReturnTuple<
1399 '_,
1400 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1401 .map(|r| {
1402 let r: getRoleAdminReturn = r.into();
1403 r._0
1404 })
1405 }
1406 #[inline]
1407 fn abi_decode_returns_validate(
1408 data: &[u8],
1409 ) -> alloy_sol_types::Result<Self::Return> {
1410 <Self::ReturnTuple<
1411 '_,
1412 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1413 .map(|r| {
1414 let r: getRoleAdminReturn = r.into();
1415 r._0
1416 })
1417 }
1418 }
1419 };
1420 #[derive(serde::Serialize, serde::Deserialize)]
1421 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1422 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1427 #[derive(Clone)]
1428 pub struct grantRoleCall {
1429 #[allow(missing_docs)]
1430 pub role: alloy::sol_types::private::FixedBytes<32>,
1431 #[allow(missing_docs)]
1432 pub account: alloy::sol_types::private::Address,
1433 }
1434 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1436 #[derive(Clone)]
1437 pub struct grantRoleReturn {}
1438 #[allow(
1439 non_camel_case_types,
1440 non_snake_case,
1441 clippy::pub_underscore_fields,
1442 clippy::style
1443 )]
1444 const _: () = {
1445 use alloy::sol_types as alloy_sol_types;
1446 {
1447 #[doc(hidden)]
1448 #[allow(dead_code)]
1449 type UnderlyingSolTuple<'a> = (
1450 alloy::sol_types::sol_data::FixedBytes<32>,
1451 alloy::sol_types::sol_data::Address,
1452 );
1453 #[doc(hidden)]
1454 type UnderlyingRustTuple<'a> = (
1455 alloy::sol_types::private::FixedBytes<32>,
1456 alloy::sol_types::private::Address,
1457 );
1458 #[cfg(test)]
1459 #[allow(dead_code, unreachable_patterns)]
1460 fn _type_assertion(
1461 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1462 ) {
1463 match _t {
1464 alloy_sol_types::private::AssertTypeEq::<
1465 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1466 >(_) => {}
1467 }
1468 }
1469 #[automatically_derived]
1470 #[doc(hidden)]
1471 impl ::core::convert::From<grantRoleCall> for UnderlyingRustTuple<'_> {
1472 fn from(value: grantRoleCall) -> Self {
1473 (value.role, value.account)
1474 }
1475 }
1476 #[automatically_derived]
1477 #[doc(hidden)]
1478 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
1479 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1480 Self {
1481 role: tuple.0,
1482 account: tuple.1,
1483 }
1484 }
1485 }
1486 }
1487 {
1488 #[doc(hidden)]
1489 #[allow(dead_code)]
1490 type UnderlyingSolTuple<'a> = ();
1491 #[doc(hidden)]
1492 type UnderlyingRustTuple<'a> = ();
1493 #[cfg(test)]
1494 #[allow(dead_code, unreachable_patterns)]
1495 fn _type_assertion(
1496 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1497 ) {
1498 match _t {
1499 alloy_sol_types::private::AssertTypeEq::<
1500 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1501 >(_) => {}
1502 }
1503 }
1504 #[automatically_derived]
1505 #[doc(hidden)]
1506 impl ::core::convert::From<grantRoleReturn> for UnderlyingRustTuple<'_> {
1507 fn from(value: grantRoleReturn) -> Self {
1508 ()
1509 }
1510 }
1511 #[automatically_derived]
1512 #[doc(hidden)]
1513 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
1514 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1515 Self {}
1516 }
1517 }
1518 }
1519 impl grantRoleReturn {
1520 fn _tokenize(
1521 &self,
1522 ) -> <grantRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1523 ()
1524 }
1525 }
1526 #[automatically_derived]
1527 impl alloy_sol_types::SolCall for grantRoleCall {
1528 type Parameters<'a> = (
1529 alloy::sol_types::sol_data::FixedBytes<32>,
1530 alloy::sol_types::sol_data::Address,
1531 );
1532 type Token<'a> = <Self::Parameters<
1533 'a,
1534 > as alloy_sol_types::SolType>::Token<'a>;
1535 type Return = grantRoleReturn;
1536 type ReturnTuple<'a> = ();
1537 type ReturnToken<'a> = <Self::ReturnTuple<
1538 'a,
1539 > as alloy_sol_types::SolType>::Token<'a>;
1540 const SIGNATURE: &'static str = "grantRole(bytes32,address)";
1541 const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
1542 #[inline]
1543 fn new<'a>(
1544 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1545 ) -> Self {
1546 tuple.into()
1547 }
1548 #[inline]
1549 fn tokenize(&self) -> Self::Token<'_> {
1550 (
1551 <alloy::sol_types::sol_data::FixedBytes<
1552 32,
1553 > as alloy_sol_types::SolType>::tokenize(&self.role),
1554 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1555 &self.account,
1556 ),
1557 )
1558 }
1559 #[inline]
1560 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1561 grantRoleReturn::_tokenize(ret)
1562 }
1563 #[inline]
1564 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1565 <Self::ReturnTuple<
1566 '_,
1567 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1568 .map(Into::into)
1569 }
1570 #[inline]
1571 fn abi_decode_returns_validate(
1572 data: &[u8],
1573 ) -> alloy_sol_types::Result<Self::Return> {
1574 <Self::ReturnTuple<
1575 '_,
1576 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1577 .map(Into::into)
1578 }
1579 }
1580 };
1581 #[derive(serde::Serialize, serde::Deserialize)]
1582 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1583 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1588 #[derive(Clone)]
1589 pub struct hasRoleCall {
1590 #[allow(missing_docs)]
1591 pub role: alloy::sol_types::private::FixedBytes<32>,
1592 #[allow(missing_docs)]
1593 pub account: alloy::sol_types::private::Address,
1594 }
1595 #[derive(serde::Serialize, serde::Deserialize)]
1596 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1597 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1599 #[derive(Clone)]
1600 pub struct hasRoleReturn {
1601 #[allow(missing_docs)]
1602 pub _0: bool,
1603 }
1604 #[allow(
1605 non_camel_case_types,
1606 non_snake_case,
1607 clippy::pub_underscore_fields,
1608 clippy::style
1609 )]
1610 const _: () = {
1611 use alloy::sol_types as alloy_sol_types;
1612 {
1613 #[doc(hidden)]
1614 #[allow(dead_code)]
1615 type UnderlyingSolTuple<'a> = (
1616 alloy::sol_types::sol_data::FixedBytes<32>,
1617 alloy::sol_types::sol_data::Address,
1618 );
1619 #[doc(hidden)]
1620 type UnderlyingRustTuple<'a> = (
1621 alloy::sol_types::private::FixedBytes<32>,
1622 alloy::sol_types::private::Address,
1623 );
1624 #[cfg(test)]
1625 #[allow(dead_code, unreachable_patterns)]
1626 fn _type_assertion(
1627 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1628 ) {
1629 match _t {
1630 alloy_sol_types::private::AssertTypeEq::<
1631 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1632 >(_) => {}
1633 }
1634 }
1635 #[automatically_derived]
1636 #[doc(hidden)]
1637 impl ::core::convert::From<hasRoleCall> for UnderlyingRustTuple<'_> {
1638 fn from(value: hasRoleCall) -> Self {
1639 (value.role, value.account)
1640 }
1641 }
1642 #[automatically_derived]
1643 #[doc(hidden)]
1644 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleCall {
1645 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1646 Self {
1647 role: tuple.0,
1648 account: tuple.1,
1649 }
1650 }
1651 }
1652 }
1653 {
1654 #[doc(hidden)]
1655 #[allow(dead_code)]
1656 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1657 #[doc(hidden)]
1658 type UnderlyingRustTuple<'a> = (bool,);
1659 #[cfg(test)]
1660 #[allow(dead_code, unreachable_patterns)]
1661 fn _type_assertion(
1662 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1663 ) {
1664 match _t {
1665 alloy_sol_types::private::AssertTypeEq::<
1666 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1667 >(_) => {}
1668 }
1669 }
1670 #[automatically_derived]
1671 #[doc(hidden)]
1672 impl ::core::convert::From<hasRoleReturn> for UnderlyingRustTuple<'_> {
1673 fn from(value: hasRoleReturn) -> Self {
1674 (value._0,)
1675 }
1676 }
1677 #[automatically_derived]
1678 #[doc(hidden)]
1679 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleReturn {
1680 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1681 Self { _0: tuple.0 }
1682 }
1683 }
1684 }
1685 #[automatically_derived]
1686 impl alloy_sol_types::SolCall for hasRoleCall {
1687 type Parameters<'a> = (
1688 alloy::sol_types::sol_data::FixedBytes<32>,
1689 alloy::sol_types::sol_data::Address,
1690 );
1691 type Token<'a> = <Self::Parameters<
1692 'a,
1693 > as alloy_sol_types::SolType>::Token<'a>;
1694 type Return = bool;
1695 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1696 type ReturnToken<'a> = <Self::ReturnTuple<
1697 'a,
1698 > as alloy_sol_types::SolType>::Token<'a>;
1699 const SIGNATURE: &'static str = "hasRole(bytes32,address)";
1700 const SELECTOR: [u8; 4] = [145u8, 209u8, 72u8, 84u8];
1701 #[inline]
1702 fn new<'a>(
1703 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1704 ) -> Self {
1705 tuple.into()
1706 }
1707 #[inline]
1708 fn tokenize(&self) -> Self::Token<'_> {
1709 (
1710 <alloy::sol_types::sol_data::FixedBytes<
1711 32,
1712 > as alloy_sol_types::SolType>::tokenize(&self.role),
1713 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1714 &self.account,
1715 ),
1716 )
1717 }
1718 #[inline]
1719 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1720 (
1721 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
1722 ret,
1723 ),
1724 )
1725 }
1726 #[inline]
1727 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1728 <Self::ReturnTuple<
1729 '_,
1730 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1731 .map(|r| {
1732 let r: hasRoleReturn = r.into();
1733 r._0
1734 })
1735 }
1736 #[inline]
1737 fn abi_decode_returns_validate(
1738 data: &[u8],
1739 ) -> alloy_sol_types::Result<Self::Return> {
1740 <Self::ReturnTuple<
1741 '_,
1742 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1743 .map(|r| {
1744 let r: hasRoleReturn = r.into();
1745 r._0
1746 })
1747 }
1748 }
1749 };
1750 #[derive(serde::Serialize, serde::Deserialize)]
1751 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1752 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1757 #[derive(Clone)]
1758 pub struct renounceRoleCall {
1759 #[allow(missing_docs)]
1760 pub role: alloy::sol_types::private::FixedBytes<32>,
1761 #[allow(missing_docs)]
1762 pub callerConfirmation: alloy::sol_types::private::Address,
1763 }
1764 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1766 #[derive(Clone)]
1767 pub struct renounceRoleReturn {}
1768 #[allow(
1769 non_camel_case_types,
1770 non_snake_case,
1771 clippy::pub_underscore_fields,
1772 clippy::style
1773 )]
1774 const _: () = {
1775 use alloy::sol_types as alloy_sol_types;
1776 {
1777 #[doc(hidden)]
1778 #[allow(dead_code)]
1779 type UnderlyingSolTuple<'a> = (
1780 alloy::sol_types::sol_data::FixedBytes<32>,
1781 alloy::sol_types::sol_data::Address,
1782 );
1783 #[doc(hidden)]
1784 type UnderlyingRustTuple<'a> = (
1785 alloy::sol_types::private::FixedBytes<32>,
1786 alloy::sol_types::private::Address,
1787 );
1788 #[cfg(test)]
1789 #[allow(dead_code, unreachable_patterns)]
1790 fn _type_assertion(
1791 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1792 ) {
1793 match _t {
1794 alloy_sol_types::private::AssertTypeEq::<
1795 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1796 >(_) => {}
1797 }
1798 }
1799 #[automatically_derived]
1800 #[doc(hidden)]
1801 impl ::core::convert::From<renounceRoleCall> for UnderlyingRustTuple<'_> {
1802 fn from(value: renounceRoleCall) -> Self {
1803 (value.role, value.callerConfirmation)
1804 }
1805 }
1806 #[automatically_derived]
1807 #[doc(hidden)]
1808 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleCall {
1809 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1810 Self {
1811 role: tuple.0,
1812 callerConfirmation: tuple.1,
1813 }
1814 }
1815 }
1816 }
1817 {
1818 #[doc(hidden)]
1819 #[allow(dead_code)]
1820 type UnderlyingSolTuple<'a> = ();
1821 #[doc(hidden)]
1822 type UnderlyingRustTuple<'a> = ();
1823 #[cfg(test)]
1824 #[allow(dead_code, unreachable_patterns)]
1825 fn _type_assertion(
1826 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1827 ) {
1828 match _t {
1829 alloy_sol_types::private::AssertTypeEq::<
1830 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1831 >(_) => {}
1832 }
1833 }
1834 #[automatically_derived]
1835 #[doc(hidden)]
1836 impl ::core::convert::From<renounceRoleReturn> for UnderlyingRustTuple<'_> {
1837 fn from(value: renounceRoleReturn) -> Self {
1838 ()
1839 }
1840 }
1841 #[automatically_derived]
1842 #[doc(hidden)]
1843 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleReturn {
1844 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1845 Self {}
1846 }
1847 }
1848 }
1849 impl renounceRoleReturn {
1850 fn _tokenize(
1851 &self,
1852 ) -> <renounceRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1853 ()
1854 }
1855 }
1856 #[automatically_derived]
1857 impl alloy_sol_types::SolCall for renounceRoleCall {
1858 type Parameters<'a> = (
1859 alloy::sol_types::sol_data::FixedBytes<32>,
1860 alloy::sol_types::sol_data::Address,
1861 );
1862 type Token<'a> = <Self::Parameters<
1863 'a,
1864 > as alloy_sol_types::SolType>::Token<'a>;
1865 type Return = renounceRoleReturn;
1866 type ReturnTuple<'a> = ();
1867 type ReturnToken<'a> = <Self::ReturnTuple<
1868 'a,
1869 > as alloy_sol_types::SolType>::Token<'a>;
1870 const SIGNATURE: &'static str = "renounceRole(bytes32,address)";
1871 const SELECTOR: [u8; 4] = [54u8, 86u8, 138u8, 190u8];
1872 #[inline]
1873 fn new<'a>(
1874 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1875 ) -> Self {
1876 tuple.into()
1877 }
1878 #[inline]
1879 fn tokenize(&self) -> Self::Token<'_> {
1880 (
1881 <alloy::sol_types::sol_data::FixedBytes<
1882 32,
1883 > as alloy_sol_types::SolType>::tokenize(&self.role),
1884 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1885 &self.callerConfirmation,
1886 ),
1887 )
1888 }
1889 #[inline]
1890 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1891 renounceRoleReturn::_tokenize(ret)
1892 }
1893 #[inline]
1894 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1895 <Self::ReturnTuple<
1896 '_,
1897 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1898 .map(Into::into)
1899 }
1900 #[inline]
1901 fn abi_decode_returns_validate(
1902 data: &[u8],
1903 ) -> alloy_sol_types::Result<Self::Return> {
1904 <Self::ReturnTuple<
1905 '_,
1906 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1907 .map(Into::into)
1908 }
1909 }
1910 };
1911 #[derive(serde::Serialize, serde::Deserialize)]
1912 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1913 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1918 #[derive(Clone)]
1919 pub struct revokeRoleCall {
1920 #[allow(missing_docs)]
1921 pub role: alloy::sol_types::private::FixedBytes<32>,
1922 #[allow(missing_docs)]
1923 pub account: alloy::sol_types::private::Address,
1924 }
1925 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1927 #[derive(Clone)]
1928 pub struct revokeRoleReturn {}
1929 #[allow(
1930 non_camel_case_types,
1931 non_snake_case,
1932 clippy::pub_underscore_fields,
1933 clippy::style
1934 )]
1935 const _: () = {
1936 use alloy::sol_types as alloy_sol_types;
1937 {
1938 #[doc(hidden)]
1939 #[allow(dead_code)]
1940 type UnderlyingSolTuple<'a> = (
1941 alloy::sol_types::sol_data::FixedBytes<32>,
1942 alloy::sol_types::sol_data::Address,
1943 );
1944 #[doc(hidden)]
1945 type UnderlyingRustTuple<'a> = (
1946 alloy::sol_types::private::FixedBytes<32>,
1947 alloy::sol_types::private::Address,
1948 );
1949 #[cfg(test)]
1950 #[allow(dead_code, unreachable_patterns)]
1951 fn _type_assertion(
1952 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1953 ) {
1954 match _t {
1955 alloy_sol_types::private::AssertTypeEq::<
1956 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1957 >(_) => {}
1958 }
1959 }
1960 #[automatically_derived]
1961 #[doc(hidden)]
1962 impl ::core::convert::From<revokeRoleCall> for UnderlyingRustTuple<'_> {
1963 fn from(value: revokeRoleCall) -> Self {
1964 (value.role, value.account)
1965 }
1966 }
1967 #[automatically_derived]
1968 #[doc(hidden)]
1969 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleCall {
1970 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1971 Self {
1972 role: tuple.0,
1973 account: tuple.1,
1974 }
1975 }
1976 }
1977 }
1978 {
1979 #[doc(hidden)]
1980 #[allow(dead_code)]
1981 type UnderlyingSolTuple<'a> = ();
1982 #[doc(hidden)]
1983 type UnderlyingRustTuple<'a> = ();
1984 #[cfg(test)]
1985 #[allow(dead_code, unreachable_patterns)]
1986 fn _type_assertion(
1987 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1988 ) {
1989 match _t {
1990 alloy_sol_types::private::AssertTypeEq::<
1991 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1992 >(_) => {}
1993 }
1994 }
1995 #[automatically_derived]
1996 #[doc(hidden)]
1997 impl ::core::convert::From<revokeRoleReturn> for UnderlyingRustTuple<'_> {
1998 fn from(value: revokeRoleReturn) -> Self {
1999 ()
2000 }
2001 }
2002 #[automatically_derived]
2003 #[doc(hidden)]
2004 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleReturn {
2005 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2006 Self {}
2007 }
2008 }
2009 }
2010 impl revokeRoleReturn {
2011 fn _tokenize(
2012 &self,
2013 ) -> <revokeRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2014 ()
2015 }
2016 }
2017 #[automatically_derived]
2018 impl alloy_sol_types::SolCall for revokeRoleCall {
2019 type Parameters<'a> = (
2020 alloy::sol_types::sol_data::FixedBytes<32>,
2021 alloy::sol_types::sol_data::Address,
2022 );
2023 type Token<'a> = <Self::Parameters<
2024 'a,
2025 > as alloy_sol_types::SolType>::Token<'a>;
2026 type Return = revokeRoleReturn;
2027 type ReturnTuple<'a> = ();
2028 type ReturnToken<'a> = <Self::ReturnTuple<
2029 'a,
2030 > as alloy_sol_types::SolType>::Token<'a>;
2031 const SIGNATURE: &'static str = "revokeRole(bytes32,address)";
2032 const SELECTOR: [u8; 4] = [213u8, 71u8, 116u8, 31u8];
2033 #[inline]
2034 fn new<'a>(
2035 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2036 ) -> Self {
2037 tuple.into()
2038 }
2039 #[inline]
2040 fn tokenize(&self) -> Self::Token<'_> {
2041 (
2042 <alloy::sol_types::sol_data::FixedBytes<
2043 32,
2044 > as alloy_sol_types::SolType>::tokenize(&self.role),
2045 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2046 &self.account,
2047 ),
2048 )
2049 }
2050 #[inline]
2051 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2052 revokeRoleReturn::_tokenize(ret)
2053 }
2054 #[inline]
2055 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2056 <Self::ReturnTuple<
2057 '_,
2058 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2059 .map(Into::into)
2060 }
2061 #[inline]
2062 fn abi_decode_returns_validate(
2063 data: &[u8],
2064 ) -> alloy_sol_types::Result<Self::Return> {
2065 <Self::ReturnTuple<
2066 '_,
2067 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2068 .map(Into::into)
2069 }
2070 }
2071 };
2072 #[derive(serde::Serialize, serde::Deserialize)]
2073 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2074 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2079 #[derive(Clone)]
2080 pub struct supportsInterfaceCall {
2081 #[allow(missing_docs)]
2082 pub interfaceId: alloy::sol_types::private::FixedBytes<4>,
2083 }
2084 #[derive(serde::Serialize, serde::Deserialize)]
2085 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2086 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2088 #[derive(Clone)]
2089 pub struct supportsInterfaceReturn {
2090 #[allow(missing_docs)]
2091 pub _0: bool,
2092 }
2093 #[allow(
2094 non_camel_case_types,
2095 non_snake_case,
2096 clippy::pub_underscore_fields,
2097 clippy::style
2098 )]
2099 const _: () = {
2100 use alloy::sol_types as alloy_sol_types;
2101 {
2102 #[doc(hidden)]
2103 #[allow(dead_code)]
2104 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
2105 #[doc(hidden)]
2106 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
2107 #[cfg(test)]
2108 #[allow(dead_code, unreachable_patterns)]
2109 fn _type_assertion(
2110 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2111 ) {
2112 match _t {
2113 alloy_sol_types::private::AssertTypeEq::<
2114 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2115 >(_) => {}
2116 }
2117 }
2118 #[automatically_derived]
2119 #[doc(hidden)]
2120 impl ::core::convert::From<supportsInterfaceCall>
2121 for UnderlyingRustTuple<'_> {
2122 fn from(value: supportsInterfaceCall) -> Self {
2123 (value.interfaceId,)
2124 }
2125 }
2126 #[automatically_derived]
2127 #[doc(hidden)]
2128 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2129 for supportsInterfaceCall {
2130 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2131 Self { interfaceId: tuple.0 }
2132 }
2133 }
2134 }
2135 {
2136 #[doc(hidden)]
2137 #[allow(dead_code)]
2138 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2139 #[doc(hidden)]
2140 type UnderlyingRustTuple<'a> = (bool,);
2141 #[cfg(test)]
2142 #[allow(dead_code, unreachable_patterns)]
2143 fn _type_assertion(
2144 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2145 ) {
2146 match _t {
2147 alloy_sol_types::private::AssertTypeEq::<
2148 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2149 >(_) => {}
2150 }
2151 }
2152 #[automatically_derived]
2153 #[doc(hidden)]
2154 impl ::core::convert::From<supportsInterfaceReturn>
2155 for UnderlyingRustTuple<'_> {
2156 fn from(value: supportsInterfaceReturn) -> Self {
2157 (value._0,)
2158 }
2159 }
2160 #[automatically_derived]
2161 #[doc(hidden)]
2162 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2163 for supportsInterfaceReturn {
2164 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2165 Self { _0: tuple.0 }
2166 }
2167 }
2168 }
2169 #[automatically_derived]
2170 impl alloy_sol_types::SolCall for supportsInterfaceCall {
2171 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
2172 type Token<'a> = <Self::Parameters<
2173 'a,
2174 > as alloy_sol_types::SolType>::Token<'a>;
2175 type Return = bool;
2176 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2177 type ReturnToken<'a> = <Self::ReturnTuple<
2178 'a,
2179 > as alloy_sol_types::SolType>::Token<'a>;
2180 const SIGNATURE: &'static str = "supportsInterface(bytes4)";
2181 const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
2182 #[inline]
2183 fn new<'a>(
2184 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2185 ) -> Self {
2186 tuple.into()
2187 }
2188 #[inline]
2189 fn tokenize(&self) -> Self::Token<'_> {
2190 (
2191 <alloy::sol_types::sol_data::FixedBytes<
2192 4,
2193 > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
2194 )
2195 }
2196 #[inline]
2197 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2198 (
2199 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
2200 ret,
2201 ),
2202 )
2203 }
2204 #[inline]
2205 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2206 <Self::ReturnTuple<
2207 '_,
2208 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2209 .map(|r| {
2210 let r: supportsInterfaceReturn = r.into();
2211 r._0
2212 })
2213 }
2214 #[inline]
2215 fn abi_decode_returns_validate(
2216 data: &[u8],
2217 ) -> alloy_sol_types::Result<Self::Return> {
2218 <Self::ReturnTuple<
2219 '_,
2220 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2221 .map(|r| {
2222 let r: supportsInterfaceReturn = r.into();
2223 r._0
2224 })
2225 }
2226 }
2227 };
2228 #[derive(Clone)]
2230 #[derive(serde::Serialize, serde::Deserialize)]
2231 #[derive()]
2232 pub enum AccessControlUpgradeableCalls {
2233 #[allow(missing_docs)]
2234 DEFAULT_ADMIN_ROLE(DEFAULT_ADMIN_ROLECall),
2235 #[allow(missing_docs)]
2236 getRoleAdmin(getRoleAdminCall),
2237 #[allow(missing_docs)]
2238 grantRole(grantRoleCall),
2239 #[allow(missing_docs)]
2240 hasRole(hasRoleCall),
2241 #[allow(missing_docs)]
2242 renounceRole(renounceRoleCall),
2243 #[allow(missing_docs)]
2244 revokeRole(revokeRoleCall),
2245 #[allow(missing_docs)]
2246 supportsInterface(supportsInterfaceCall),
2247 }
2248 impl AccessControlUpgradeableCalls {
2249 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2256 [1u8, 255u8, 201u8, 167u8],
2257 [36u8, 138u8, 156u8, 163u8],
2258 [47u8, 47u8, 241u8, 93u8],
2259 [54u8, 86u8, 138u8, 190u8],
2260 [145u8, 209u8, 72u8, 84u8],
2261 [162u8, 23u8, 253u8, 223u8],
2262 [213u8, 71u8, 116u8, 31u8],
2263 ];
2264 pub const VARIANT_NAMES: &'static [&'static str] = &[
2266 ::core::stringify!(supportsInterface),
2267 ::core::stringify!(getRoleAdmin),
2268 ::core::stringify!(grantRole),
2269 ::core::stringify!(renounceRole),
2270 ::core::stringify!(hasRole),
2271 ::core::stringify!(DEFAULT_ADMIN_ROLE),
2272 ::core::stringify!(revokeRole),
2273 ];
2274 pub const SIGNATURES: &'static [&'static str] = &[
2276 <supportsInterfaceCall as alloy_sol_types::SolCall>::SIGNATURE,
2277 <getRoleAdminCall as alloy_sol_types::SolCall>::SIGNATURE,
2278 <grantRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
2279 <renounceRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
2280 <hasRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
2281 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SIGNATURE,
2282 <revokeRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
2283 ];
2284 #[inline]
2286 pub fn signature_by_selector(
2287 selector: [u8; 4usize],
2288 ) -> ::core::option::Option<&'static str> {
2289 match Self::SELECTORS.binary_search(&selector) {
2290 ::core::result::Result::Ok(idx) => {
2291 ::core::option::Option::Some(Self::SIGNATURES[idx])
2292 }
2293 ::core::result::Result::Err(_) => ::core::option::Option::None,
2294 }
2295 }
2296 #[inline]
2298 pub fn name_by_selector(
2299 selector: [u8; 4usize],
2300 ) -> ::core::option::Option<&'static str> {
2301 let sig = Self::signature_by_selector(selector)?;
2302 sig.split_once('(').map(|(name, _)| name)
2303 }
2304 }
2305 #[automatically_derived]
2306 impl alloy_sol_types::SolInterface for AccessControlUpgradeableCalls {
2307 const NAME: &'static str = "AccessControlUpgradeableCalls";
2308 const MIN_DATA_LENGTH: usize = 0usize;
2309 const COUNT: usize = 7usize;
2310 #[inline]
2311 fn selector(&self) -> [u8; 4] {
2312 match self {
2313 Self::DEFAULT_ADMIN_ROLE(_) => {
2314 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SELECTOR
2315 }
2316 Self::getRoleAdmin(_) => {
2317 <getRoleAdminCall as alloy_sol_types::SolCall>::SELECTOR
2318 }
2319 Self::grantRole(_) => {
2320 <grantRoleCall as alloy_sol_types::SolCall>::SELECTOR
2321 }
2322 Self::hasRole(_) => <hasRoleCall as alloy_sol_types::SolCall>::SELECTOR,
2323 Self::renounceRole(_) => {
2324 <renounceRoleCall as alloy_sol_types::SolCall>::SELECTOR
2325 }
2326 Self::revokeRole(_) => {
2327 <revokeRoleCall as alloy_sol_types::SolCall>::SELECTOR
2328 }
2329 Self::supportsInterface(_) => {
2330 <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
2331 }
2332 }
2333 }
2334 #[inline]
2335 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2336 Self::SELECTORS.get(i).copied()
2337 }
2338 #[inline]
2339 fn valid_selector(selector: [u8; 4]) -> bool {
2340 Self::SELECTORS.binary_search(&selector).is_ok()
2341 }
2342 #[inline]
2343 #[allow(non_snake_case)]
2344 fn abi_decode_raw(
2345 selector: [u8; 4],
2346 data: &[u8],
2347 ) -> alloy_sol_types::Result<Self> {
2348 static DECODE_SHIMS: &[fn(
2349 &[u8],
2350 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls>] = &[
2351 {
2352 fn supportsInterface(
2353 data: &[u8],
2354 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2355 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(
2356 data,
2357 )
2358 .map(AccessControlUpgradeableCalls::supportsInterface)
2359 }
2360 supportsInterface
2361 },
2362 {
2363 fn getRoleAdmin(
2364 data: &[u8],
2365 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2366 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
2367 data,
2368 )
2369 .map(AccessControlUpgradeableCalls::getRoleAdmin)
2370 }
2371 getRoleAdmin
2372 },
2373 {
2374 fn grantRole(
2375 data: &[u8],
2376 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2377 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2378 .map(AccessControlUpgradeableCalls::grantRole)
2379 }
2380 grantRole
2381 },
2382 {
2383 fn renounceRole(
2384 data: &[u8],
2385 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2386 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
2387 data,
2388 )
2389 .map(AccessControlUpgradeableCalls::renounceRole)
2390 }
2391 renounceRole
2392 },
2393 {
2394 fn hasRole(
2395 data: &[u8],
2396 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2397 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2398 .map(AccessControlUpgradeableCalls::hasRole)
2399 }
2400 hasRole
2401 },
2402 {
2403 fn DEFAULT_ADMIN_ROLE(
2404 data: &[u8],
2405 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2406 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
2407 data,
2408 )
2409 .map(AccessControlUpgradeableCalls::DEFAULT_ADMIN_ROLE)
2410 }
2411 DEFAULT_ADMIN_ROLE
2412 },
2413 {
2414 fn revokeRole(
2415 data: &[u8],
2416 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2417 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
2418 data,
2419 )
2420 .map(AccessControlUpgradeableCalls::revokeRole)
2421 }
2422 revokeRole
2423 },
2424 ];
2425 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2426 return Err(
2427 alloy_sol_types::Error::unknown_selector(
2428 <Self as alloy_sol_types::SolInterface>::NAME,
2429 selector,
2430 ),
2431 );
2432 };
2433 DECODE_SHIMS[idx](data)
2434 }
2435 #[inline]
2436 #[allow(non_snake_case)]
2437 fn abi_decode_raw_validate(
2438 selector: [u8; 4],
2439 data: &[u8],
2440 ) -> alloy_sol_types::Result<Self> {
2441 static DECODE_VALIDATE_SHIMS: &[fn(
2442 &[u8],
2443 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls>] = &[
2444 {
2445 fn supportsInterface(
2446 data: &[u8],
2447 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2448 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2449 data,
2450 )
2451 .map(AccessControlUpgradeableCalls::supportsInterface)
2452 }
2453 supportsInterface
2454 },
2455 {
2456 fn getRoleAdmin(
2457 data: &[u8],
2458 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2459 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2460 data,
2461 )
2462 .map(AccessControlUpgradeableCalls::getRoleAdmin)
2463 }
2464 getRoleAdmin
2465 },
2466 {
2467 fn grantRole(
2468 data: &[u8],
2469 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2470 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2471 data,
2472 )
2473 .map(AccessControlUpgradeableCalls::grantRole)
2474 }
2475 grantRole
2476 },
2477 {
2478 fn renounceRole(
2479 data: &[u8],
2480 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2481 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2482 data,
2483 )
2484 .map(AccessControlUpgradeableCalls::renounceRole)
2485 }
2486 renounceRole
2487 },
2488 {
2489 fn hasRole(
2490 data: &[u8],
2491 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2492 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2493 data,
2494 )
2495 .map(AccessControlUpgradeableCalls::hasRole)
2496 }
2497 hasRole
2498 },
2499 {
2500 fn DEFAULT_ADMIN_ROLE(
2501 data: &[u8],
2502 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2503 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2504 data,
2505 )
2506 .map(AccessControlUpgradeableCalls::DEFAULT_ADMIN_ROLE)
2507 }
2508 DEFAULT_ADMIN_ROLE
2509 },
2510 {
2511 fn revokeRole(
2512 data: &[u8],
2513 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2514 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2515 data,
2516 )
2517 .map(AccessControlUpgradeableCalls::revokeRole)
2518 }
2519 revokeRole
2520 },
2521 ];
2522 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2523 return Err(
2524 alloy_sol_types::Error::unknown_selector(
2525 <Self as alloy_sol_types::SolInterface>::NAME,
2526 selector,
2527 ),
2528 );
2529 };
2530 DECODE_VALIDATE_SHIMS[idx](data)
2531 }
2532 #[inline]
2533 fn abi_encoded_size(&self) -> usize {
2534 match self {
2535 Self::DEFAULT_ADMIN_ROLE(inner) => {
2536 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
2537 inner,
2538 )
2539 }
2540 Self::getRoleAdmin(inner) => {
2541 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
2542 inner,
2543 )
2544 }
2545 Self::grantRole(inner) => {
2546 <grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2547 }
2548 Self::hasRole(inner) => {
2549 <hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2550 }
2551 Self::renounceRole(inner) => {
2552 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(
2553 inner,
2554 )
2555 }
2556 Self::revokeRole(inner) => {
2557 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2558 }
2559 Self::supportsInterface(inner) => {
2560 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
2561 inner,
2562 )
2563 }
2564 }
2565 }
2566 #[inline]
2567 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2568 match self {
2569 Self::DEFAULT_ADMIN_ROLE(inner) => {
2570 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
2571 inner,
2572 out,
2573 )
2574 }
2575 Self::getRoleAdmin(inner) => {
2576 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
2577 inner,
2578 out,
2579 )
2580 }
2581 Self::grantRole(inner) => {
2582 <grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
2583 inner,
2584 out,
2585 )
2586 }
2587 Self::hasRole(inner) => {
2588 <hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2589 }
2590 Self::renounceRole(inner) => {
2591 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
2592 inner,
2593 out,
2594 )
2595 }
2596 Self::revokeRole(inner) => {
2597 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
2598 inner,
2599 out,
2600 )
2601 }
2602 Self::supportsInterface(inner) => {
2603 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
2604 inner,
2605 out,
2606 )
2607 }
2608 }
2609 }
2610 }
2611 #[derive(Clone)]
2613 #[derive(serde::Serialize, serde::Deserialize)]
2614 #[derive(Debug, PartialEq, Eq, Hash)]
2615 pub enum AccessControlUpgradeableErrors {
2616 #[allow(missing_docs)]
2617 AccessControlBadConfirmation(AccessControlBadConfirmation),
2618 #[allow(missing_docs)]
2619 AccessControlUnauthorizedAccount(AccessControlUnauthorizedAccount),
2620 #[allow(missing_docs)]
2621 InvalidInitialization(InvalidInitialization),
2622 #[allow(missing_docs)]
2623 NotInitializing(NotInitializing),
2624 }
2625 impl AccessControlUpgradeableErrors {
2626 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2633 [102u8, 151u8, 178u8, 50u8],
2634 [215u8, 230u8, 188u8, 248u8],
2635 [226u8, 81u8, 125u8, 63u8],
2636 [249u8, 46u8, 232u8, 169u8],
2637 ];
2638 pub const VARIANT_NAMES: &'static [&'static str] = &[
2640 ::core::stringify!(AccessControlBadConfirmation),
2641 ::core::stringify!(NotInitializing),
2642 ::core::stringify!(AccessControlUnauthorizedAccount),
2643 ::core::stringify!(InvalidInitialization),
2644 ];
2645 pub const SIGNATURES: &'static [&'static str] = &[
2647 <AccessControlBadConfirmation as alloy_sol_types::SolError>::SIGNATURE,
2648 <NotInitializing as alloy_sol_types::SolError>::SIGNATURE,
2649 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::SIGNATURE,
2650 <InvalidInitialization as alloy_sol_types::SolError>::SIGNATURE,
2651 ];
2652 #[inline]
2654 pub fn signature_by_selector(
2655 selector: [u8; 4usize],
2656 ) -> ::core::option::Option<&'static str> {
2657 match Self::SELECTORS.binary_search(&selector) {
2658 ::core::result::Result::Ok(idx) => {
2659 ::core::option::Option::Some(Self::SIGNATURES[idx])
2660 }
2661 ::core::result::Result::Err(_) => ::core::option::Option::None,
2662 }
2663 }
2664 #[inline]
2666 pub fn name_by_selector(
2667 selector: [u8; 4usize],
2668 ) -> ::core::option::Option<&'static str> {
2669 let sig = Self::signature_by_selector(selector)?;
2670 sig.split_once('(').map(|(name, _)| name)
2671 }
2672 }
2673 #[automatically_derived]
2674 impl alloy_sol_types::SolInterface for AccessControlUpgradeableErrors {
2675 const NAME: &'static str = "AccessControlUpgradeableErrors";
2676 const MIN_DATA_LENGTH: usize = 0usize;
2677 const COUNT: usize = 4usize;
2678 #[inline]
2679 fn selector(&self) -> [u8; 4] {
2680 match self {
2681 Self::AccessControlBadConfirmation(_) => {
2682 <AccessControlBadConfirmation as alloy_sol_types::SolError>::SELECTOR
2683 }
2684 Self::AccessControlUnauthorizedAccount(_) => {
2685 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
2686 }
2687 Self::InvalidInitialization(_) => {
2688 <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
2689 }
2690 Self::NotInitializing(_) => {
2691 <NotInitializing as alloy_sol_types::SolError>::SELECTOR
2692 }
2693 }
2694 }
2695 #[inline]
2696 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2697 Self::SELECTORS.get(i).copied()
2698 }
2699 #[inline]
2700 fn valid_selector(selector: [u8; 4]) -> bool {
2701 Self::SELECTORS.binary_search(&selector).is_ok()
2702 }
2703 #[inline]
2704 #[allow(non_snake_case)]
2705 fn abi_decode_raw(
2706 selector: [u8; 4],
2707 data: &[u8],
2708 ) -> alloy_sol_types::Result<Self> {
2709 static DECODE_SHIMS: &[fn(
2710 &[u8],
2711 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors>] = &[
2712 {
2713 fn AccessControlBadConfirmation(
2714 data: &[u8],
2715 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2716 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_decode_raw(
2717 data,
2718 )
2719 .map(
2720 AccessControlUpgradeableErrors::AccessControlBadConfirmation,
2721 )
2722 }
2723 AccessControlBadConfirmation
2724 },
2725 {
2726 fn NotInitializing(
2727 data: &[u8],
2728 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2729 <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw(
2730 data,
2731 )
2732 .map(AccessControlUpgradeableErrors::NotInitializing)
2733 }
2734 NotInitializing
2735 },
2736 {
2737 fn AccessControlUnauthorizedAccount(
2738 data: &[u8],
2739 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2740 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
2741 data,
2742 )
2743 .map(
2744 AccessControlUpgradeableErrors::AccessControlUnauthorizedAccount,
2745 )
2746 }
2747 AccessControlUnauthorizedAccount
2748 },
2749 {
2750 fn InvalidInitialization(
2751 data: &[u8],
2752 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2753 <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw(
2754 data,
2755 )
2756 .map(AccessControlUpgradeableErrors::InvalidInitialization)
2757 }
2758 InvalidInitialization
2759 },
2760 ];
2761 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2762 return Err(
2763 alloy_sol_types::Error::unknown_selector(
2764 <Self as alloy_sol_types::SolInterface>::NAME,
2765 selector,
2766 ),
2767 );
2768 };
2769 DECODE_SHIMS[idx](data)
2770 }
2771 #[inline]
2772 #[allow(non_snake_case)]
2773 fn abi_decode_raw_validate(
2774 selector: [u8; 4],
2775 data: &[u8],
2776 ) -> alloy_sol_types::Result<Self> {
2777 static DECODE_VALIDATE_SHIMS: &[fn(
2778 &[u8],
2779 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors>] = &[
2780 {
2781 fn AccessControlBadConfirmation(
2782 data: &[u8],
2783 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2784 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_decode_raw_validate(
2785 data,
2786 )
2787 .map(
2788 AccessControlUpgradeableErrors::AccessControlBadConfirmation,
2789 )
2790 }
2791 AccessControlBadConfirmation
2792 },
2793 {
2794 fn NotInitializing(
2795 data: &[u8],
2796 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2797 <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw_validate(
2798 data,
2799 )
2800 .map(AccessControlUpgradeableErrors::NotInitializing)
2801 }
2802 NotInitializing
2803 },
2804 {
2805 fn AccessControlUnauthorizedAccount(
2806 data: &[u8],
2807 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2808 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw_validate(
2809 data,
2810 )
2811 .map(
2812 AccessControlUpgradeableErrors::AccessControlUnauthorizedAccount,
2813 )
2814 }
2815 AccessControlUnauthorizedAccount
2816 },
2817 {
2818 fn InvalidInitialization(
2819 data: &[u8],
2820 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2821 <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw_validate(
2822 data,
2823 )
2824 .map(AccessControlUpgradeableErrors::InvalidInitialization)
2825 }
2826 InvalidInitialization
2827 },
2828 ];
2829 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2830 return Err(
2831 alloy_sol_types::Error::unknown_selector(
2832 <Self as alloy_sol_types::SolInterface>::NAME,
2833 selector,
2834 ),
2835 );
2836 };
2837 DECODE_VALIDATE_SHIMS[idx](data)
2838 }
2839 #[inline]
2840 fn abi_encoded_size(&self) -> usize {
2841 match self {
2842 Self::AccessControlBadConfirmation(inner) => {
2843 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encoded_size(
2844 inner,
2845 )
2846 }
2847 Self::AccessControlUnauthorizedAccount(inner) => {
2848 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
2849 inner,
2850 )
2851 }
2852 Self::InvalidInitialization(inner) => {
2853 <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(
2854 inner,
2855 )
2856 }
2857 Self::NotInitializing(inner) => {
2858 <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(
2859 inner,
2860 )
2861 }
2862 }
2863 }
2864 #[inline]
2865 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2866 match self {
2867 Self::AccessControlBadConfirmation(inner) => {
2868 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encode_raw(
2869 inner,
2870 out,
2871 )
2872 }
2873 Self::AccessControlUnauthorizedAccount(inner) => {
2874 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
2875 inner,
2876 out,
2877 )
2878 }
2879 Self::InvalidInitialization(inner) => {
2880 <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(
2881 inner,
2882 out,
2883 )
2884 }
2885 Self::NotInitializing(inner) => {
2886 <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(
2887 inner,
2888 out,
2889 )
2890 }
2891 }
2892 }
2893 }
2894 #[derive(Clone)]
2896 #[derive(serde::Serialize, serde::Deserialize)]
2897 #[derive(Debug, PartialEq, Eq, Hash)]
2898 pub enum AccessControlUpgradeableEvents {
2899 #[allow(missing_docs)]
2900 Initialized(Initialized),
2901 #[allow(missing_docs)]
2902 RoleAdminChanged(RoleAdminChanged),
2903 #[allow(missing_docs)]
2904 RoleGranted(RoleGranted),
2905 #[allow(missing_docs)]
2906 RoleRevoked(RoleRevoked),
2907 }
2908 impl AccessControlUpgradeableEvents {
2909 pub const SELECTORS: &'static [[u8; 32usize]] = &[
2916 [
2917 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
2918 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
2919 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
2920 ],
2921 [
2922 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
2923 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
2924 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
2925 ],
2926 [
2927 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
2928 19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
2929 33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
2930 ],
2931 [
2932 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
2933 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
2934 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
2935 ],
2936 ];
2937 pub const VARIANT_NAMES: &'static [&'static str] = &[
2939 ::core::stringify!(RoleGranted),
2940 ::core::stringify!(RoleAdminChanged),
2941 ::core::stringify!(Initialized),
2942 ::core::stringify!(RoleRevoked),
2943 ];
2944 pub const SIGNATURES: &'static [&'static str] = &[
2946 <RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE,
2947 <RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE,
2948 <Initialized as alloy_sol_types::SolEvent>::SIGNATURE,
2949 <RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE,
2950 ];
2951 #[inline]
2953 pub fn signature_by_selector(
2954 selector: [u8; 32usize],
2955 ) -> ::core::option::Option<&'static str> {
2956 match Self::SELECTORS.binary_search(&selector) {
2957 ::core::result::Result::Ok(idx) => {
2958 ::core::option::Option::Some(Self::SIGNATURES[idx])
2959 }
2960 ::core::result::Result::Err(_) => ::core::option::Option::None,
2961 }
2962 }
2963 #[inline]
2965 pub fn name_by_selector(
2966 selector: [u8; 32usize],
2967 ) -> ::core::option::Option<&'static str> {
2968 let sig = Self::signature_by_selector(selector)?;
2969 sig.split_once('(').map(|(name, _)| name)
2970 }
2971 }
2972 #[automatically_derived]
2973 impl alloy_sol_types::SolEventInterface for AccessControlUpgradeableEvents {
2974 const NAME: &'static str = "AccessControlUpgradeableEvents";
2975 const COUNT: usize = 4usize;
2976 fn decode_raw_log(
2977 topics: &[alloy_sol_types::Word],
2978 data: &[u8],
2979 ) -> alloy_sol_types::Result<Self> {
2980 match topics.first().copied() {
2981 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
2982 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
2983 topics,
2984 data,
2985 )
2986 .map(Self::Initialized)
2987 }
2988 Some(<RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
2989 <RoleAdminChanged as alloy_sol_types::SolEvent>::decode_raw_log(
2990 topics,
2991 data,
2992 )
2993 .map(Self::RoleAdminChanged)
2994 }
2995 Some(<RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
2996 <RoleGranted as alloy_sol_types::SolEvent>::decode_raw_log(
2997 topics,
2998 data,
2999 )
3000 .map(Self::RoleGranted)
3001 }
3002 Some(<RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3003 <RoleRevoked as alloy_sol_types::SolEvent>::decode_raw_log(
3004 topics,
3005 data,
3006 )
3007 .map(Self::RoleRevoked)
3008 }
3009 _ => {
3010 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
3011 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
3012 log: alloy_sol_types::private::Box::new(
3013 alloy_sol_types::private::LogData::new_unchecked(
3014 topics.to_vec(),
3015 data.to_vec().into(),
3016 ),
3017 ),
3018 })
3019 }
3020 }
3021 }
3022 }
3023 #[automatically_derived]
3024 impl alloy_sol_types::private::IntoLogData for AccessControlUpgradeableEvents {
3025 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3026 match self {
3027 Self::Initialized(inner) => {
3028 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3029 }
3030 Self::RoleAdminChanged(inner) => {
3031 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3032 }
3033 Self::RoleGranted(inner) => {
3034 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3035 }
3036 Self::RoleRevoked(inner) => {
3037 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3038 }
3039 }
3040 }
3041 fn into_log_data(self) -> alloy_sol_types::private::LogData {
3042 match self {
3043 Self::Initialized(inner) => {
3044 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3045 }
3046 Self::RoleAdminChanged(inner) => {
3047 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3048 }
3049 Self::RoleGranted(inner) => {
3050 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3051 }
3052 Self::RoleRevoked(inner) => {
3053 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3054 }
3055 }
3056 }
3057 }
3058 use alloy::contract as alloy_contract;
3059 #[inline]
3063 pub const fn new<
3064 P: alloy_contract::private::Provider<N>,
3065 N: alloy_contract::private::Network,
3066 >(
3067 address: alloy_sol_types::private::Address,
3068 __provider: P,
3069 ) -> AccessControlUpgradeableInstance<P, N> {
3070 AccessControlUpgradeableInstance::<P, N>::new(address, __provider)
3071 }
3072 #[inline]
3078 pub fn deploy<
3079 P: alloy_contract::private::Provider<N>,
3080 N: alloy_contract::private::Network,
3081 >(
3082 __provider: P,
3083 ) -> impl ::core::future::Future<
3084 Output = alloy_contract::Result<AccessControlUpgradeableInstance<P, N>>,
3085 > {
3086 AccessControlUpgradeableInstance::<P, N>::deploy(__provider)
3087 }
3088 #[inline]
3094 pub fn deploy_builder<
3095 P: alloy_contract::private::Provider<N>,
3096 N: alloy_contract::private::Network,
3097 >(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
3098 AccessControlUpgradeableInstance::<P, N>::deploy_builder(__provider)
3099 }
3100 #[derive(Clone)]
3112 pub struct AccessControlUpgradeableInstance<
3113 P,
3114 N = alloy_contract::private::Ethereum,
3115 > {
3116 address: alloy_sol_types::private::Address,
3117 provider: P,
3118 _network: ::core::marker::PhantomData<N>,
3119 }
3120 #[automatically_derived]
3121 impl<P, N> ::core::fmt::Debug for AccessControlUpgradeableInstance<P, N> {
3122 #[inline]
3123 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3124 f.debug_tuple("AccessControlUpgradeableInstance")
3125 .field(&self.address)
3126 .finish()
3127 }
3128 }
3129 impl<
3131 P: alloy_contract::private::Provider<N>,
3132 N: alloy_contract::private::Network,
3133 > AccessControlUpgradeableInstance<P, N> {
3134 #[inline]
3138 pub const fn new(
3139 address: alloy_sol_types::private::Address,
3140 __provider: P,
3141 ) -> Self {
3142 Self {
3143 address,
3144 provider: __provider,
3145 _network: ::core::marker::PhantomData,
3146 }
3147 }
3148 #[inline]
3154 pub async fn deploy(
3155 __provider: P,
3156 ) -> alloy_contract::Result<AccessControlUpgradeableInstance<P, N>> {
3157 let call_builder = Self::deploy_builder(__provider);
3158 let contract_address = call_builder.deploy().await?;
3159 Ok(Self::new(contract_address, call_builder.provider))
3160 }
3161 #[inline]
3167 pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
3168 alloy_contract::RawCallBuilder::new_raw_deploy(
3169 __provider,
3170 ::core::clone::Clone::clone(&BYTECODE),
3171 )
3172 }
3173 #[inline]
3175 pub const fn address(&self) -> &alloy_sol_types::private::Address {
3176 &self.address
3177 }
3178 #[inline]
3180 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3181 self.address = address;
3182 }
3183 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3185 self.set_address(address);
3186 self
3187 }
3188 #[inline]
3190 pub const fn provider(&self) -> &P {
3191 &self.provider
3192 }
3193 }
3194 impl<P: ::core::clone::Clone, N> AccessControlUpgradeableInstance<&P, N> {
3195 #[inline]
3197 pub fn with_cloned_provider(self) -> AccessControlUpgradeableInstance<P, N> {
3198 AccessControlUpgradeableInstance {
3199 address: self.address,
3200 provider: ::core::clone::Clone::clone(&self.provider),
3201 _network: ::core::marker::PhantomData,
3202 }
3203 }
3204 }
3205 impl<
3207 P: alloy_contract::private::Provider<N>,
3208 N: alloy_contract::private::Network,
3209 > AccessControlUpgradeableInstance<P, N> {
3210 pub fn call_builder<C: alloy_sol_types::SolCall>(
3215 &self,
3216 call: &C,
3217 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
3218 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3219 }
3220 pub fn DEFAULT_ADMIN_ROLE(
3222 &self,
3223 ) -> alloy_contract::SolCallBuilder<&P, DEFAULT_ADMIN_ROLECall, N> {
3224 self.call_builder(&DEFAULT_ADMIN_ROLECall)
3225 }
3226 pub fn getRoleAdmin(
3228 &self,
3229 role: alloy::sol_types::private::FixedBytes<32>,
3230 ) -> alloy_contract::SolCallBuilder<&P, getRoleAdminCall, N> {
3231 self.call_builder(&getRoleAdminCall { role })
3232 }
3233 pub fn grantRole(
3235 &self,
3236 role: alloy::sol_types::private::FixedBytes<32>,
3237 account: alloy::sol_types::private::Address,
3238 ) -> alloy_contract::SolCallBuilder<&P, grantRoleCall, N> {
3239 self.call_builder(&grantRoleCall { role, account })
3240 }
3241 pub fn hasRole(
3243 &self,
3244 role: alloy::sol_types::private::FixedBytes<32>,
3245 account: alloy::sol_types::private::Address,
3246 ) -> alloy_contract::SolCallBuilder<&P, hasRoleCall, N> {
3247 self.call_builder(&hasRoleCall { role, account })
3248 }
3249 pub fn renounceRole(
3251 &self,
3252 role: alloy::sol_types::private::FixedBytes<32>,
3253 callerConfirmation: alloy::sol_types::private::Address,
3254 ) -> alloy_contract::SolCallBuilder<&P, renounceRoleCall, N> {
3255 self.call_builder(
3256 &renounceRoleCall {
3257 role,
3258 callerConfirmation,
3259 },
3260 )
3261 }
3262 pub fn revokeRole(
3264 &self,
3265 role: alloy::sol_types::private::FixedBytes<32>,
3266 account: alloy::sol_types::private::Address,
3267 ) -> alloy_contract::SolCallBuilder<&P, revokeRoleCall, N> {
3268 self.call_builder(&revokeRoleCall { role, account })
3269 }
3270 pub fn supportsInterface(
3272 &self,
3273 interfaceId: alloy::sol_types::private::FixedBytes<4>,
3274 ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
3275 self.call_builder(
3276 &supportsInterfaceCall {
3277 interfaceId,
3278 },
3279 )
3280 }
3281 }
3282 impl<
3284 P: alloy_contract::private::Provider<N>,
3285 N: alloy_contract::private::Network,
3286 > AccessControlUpgradeableInstance<P, N> {
3287 pub fn event_filter<E: alloy_sol_types::SolEvent>(
3292 &self,
3293 ) -> alloy_contract::Event<&P, E, N> {
3294 alloy_contract::Event::new_sol(&self.provider, &self.address)
3295 }
3296 pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
3298 self.event_filter::<Initialized>()
3299 }
3300 pub fn RoleAdminChanged_filter(
3302 &self,
3303 ) -> alloy_contract::Event<&P, RoleAdminChanged, N> {
3304 self.event_filter::<RoleAdminChanged>()
3305 }
3306 pub fn RoleGranted_filter(&self) -> alloy_contract::Event<&P, RoleGranted, N> {
3308 self.event_filter::<RoleGranted>()
3309 }
3310 pub fn RoleRevoked_filter(&self) -> alloy_contract::Event<&P, RoleRevoked, N> {
3312 self.event_filter::<RoleRevoked>()
3313 }
3314 }
3315}