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