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::abi_decode_raw_with_config(
379 data,
380 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
381 )
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::abi_decode_raw_with_config(
476 data,
477 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
478 )
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::abi_decode_raw_with_config(
550 data,
551 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
552 )
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::abi_decode_raw_with_config(
624 data,
625 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
626 )
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_with_config(
1256 data: &[u8],
1257 config: alloy_sol_types::abi::AbiDecoderConfig,
1258 ) -> alloy_sol_types::Result<Self::Return> {
1259 <Self::ReturnTuple<
1260 '_,
1261 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
1262 data,
1263 config,
1264 )
1265 .map(|r| {
1266 let r: DEFAULT_ADMIN_ROLEReturn = r.into();
1267 r._0
1268 })
1269 }
1270 #[inline]
1271 fn abi_decode_returns_validate(
1272 data: &[u8],
1273 ) -> alloy_sol_types::Result<Self::Return> {
1274 Self::abi_decode_returns_with_config(
1275 data,
1276 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1277 )
1278 }
1279 }
1280 };
1281 #[derive(serde::Serialize, serde::Deserialize)]
1282 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1283 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1288 #[derive(Clone)]
1289 pub struct getRoleAdminCall {
1290 #[allow(missing_docs)]
1291 pub role: alloy::sol_types::private::FixedBytes<32>,
1292 }
1293 #[derive(serde::Serialize, serde::Deserialize)]
1294 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1295 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1297 #[derive(Clone)]
1298 pub struct getRoleAdminReturn {
1299 #[allow(missing_docs)]
1300 pub _0: alloy::sol_types::private::FixedBytes<32>,
1301 }
1302 #[allow(
1303 non_camel_case_types,
1304 non_snake_case,
1305 clippy::pub_underscore_fields,
1306 clippy::style
1307 )]
1308 const _: () = {
1309 use alloy::sol_types as alloy_sol_types;
1310 {
1311 #[doc(hidden)]
1312 #[allow(dead_code)]
1313 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1314 #[doc(hidden)]
1315 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1316 #[cfg(test)]
1317 #[allow(dead_code, unreachable_patterns)]
1318 fn _type_assertion(
1319 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1320 ) {
1321 match _t {
1322 alloy_sol_types::private::AssertTypeEq::<
1323 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1324 >(_) => {}
1325 }
1326 }
1327 #[automatically_derived]
1328 #[doc(hidden)]
1329 impl ::core::convert::From<getRoleAdminCall> for UnderlyingRustTuple<'_> {
1330 fn from(value: getRoleAdminCall) -> Self {
1331 (value.role,)
1332 }
1333 }
1334 #[automatically_derived]
1335 #[doc(hidden)]
1336 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminCall {
1337 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1338 Self { role: tuple.0 }
1339 }
1340 }
1341 }
1342 {
1343 #[doc(hidden)]
1344 #[allow(dead_code)]
1345 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1346 #[doc(hidden)]
1347 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1348 #[cfg(test)]
1349 #[allow(dead_code, unreachable_patterns)]
1350 fn _type_assertion(
1351 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1352 ) {
1353 match _t {
1354 alloy_sol_types::private::AssertTypeEq::<
1355 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1356 >(_) => {}
1357 }
1358 }
1359 #[automatically_derived]
1360 #[doc(hidden)]
1361 impl ::core::convert::From<getRoleAdminReturn> for UnderlyingRustTuple<'_> {
1362 fn from(value: getRoleAdminReturn) -> Self {
1363 (value._0,)
1364 }
1365 }
1366 #[automatically_derived]
1367 #[doc(hidden)]
1368 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminReturn {
1369 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1370 Self { _0: tuple.0 }
1371 }
1372 }
1373 }
1374 #[automatically_derived]
1375 impl alloy_sol_types::SolCall for getRoleAdminCall {
1376 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1377 type Token<'a> = <Self::Parameters<
1378 'a,
1379 > as alloy_sol_types::SolType>::Token<'a>;
1380 type Return = alloy::sol_types::private::FixedBytes<32>;
1381 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1382 type ReturnToken<'a> = <Self::ReturnTuple<
1383 'a,
1384 > as alloy_sol_types::SolType>::Token<'a>;
1385 const SIGNATURE: &'static str = "getRoleAdmin(bytes32)";
1386 const SELECTOR: [u8; 4] = [36u8, 138u8, 156u8, 163u8];
1387 #[inline]
1388 fn new<'a>(
1389 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1390 ) -> Self {
1391 tuple.into()
1392 }
1393 #[inline]
1394 fn tokenize(&self) -> Self::Token<'_> {
1395 (
1396 <alloy::sol_types::sol_data::FixedBytes<
1397 32,
1398 > as alloy_sol_types::SolType>::tokenize(&self.role),
1399 )
1400 }
1401 #[inline]
1402 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1403 (
1404 <alloy::sol_types::sol_data::FixedBytes<
1405 32,
1406 > as alloy_sol_types::SolType>::tokenize(ret),
1407 )
1408 }
1409 #[inline]
1410 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1411 <Self::ReturnTuple<
1412 '_,
1413 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1414 .map(|r| {
1415 let r: getRoleAdminReturn = r.into();
1416 r._0
1417 })
1418 }
1419 #[inline]
1420 fn abi_decode_returns_with_config(
1421 data: &[u8],
1422 config: alloy_sol_types::abi::AbiDecoderConfig,
1423 ) -> alloy_sol_types::Result<Self::Return> {
1424 <Self::ReturnTuple<
1425 '_,
1426 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
1427 data,
1428 config,
1429 )
1430 .map(|r| {
1431 let r: getRoleAdminReturn = r.into();
1432 r._0
1433 })
1434 }
1435 #[inline]
1436 fn abi_decode_returns_validate(
1437 data: &[u8],
1438 ) -> alloy_sol_types::Result<Self::Return> {
1439 Self::abi_decode_returns_with_config(
1440 data,
1441 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1442 )
1443 }
1444 }
1445 };
1446 #[derive(serde::Serialize, serde::Deserialize)]
1447 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1448 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1453 #[derive(Clone)]
1454 pub struct grantRoleCall {
1455 #[allow(missing_docs)]
1456 pub role: alloy::sol_types::private::FixedBytes<32>,
1457 #[allow(missing_docs)]
1458 pub account: alloy::sol_types::private::Address,
1459 }
1460 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1462 #[derive(Clone)]
1463 pub struct grantRoleReturn {}
1464 #[allow(
1465 non_camel_case_types,
1466 non_snake_case,
1467 clippy::pub_underscore_fields,
1468 clippy::style
1469 )]
1470 const _: () = {
1471 use alloy::sol_types as alloy_sol_types;
1472 {
1473 #[doc(hidden)]
1474 #[allow(dead_code)]
1475 type UnderlyingSolTuple<'a> = (
1476 alloy::sol_types::sol_data::FixedBytes<32>,
1477 alloy::sol_types::sol_data::Address,
1478 );
1479 #[doc(hidden)]
1480 type UnderlyingRustTuple<'a> = (
1481 alloy::sol_types::private::FixedBytes<32>,
1482 alloy::sol_types::private::Address,
1483 );
1484 #[cfg(test)]
1485 #[allow(dead_code, unreachable_patterns)]
1486 fn _type_assertion(
1487 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1488 ) {
1489 match _t {
1490 alloy_sol_types::private::AssertTypeEq::<
1491 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1492 >(_) => {}
1493 }
1494 }
1495 #[automatically_derived]
1496 #[doc(hidden)]
1497 impl ::core::convert::From<grantRoleCall> for UnderlyingRustTuple<'_> {
1498 fn from(value: grantRoleCall) -> Self {
1499 (value.role, value.account)
1500 }
1501 }
1502 #[automatically_derived]
1503 #[doc(hidden)]
1504 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
1505 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1506 Self {
1507 role: tuple.0,
1508 account: tuple.1,
1509 }
1510 }
1511 }
1512 }
1513 {
1514 #[doc(hidden)]
1515 #[allow(dead_code)]
1516 type UnderlyingSolTuple<'a> = ();
1517 #[doc(hidden)]
1518 type UnderlyingRustTuple<'a> = ();
1519 #[cfg(test)]
1520 #[allow(dead_code, unreachable_patterns)]
1521 fn _type_assertion(
1522 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1523 ) {
1524 match _t {
1525 alloy_sol_types::private::AssertTypeEq::<
1526 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1527 >(_) => {}
1528 }
1529 }
1530 #[automatically_derived]
1531 #[doc(hidden)]
1532 impl ::core::convert::From<grantRoleReturn> for UnderlyingRustTuple<'_> {
1533 fn from(value: grantRoleReturn) -> Self {
1534 ()
1535 }
1536 }
1537 #[automatically_derived]
1538 #[doc(hidden)]
1539 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
1540 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1541 Self {}
1542 }
1543 }
1544 }
1545 impl grantRoleReturn {
1546 fn _tokenize(
1547 &self,
1548 ) -> <grantRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1549 ()
1550 }
1551 }
1552 #[automatically_derived]
1553 impl alloy_sol_types::SolCall for grantRoleCall {
1554 type Parameters<'a> = (
1555 alloy::sol_types::sol_data::FixedBytes<32>,
1556 alloy::sol_types::sol_data::Address,
1557 );
1558 type Token<'a> = <Self::Parameters<
1559 'a,
1560 > as alloy_sol_types::SolType>::Token<'a>;
1561 type Return = grantRoleReturn;
1562 type ReturnTuple<'a> = ();
1563 type ReturnToken<'a> = <Self::ReturnTuple<
1564 'a,
1565 > as alloy_sol_types::SolType>::Token<'a>;
1566 const SIGNATURE: &'static str = "grantRole(bytes32,address)";
1567 const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
1568 #[inline]
1569 fn new<'a>(
1570 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1571 ) -> Self {
1572 tuple.into()
1573 }
1574 #[inline]
1575 fn tokenize(&self) -> Self::Token<'_> {
1576 (
1577 <alloy::sol_types::sol_data::FixedBytes<
1578 32,
1579 > as alloy_sol_types::SolType>::tokenize(&self.role),
1580 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1581 &self.account,
1582 ),
1583 )
1584 }
1585 #[inline]
1586 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1587 grantRoleReturn::_tokenize(ret)
1588 }
1589 #[inline]
1590 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1591 <Self::ReturnTuple<
1592 '_,
1593 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1594 .map(Into::into)
1595 }
1596 #[inline]
1597 fn abi_decode_returns_with_config(
1598 data: &[u8],
1599 config: alloy_sol_types::abi::AbiDecoderConfig,
1600 ) -> alloy_sol_types::Result<Self::Return> {
1601 <Self::ReturnTuple<
1602 '_,
1603 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
1604 data,
1605 config,
1606 )
1607 .map(Into::into)
1608 }
1609 #[inline]
1610 fn abi_decode_returns_validate(
1611 data: &[u8],
1612 ) -> alloy_sol_types::Result<Self::Return> {
1613 Self::abi_decode_returns_with_config(
1614 data,
1615 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1616 )
1617 }
1618 }
1619 };
1620 #[derive(serde::Serialize, serde::Deserialize)]
1621 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1622 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1627 #[derive(Clone)]
1628 pub struct hasRoleCall {
1629 #[allow(missing_docs)]
1630 pub role: alloy::sol_types::private::FixedBytes<32>,
1631 #[allow(missing_docs)]
1632 pub account: alloy::sol_types::private::Address,
1633 }
1634 #[derive(serde::Serialize, serde::Deserialize)]
1635 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1636 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1638 #[derive(Clone)]
1639 pub struct hasRoleReturn {
1640 #[allow(missing_docs)]
1641 pub _0: bool,
1642 }
1643 #[allow(
1644 non_camel_case_types,
1645 non_snake_case,
1646 clippy::pub_underscore_fields,
1647 clippy::style
1648 )]
1649 const _: () = {
1650 use alloy::sol_types as alloy_sol_types;
1651 {
1652 #[doc(hidden)]
1653 #[allow(dead_code)]
1654 type UnderlyingSolTuple<'a> = (
1655 alloy::sol_types::sol_data::FixedBytes<32>,
1656 alloy::sol_types::sol_data::Address,
1657 );
1658 #[doc(hidden)]
1659 type UnderlyingRustTuple<'a> = (
1660 alloy::sol_types::private::FixedBytes<32>,
1661 alloy::sol_types::private::Address,
1662 );
1663 #[cfg(test)]
1664 #[allow(dead_code, unreachable_patterns)]
1665 fn _type_assertion(
1666 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1667 ) {
1668 match _t {
1669 alloy_sol_types::private::AssertTypeEq::<
1670 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1671 >(_) => {}
1672 }
1673 }
1674 #[automatically_derived]
1675 #[doc(hidden)]
1676 impl ::core::convert::From<hasRoleCall> for UnderlyingRustTuple<'_> {
1677 fn from(value: hasRoleCall) -> Self {
1678 (value.role, value.account)
1679 }
1680 }
1681 #[automatically_derived]
1682 #[doc(hidden)]
1683 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleCall {
1684 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1685 Self {
1686 role: tuple.0,
1687 account: tuple.1,
1688 }
1689 }
1690 }
1691 }
1692 {
1693 #[doc(hidden)]
1694 #[allow(dead_code)]
1695 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1696 #[doc(hidden)]
1697 type UnderlyingRustTuple<'a> = (bool,);
1698 #[cfg(test)]
1699 #[allow(dead_code, unreachable_patterns)]
1700 fn _type_assertion(
1701 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1702 ) {
1703 match _t {
1704 alloy_sol_types::private::AssertTypeEq::<
1705 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1706 >(_) => {}
1707 }
1708 }
1709 #[automatically_derived]
1710 #[doc(hidden)]
1711 impl ::core::convert::From<hasRoleReturn> for UnderlyingRustTuple<'_> {
1712 fn from(value: hasRoleReturn) -> Self {
1713 (value._0,)
1714 }
1715 }
1716 #[automatically_derived]
1717 #[doc(hidden)]
1718 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleReturn {
1719 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1720 Self { _0: tuple.0 }
1721 }
1722 }
1723 }
1724 #[automatically_derived]
1725 impl alloy_sol_types::SolCall for hasRoleCall {
1726 type Parameters<'a> = (
1727 alloy::sol_types::sol_data::FixedBytes<32>,
1728 alloy::sol_types::sol_data::Address,
1729 );
1730 type Token<'a> = <Self::Parameters<
1731 'a,
1732 > as alloy_sol_types::SolType>::Token<'a>;
1733 type Return = bool;
1734 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1735 type ReturnToken<'a> = <Self::ReturnTuple<
1736 'a,
1737 > as alloy_sol_types::SolType>::Token<'a>;
1738 const SIGNATURE: &'static str = "hasRole(bytes32,address)";
1739 const SELECTOR: [u8; 4] = [145u8, 209u8, 72u8, 84u8];
1740 #[inline]
1741 fn new<'a>(
1742 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1743 ) -> Self {
1744 tuple.into()
1745 }
1746 #[inline]
1747 fn tokenize(&self) -> Self::Token<'_> {
1748 (
1749 <alloy::sol_types::sol_data::FixedBytes<
1750 32,
1751 > as alloy_sol_types::SolType>::tokenize(&self.role),
1752 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1753 &self.account,
1754 ),
1755 )
1756 }
1757 #[inline]
1758 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1759 (
1760 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
1761 ret,
1762 ),
1763 )
1764 }
1765 #[inline]
1766 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1767 <Self::ReturnTuple<
1768 '_,
1769 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1770 .map(|r| {
1771 let r: hasRoleReturn = r.into();
1772 r._0
1773 })
1774 }
1775 #[inline]
1776 fn abi_decode_returns_with_config(
1777 data: &[u8],
1778 config: alloy_sol_types::abi::AbiDecoderConfig,
1779 ) -> alloy_sol_types::Result<Self::Return> {
1780 <Self::ReturnTuple<
1781 '_,
1782 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
1783 data,
1784 config,
1785 )
1786 .map(|r| {
1787 let r: hasRoleReturn = r.into();
1788 r._0
1789 })
1790 }
1791 #[inline]
1792 fn abi_decode_returns_validate(
1793 data: &[u8],
1794 ) -> alloy_sol_types::Result<Self::Return> {
1795 Self::abi_decode_returns_with_config(
1796 data,
1797 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1798 )
1799 }
1800 }
1801 };
1802 #[derive(serde::Serialize, serde::Deserialize)]
1803 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1804 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1809 #[derive(Clone)]
1810 pub struct renounceRoleCall {
1811 #[allow(missing_docs)]
1812 pub role: alloy::sol_types::private::FixedBytes<32>,
1813 #[allow(missing_docs)]
1814 pub callerConfirmation: alloy::sol_types::private::Address,
1815 }
1816 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1818 #[derive(Clone)]
1819 pub struct renounceRoleReturn {}
1820 #[allow(
1821 non_camel_case_types,
1822 non_snake_case,
1823 clippy::pub_underscore_fields,
1824 clippy::style
1825 )]
1826 const _: () = {
1827 use alloy::sol_types as alloy_sol_types;
1828 {
1829 #[doc(hidden)]
1830 #[allow(dead_code)]
1831 type UnderlyingSolTuple<'a> = (
1832 alloy::sol_types::sol_data::FixedBytes<32>,
1833 alloy::sol_types::sol_data::Address,
1834 );
1835 #[doc(hidden)]
1836 type UnderlyingRustTuple<'a> = (
1837 alloy::sol_types::private::FixedBytes<32>,
1838 alloy::sol_types::private::Address,
1839 );
1840 #[cfg(test)]
1841 #[allow(dead_code, unreachable_patterns)]
1842 fn _type_assertion(
1843 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1844 ) {
1845 match _t {
1846 alloy_sol_types::private::AssertTypeEq::<
1847 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1848 >(_) => {}
1849 }
1850 }
1851 #[automatically_derived]
1852 #[doc(hidden)]
1853 impl ::core::convert::From<renounceRoleCall> for UnderlyingRustTuple<'_> {
1854 fn from(value: renounceRoleCall) -> Self {
1855 (value.role, value.callerConfirmation)
1856 }
1857 }
1858 #[automatically_derived]
1859 #[doc(hidden)]
1860 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleCall {
1861 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1862 Self {
1863 role: tuple.0,
1864 callerConfirmation: tuple.1,
1865 }
1866 }
1867 }
1868 }
1869 {
1870 #[doc(hidden)]
1871 #[allow(dead_code)]
1872 type UnderlyingSolTuple<'a> = ();
1873 #[doc(hidden)]
1874 type UnderlyingRustTuple<'a> = ();
1875 #[cfg(test)]
1876 #[allow(dead_code, unreachable_patterns)]
1877 fn _type_assertion(
1878 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1879 ) {
1880 match _t {
1881 alloy_sol_types::private::AssertTypeEq::<
1882 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1883 >(_) => {}
1884 }
1885 }
1886 #[automatically_derived]
1887 #[doc(hidden)]
1888 impl ::core::convert::From<renounceRoleReturn> for UnderlyingRustTuple<'_> {
1889 fn from(value: renounceRoleReturn) -> Self {
1890 ()
1891 }
1892 }
1893 #[automatically_derived]
1894 #[doc(hidden)]
1895 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleReturn {
1896 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1897 Self {}
1898 }
1899 }
1900 }
1901 impl renounceRoleReturn {
1902 fn _tokenize(
1903 &self,
1904 ) -> <renounceRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1905 ()
1906 }
1907 }
1908 #[automatically_derived]
1909 impl alloy_sol_types::SolCall for renounceRoleCall {
1910 type Parameters<'a> = (
1911 alloy::sol_types::sol_data::FixedBytes<32>,
1912 alloy::sol_types::sol_data::Address,
1913 );
1914 type Token<'a> = <Self::Parameters<
1915 'a,
1916 > as alloy_sol_types::SolType>::Token<'a>;
1917 type Return = renounceRoleReturn;
1918 type ReturnTuple<'a> = ();
1919 type ReturnToken<'a> = <Self::ReturnTuple<
1920 'a,
1921 > as alloy_sol_types::SolType>::Token<'a>;
1922 const SIGNATURE: &'static str = "renounceRole(bytes32,address)";
1923 const SELECTOR: [u8; 4] = [54u8, 86u8, 138u8, 190u8];
1924 #[inline]
1925 fn new<'a>(
1926 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1927 ) -> Self {
1928 tuple.into()
1929 }
1930 #[inline]
1931 fn tokenize(&self) -> Self::Token<'_> {
1932 (
1933 <alloy::sol_types::sol_data::FixedBytes<
1934 32,
1935 > as alloy_sol_types::SolType>::tokenize(&self.role),
1936 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1937 &self.callerConfirmation,
1938 ),
1939 )
1940 }
1941 #[inline]
1942 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1943 renounceRoleReturn::_tokenize(ret)
1944 }
1945 #[inline]
1946 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1947 <Self::ReturnTuple<
1948 '_,
1949 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1950 .map(Into::into)
1951 }
1952 #[inline]
1953 fn abi_decode_returns_with_config(
1954 data: &[u8],
1955 config: alloy_sol_types::abi::AbiDecoderConfig,
1956 ) -> alloy_sol_types::Result<Self::Return> {
1957 <Self::ReturnTuple<
1958 '_,
1959 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
1960 data,
1961 config,
1962 )
1963 .map(Into::into)
1964 }
1965 #[inline]
1966 fn abi_decode_returns_validate(
1967 data: &[u8],
1968 ) -> alloy_sol_types::Result<Self::Return> {
1969 Self::abi_decode_returns_with_config(
1970 data,
1971 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
1972 )
1973 }
1974 }
1975 };
1976 #[derive(serde::Serialize, serde::Deserialize)]
1977 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1978 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1983 #[derive(Clone)]
1984 pub struct revokeRoleCall {
1985 #[allow(missing_docs)]
1986 pub role: alloy::sol_types::private::FixedBytes<32>,
1987 #[allow(missing_docs)]
1988 pub account: alloy::sol_types::private::Address,
1989 }
1990 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1992 #[derive(Clone)]
1993 pub struct revokeRoleReturn {}
1994 #[allow(
1995 non_camel_case_types,
1996 non_snake_case,
1997 clippy::pub_underscore_fields,
1998 clippy::style
1999 )]
2000 const _: () = {
2001 use alloy::sol_types as alloy_sol_types;
2002 {
2003 #[doc(hidden)]
2004 #[allow(dead_code)]
2005 type UnderlyingSolTuple<'a> = (
2006 alloy::sol_types::sol_data::FixedBytes<32>,
2007 alloy::sol_types::sol_data::Address,
2008 );
2009 #[doc(hidden)]
2010 type UnderlyingRustTuple<'a> = (
2011 alloy::sol_types::private::FixedBytes<32>,
2012 alloy::sol_types::private::Address,
2013 );
2014 #[cfg(test)]
2015 #[allow(dead_code, unreachable_patterns)]
2016 fn _type_assertion(
2017 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2018 ) {
2019 match _t {
2020 alloy_sol_types::private::AssertTypeEq::<
2021 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2022 >(_) => {}
2023 }
2024 }
2025 #[automatically_derived]
2026 #[doc(hidden)]
2027 impl ::core::convert::From<revokeRoleCall> for UnderlyingRustTuple<'_> {
2028 fn from(value: revokeRoleCall) -> Self {
2029 (value.role, value.account)
2030 }
2031 }
2032 #[automatically_derived]
2033 #[doc(hidden)]
2034 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleCall {
2035 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2036 Self {
2037 role: tuple.0,
2038 account: tuple.1,
2039 }
2040 }
2041 }
2042 }
2043 {
2044 #[doc(hidden)]
2045 #[allow(dead_code)]
2046 type UnderlyingSolTuple<'a> = ();
2047 #[doc(hidden)]
2048 type UnderlyingRustTuple<'a> = ();
2049 #[cfg(test)]
2050 #[allow(dead_code, unreachable_patterns)]
2051 fn _type_assertion(
2052 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2053 ) {
2054 match _t {
2055 alloy_sol_types::private::AssertTypeEq::<
2056 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2057 >(_) => {}
2058 }
2059 }
2060 #[automatically_derived]
2061 #[doc(hidden)]
2062 impl ::core::convert::From<revokeRoleReturn> for UnderlyingRustTuple<'_> {
2063 fn from(value: revokeRoleReturn) -> Self {
2064 ()
2065 }
2066 }
2067 #[automatically_derived]
2068 #[doc(hidden)]
2069 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleReturn {
2070 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2071 Self {}
2072 }
2073 }
2074 }
2075 impl revokeRoleReturn {
2076 fn _tokenize(
2077 &self,
2078 ) -> <revokeRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2079 ()
2080 }
2081 }
2082 #[automatically_derived]
2083 impl alloy_sol_types::SolCall for revokeRoleCall {
2084 type Parameters<'a> = (
2085 alloy::sol_types::sol_data::FixedBytes<32>,
2086 alloy::sol_types::sol_data::Address,
2087 );
2088 type Token<'a> = <Self::Parameters<
2089 'a,
2090 > as alloy_sol_types::SolType>::Token<'a>;
2091 type Return = revokeRoleReturn;
2092 type ReturnTuple<'a> = ();
2093 type ReturnToken<'a> = <Self::ReturnTuple<
2094 'a,
2095 > as alloy_sol_types::SolType>::Token<'a>;
2096 const SIGNATURE: &'static str = "revokeRole(bytes32,address)";
2097 const SELECTOR: [u8; 4] = [213u8, 71u8, 116u8, 31u8];
2098 #[inline]
2099 fn new<'a>(
2100 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2101 ) -> Self {
2102 tuple.into()
2103 }
2104 #[inline]
2105 fn tokenize(&self) -> Self::Token<'_> {
2106 (
2107 <alloy::sol_types::sol_data::FixedBytes<
2108 32,
2109 > as alloy_sol_types::SolType>::tokenize(&self.role),
2110 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2111 &self.account,
2112 ),
2113 )
2114 }
2115 #[inline]
2116 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2117 revokeRoleReturn::_tokenize(ret)
2118 }
2119 #[inline]
2120 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2121 <Self::ReturnTuple<
2122 '_,
2123 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2124 .map(Into::into)
2125 }
2126 #[inline]
2127 fn abi_decode_returns_with_config(
2128 data: &[u8],
2129 config: alloy_sol_types::abi::AbiDecoderConfig,
2130 ) -> alloy_sol_types::Result<Self::Return> {
2131 <Self::ReturnTuple<
2132 '_,
2133 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
2134 data,
2135 config,
2136 )
2137 .map(Into::into)
2138 }
2139 #[inline]
2140 fn abi_decode_returns_validate(
2141 data: &[u8],
2142 ) -> alloy_sol_types::Result<Self::Return> {
2143 Self::abi_decode_returns_with_config(
2144 data,
2145 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2146 )
2147 }
2148 }
2149 };
2150 #[derive(serde::Serialize, serde::Deserialize)]
2151 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2152 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2157 #[derive(Clone)]
2158 pub struct supportsInterfaceCall {
2159 #[allow(missing_docs)]
2160 pub interfaceId: alloy::sol_types::private::FixedBytes<4>,
2161 }
2162 #[derive(serde::Serialize, serde::Deserialize)]
2163 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2164 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2166 #[derive(Clone)]
2167 pub struct supportsInterfaceReturn {
2168 #[allow(missing_docs)]
2169 pub _0: bool,
2170 }
2171 #[allow(
2172 non_camel_case_types,
2173 non_snake_case,
2174 clippy::pub_underscore_fields,
2175 clippy::style
2176 )]
2177 const _: () = {
2178 use alloy::sol_types as alloy_sol_types;
2179 {
2180 #[doc(hidden)]
2181 #[allow(dead_code)]
2182 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
2183 #[doc(hidden)]
2184 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
2185 #[cfg(test)]
2186 #[allow(dead_code, unreachable_patterns)]
2187 fn _type_assertion(
2188 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2189 ) {
2190 match _t {
2191 alloy_sol_types::private::AssertTypeEq::<
2192 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2193 >(_) => {}
2194 }
2195 }
2196 #[automatically_derived]
2197 #[doc(hidden)]
2198 impl ::core::convert::From<supportsInterfaceCall>
2199 for UnderlyingRustTuple<'_> {
2200 fn from(value: supportsInterfaceCall) -> Self {
2201 (value.interfaceId,)
2202 }
2203 }
2204 #[automatically_derived]
2205 #[doc(hidden)]
2206 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2207 for supportsInterfaceCall {
2208 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2209 Self { interfaceId: tuple.0 }
2210 }
2211 }
2212 }
2213 {
2214 #[doc(hidden)]
2215 #[allow(dead_code)]
2216 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2217 #[doc(hidden)]
2218 type UnderlyingRustTuple<'a> = (bool,);
2219 #[cfg(test)]
2220 #[allow(dead_code, unreachable_patterns)]
2221 fn _type_assertion(
2222 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2223 ) {
2224 match _t {
2225 alloy_sol_types::private::AssertTypeEq::<
2226 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2227 >(_) => {}
2228 }
2229 }
2230 #[automatically_derived]
2231 #[doc(hidden)]
2232 impl ::core::convert::From<supportsInterfaceReturn>
2233 for UnderlyingRustTuple<'_> {
2234 fn from(value: supportsInterfaceReturn) -> Self {
2235 (value._0,)
2236 }
2237 }
2238 #[automatically_derived]
2239 #[doc(hidden)]
2240 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2241 for supportsInterfaceReturn {
2242 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2243 Self { _0: tuple.0 }
2244 }
2245 }
2246 }
2247 #[automatically_derived]
2248 impl alloy_sol_types::SolCall for supportsInterfaceCall {
2249 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
2250 type Token<'a> = <Self::Parameters<
2251 'a,
2252 > as alloy_sol_types::SolType>::Token<'a>;
2253 type Return = bool;
2254 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2255 type ReturnToken<'a> = <Self::ReturnTuple<
2256 'a,
2257 > as alloy_sol_types::SolType>::Token<'a>;
2258 const SIGNATURE: &'static str = "supportsInterface(bytes4)";
2259 const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
2260 #[inline]
2261 fn new<'a>(
2262 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2263 ) -> Self {
2264 tuple.into()
2265 }
2266 #[inline]
2267 fn tokenize(&self) -> Self::Token<'_> {
2268 (
2269 <alloy::sol_types::sol_data::FixedBytes<
2270 4,
2271 > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
2272 )
2273 }
2274 #[inline]
2275 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2276 (
2277 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
2278 ret,
2279 ),
2280 )
2281 }
2282 #[inline]
2283 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2284 <Self::ReturnTuple<
2285 '_,
2286 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2287 .map(|r| {
2288 let r: supportsInterfaceReturn = r.into();
2289 r._0
2290 })
2291 }
2292 #[inline]
2293 fn abi_decode_returns_with_config(
2294 data: &[u8],
2295 config: alloy_sol_types::abi::AbiDecoderConfig,
2296 ) -> alloy_sol_types::Result<Self::Return> {
2297 <Self::ReturnTuple<
2298 '_,
2299 > as alloy_sol_types::SolType>::abi_decode_sequence_with_config(
2300 data,
2301 config,
2302 )
2303 .map(|r| {
2304 let r: supportsInterfaceReturn = r.into();
2305 r._0
2306 })
2307 }
2308 #[inline]
2309 fn abi_decode_returns_validate(
2310 data: &[u8],
2311 ) -> alloy_sol_types::Result<Self::Return> {
2312 Self::abi_decode_returns_with_config(
2313 data,
2314 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2315 )
2316 }
2317 }
2318 };
2319 #[derive(Clone)]
2321 #[derive(serde::Serialize, serde::Deserialize)]
2322 #[derive(Debug, PartialEq, Eq, Hash)]
2323 pub enum AccessControlUpgradeableCalls {
2324 #[allow(missing_docs)]
2325 DEFAULT_ADMIN_ROLE(DEFAULT_ADMIN_ROLECall),
2326 #[allow(missing_docs)]
2327 getRoleAdmin(getRoleAdminCall),
2328 #[allow(missing_docs)]
2329 grantRole(grantRoleCall),
2330 #[allow(missing_docs)]
2331 hasRole(hasRoleCall),
2332 #[allow(missing_docs)]
2333 renounceRole(renounceRoleCall),
2334 #[allow(missing_docs)]
2335 revokeRole(revokeRoleCall),
2336 #[allow(missing_docs)]
2337 supportsInterface(supportsInterfaceCall),
2338 }
2339 impl AccessControlUpgradeableCalls {
2340 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2347 [1u8, 255u8, 201u8, 167u8],
2348 [36u8, 138u8, 156u8, 163u8],
2349 [47u8, 47u8, 241u8, 93u8],
2350 [54u8, 86u8, 138u8, 190u8],
2351 [145u8, 209u8, 72u8, 84u8],
2352 [162u8, 23u8, 253u8, 223u8],
2353 [213u8, 71u8, 116u8, 31u8],
2354 ];
2355 pub const VARIANT_NAMES: &'static [&'static str] = &[
2357 ::core::stringify!(supportsInterface),
2358 ::core::stringify!(getRoleAdmin),
2359 ::core::stringify!(grantRole),
2360 ::core::stringify!(renounceRole),
2361 ::core::stringify!(hasRole),
2362 ::core::stringify!(DEFAULT_ADMIN_ROLE),
2363 ::core::stringify!(revokeRole),
2364 ];
2365 pub const SIGNATURES: &'static [&'static str] = &[
2367 <supportsInterfaceCall as alloy_sol_types::SolCall>::SIGNATURE,
2368 <getRoleAdminCall as alloy_sol_types::SolCall>::SIGNATURE,
2369 <grantRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
2370 <renounceRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
2371 <hasRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
2372 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SIGNATURE,
2373 <revokeRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
2374 ];
2375 #[inline]
2377 pub fn signature_by_selector(
2378 selector: [u8; 4usize],
2379 ) -> ::core::option::Option<&'static str> {
2380 match Self::SELECTORS.binary_search(&selector) {
2381 ::core::result::Result::Ok(idx) => {
2382 ::core::option::Option::Some(Self::SIGNATURES[idx])
2383 }
2384 ::core::result::Result::Err(_) => ::core::option::Option::None,
2385 }
2386 }
2387 #[inline]
2389 pub fn name_by_selector(
2390 selector: [u8; 4usize],
2391 ) -> ::core::option::Option<&'static str> {
2392 let sig = Self::signature_by_selector(selector)?;
2393 sig.split_once('(').map(|(name, _)| name)
2394 }
2395 }
2396 #[automatically_derived]
2397 impl alloy_sol_types::SolInterface for AccessControlUpgradeableCalls {
2398 const NAME: &'static str = "AccessControlUpgradeableCalls";
2399 const MIN_DATA_LENGTH: usize = 0usize;
2400 const COUNT: usize = 7usize;
2401 #[inline]
2402 fn selector(&self) -> [u8; 4] {
2403 match self {
2404 Self::DEFAULT_ADMIN_ROLE(_) => {
2405 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SELECTOR
2406 }
2407 Self::getRoleAdmin(_) => {
2408 <getRoleAdminCall as alloy_sol_types::SolCall>::SELECTOR
2409 }
2410 Self::grantRole(_) => {
2411 <grantRoleCall as alloy_sol_types::SolCall>::SELECTOR
2412 }
2413 Self::hasRole(_) => <hasRoleCall as alloy_sol_types::SolCall>::SELECTOR,
2414 Self::renounceRole(_) => {
2415 <renounceRoleCall as alloy_sol_types::SolCall>::SELECTOR
2416 }
2417 Self::revokeRole(_) => {
2418 <revokeRoleCall as alloy_sol_types::SolCall>::SELECTOR
2419 }
2420 Self::supportsInterface(_) => {
2421 <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
2422 }
2423 }
2424 }
2425 #[inline]
2426 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2427 Self::SELECTORS.get(i).copied()
2428 }
2429 #[inline]
2430 fn valid_selector(selector: [u8; 4]) -> bool {
2431 Self::SELECTORS.binary_search(&selector).is_ok()
2432 }
2433 #[inline]
2434 #[allow(non_snake_case)]
2435 fn abi_decode_raw(
2436 selector: [u8; 4],
2437 data: &[u8],
2438 ) -> alloy_sol_types::Result<Self> {
2439 Self::abi_decode_raw_with_config(
2440 selector,
2441 data,
2442 alloy_sol_types::abi::AbiDecoderConfig::default(),
2443 )
2444 }
2445 #[inline]
2446 #[allow(non_snake_case)]
2447 fn abi_decode_raw_with_config(
2448 selector: [u8; 4],
2449 data: &[u8],
2450 config: alloy_sol_types::abi::AbiDecoderConfig,
2451 ) -> alloy_sol_types::Result<Self> {
2452 static DECODE_SHIMS: &[fn(
2453 &[u8],
2454 alloy_sol_types::abi::AbiDecoderConfig,
2455 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls>] = &[
2456 {
2457 fn supportsInterface(
2458 data: &[u8],
2459 config: alloy_sol_types::abi::AbiDecoderConfig,
2460 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2461 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
2462 data,
2463 config,
2464 )
2465 .map(AccessControlUpgradeableCalls::supportsInterface)
2466 }
2467 supportsInterface
2468 },
2469 {
2470 fn getRoleAdmin(
2471 data: &[u8],
2472 config: alloy_sol_types::abi::AbiDecoderConfig,
2473 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2474 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
2475 data,
2476 config,
2477 )
2478 .map(AccessControlUpgradeableCalls::getRoleAdmin)
2479 }
2480 getRoleAdmin
2481 },
2482 {
2483 fn grantRole(
2484 data: &[u8],
2485 config: alloy_sol_types::abi::AbiDecoderConfig,
2486 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2487 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
2488 data,
2489 config,
2490 )
2491 .map(AccessControlUpgradeableCalls::grantRole)
2492 }
2493 grantRole
2494 },
2495 {
2496 fn renounceRole(
2497 data: &[u8],
2498 config: alloy_sol_types::abi::AbiDecoderConfig,
2499 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2500 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
2501 data,
2502 config,
2503 )
2504 .map(AccessControlUpgradeableCalls::renounceRole)
2505 }
2506 renounceRole
2507 },
2508 {
2509 fn hasRole(
2510 data: &[u8],
2511 config: alloy_sol_types::abi::AbiDecoderConfig,
2512 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2513 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
2514 data,
2515 config,
2516 )
2517 .map(AccessControlUpgradeableCalls::hasRole)
2518 }
2519 hasRole
2520 },
2521 {
2522 fn DEFAULT_ADMIN_ROLE(
2523 data: &[u8],
2524 config: alloy_sol_types::abi::AbiDecoderConfig,
2525 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2526 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
2527 data,
2528 config,
2529 )
2530 .map(AccessControlUpgradeableCalls::DEFAULT_ADMIN_ROLE)
2531 }
2532 DEFAULT_ADMIN_ROLE
2533 },
2534 {
2535 fn revokeRole(
2536 data: &[u8],
2537 config: alloy_sol_types::abi::AbiDecoderConfig,
2538 ) -> alloy_sol_types::Result<AccessControlUpgradeableCalls> {
2539 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_with_config(
2540 data,
2541 config,
2542 )
2543 .map(AccessControlUpgradeableCalls::revokeRole)
2544 }
2545 revokeRole
2546 },
2547 ];
2548 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2549 return Err(
2550 alloy_sol_types::Error::unknown_selector(
2551 <Self as alloy_sol_types::SolInterface>::NAME,
2552 selector,
2553 ),
2554 );
2555 };
2556 DECODE_SHIMS[idx](data, config)
2557 }
2558 #[inline]
2559 #[allow(non_snake_case)]
2560 fn abi_decode_raw_validate(
2561 selector: [u8; 4],
2562 data: &[u8],
2563 ) -> alloy_sol_types::Result<Self> {
2564 Self::abi_decode_raw_with_config(
2565 selector,
2566 data,
2567 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2568 )
2569 }
2570 #[inline]
2571 fn abi_encoded_size(&self) -> usize {
2572 match self {
2573 Self::DEFAULT_ADMIN_ROLE(inner) => {
2574 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
2575 inner,
2576 )
2577 }
2578 Self::getRoleAdmin(inner) => {
2579 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
2580 inner,
2581 )
2582 }
2583 Self::grantRole(inner) => {
2584 <grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2585 }
2586 Self::hasRole(inner) => {
2587 <hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2588 }
2589 Self::renounceRole(inner) => {
2590 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(
2591 inner,
2592 )
2593 }
2594 Self::revokeRole(inner) => {
2595 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2596 }
2597 Self::supportsInterface(inner) => {
2598 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
2599 inner,
2600 )
2601 }
2602 }
2603 }
2604 #[inline]
2605 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2606 match self {
2607 Self::DEFAULT_ADMIN_ROLE(inner) => {
2608 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
2609 inner,
2610 out,
2611 )
2612 }
2613 Self::getRoleAdmin(inner) => {
2614 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
2615 inner,
2616 out,
2617 )
2618 }
2619 Self::grantRole(inner) => {
2620 <grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
2621 inner,
2622 out,
2623 )
2624 }
2625 Self::hasRole(inner) => {
2626 <hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2627 }
2628 Self::renounceRole(inner) => {
2629 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
2630 inner,
2631 out,
2632 )
2633 }
2634 Self::revokeRole(inner) => {
2635 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
2636 inner,
2637 out,
2638 )
2639 }
2640 Self::supportsInterface(inner) => {
2641 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
2642 inner,
2643 out,
2644 )
2645 }
2646 }
2647 }
2648 }
2649 #[derive(Clone)]
2651 #[derive(serde::Serialize, serde::Deserialize)]
2652 #[derive(Debug, PartialEq, Eq, Hash)]
2653 pub enum AccessControlUpgradeableErrors {
2654 #[allow(missing_docs)]
2655 AccessControlBadConfirmation(AccessControlBadConfirmation),
2656 #[allow(missing_docs)]
2657 AccessControlUnauthorizedAccount(AccessControlUnauthorizedAccount),
2658 #[allow(missing_docs)]
2659 InvalidInitialization(InvalidInitialization),
2660 #[allow(missing_docs)]
2661 NotInitializing(NotInitializing),
2662 }
2663 impl AccessControlUpgradeableErrors {
2664 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2671 [102u8, 151u8, 178u8, 50u8],
2672 [215u8, 230u8, 188u8, 248u8],
2673 [226u8, 81u8, 125u8, 63u8],
2674 [249u8, 46u8, 232u8, 169u8],
2675 ];
2676 pub const VARIANT_NAMES: &'static [&'static str] = &[
2678 ::core::stringify!(AccessControlBadConfirmation),
2679 ::core::stringify!(NotInitializing),
2680 ::core::stringify!(AccessControlUnauthorizedAccount),
2681 ::core::stringify!(InvalidInitialization),
2682 ];
2683 pub const SIGNATURES: &'static [&'static str] = &[
2685 <AccessControlBadConfirmation as alloy_sol_types::SolError>::SIGNATURE,
2686 <NotInitializing as alloy_sol_types::SolError>::SIGNATURE,
2687 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::SIGNATURE,
2688 <InvalidInitialization as alloy_sol_types::SolError>::SIGNATURE,
2689 ];
2690 #[inline]
2692 pub fn signature_by_selector(
2693 selector: [u8; 4usize],
2694 ) -> ::core::option::Option<&'static str> {
2695 match Self::SELECTORS.binary_search(&selector) {
2696 ::core::result::Result::Ok(idx) => {
2697 ::core::option::Option::Some(Self::SIGNATURES[idx])
2698 }
2699 ::core::result::Result::Err(_) => ::core::option::Option::None,
2700 }
2701 }
2702 #[inline]
2704 pub fn name_by_selector(
2705 selector: [u8; 4usize],
2706 ) -> ::core::option::Option<&'static str> {
2707 let sig = Self::signature_by_selector(selector)?;
2708 sig.split_once('(').map(|(name, _)| name)
2709 }
2710 }
2711 #[automatically_derived]
2712 impl alloy_sol_types::SolInterface for AccessControlUpgradeableErrors {
2713 const NAME: &'static str = "AccessControlUpgradeableErrors";
2714 const MIN_DATA_LENGTH: usize = 0usize;
2715 const COUNT: usize = 4usize;
2716 #[inline]
2717 fn selector(&self) -> [u8; 4] {
2718 match self {
2719 Self::AccessControlBadConfirmation(_) => {
2720 <AccessControlBadConfirmation as alloy_sol_types::SolError>::SELECTOR
2721 }
2722 Self::AccessControlUnauthorizedAccount(_) => {
2723 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
2724 }
2725 Self::InvalidInitialization(_) => {
2726 <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
2727 }
2728 Self::NotInitializing(_) => {
2729 <NotInitializing as alloy_sol_types::SolError>::SELECTOR
2730 }
2731 }
2732 }
2733 #[inline]
2734 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2735 Self::SELECTORS.get(i).copied()
2736 }
2737 #[inline]
2738 fn valid_selector(selector: [u8; 4]) -> bool {
2739 Self::SELECTORS.binary_search(&selector).is_ok()
2740 }
2741 #[inline]
2742 #[allow(non_snake_case)]
2743 fn abi_decode_raw(
2744 selector: [u8; 4],
2745 data: &[u8],
2746 ) -> alloy_sol_types::Result<Self> {
2747 Self::abi_decode_raw_with_config(
2748 selector,
2749 data,
2750 alloy_sol_types::abi::AbiDecoderConfig::default(),
2751 )
2752 }
2753 #[inline]
2754 #[allow(non_snake_case)]
2755 fn abi_decode_raw_with_config(
2756 selector: [u8; 4],
2757 data: &[u8],
2758 config: alloy_sol_types::abi::AbiDecoderConfig,
2759 ) -> alloy_sol_types::Result<Self> {
2760 static DECODE_SHIMS: &[fn(
2761 &[u8],
2762 alloy_sol_types::abi::AbiDecoderConfig,
2763 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors>] = &[
2764 {
2765 fn AccessControlBadConfirmation(
2766 data: &[u8],
2767 config: alloy_sol_types::abi::AbiDecoderConfig,
2768 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2769 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_decode_raw_with_config(
2770 data,
2771 config,
2772 )
2773 .map(
2774 AccessControlUpgradeableErrors::AccessControlBadConfirmation,
2775 )
2776 }
2777 AccessControlBadConfirmation
2778 },
2779 {
2780 fn NotInitializing(
2781 data: &[u8],
2782 config: alloy_sol_types::abi::AbiDecoderConfig,
2783 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2784 <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw_with_config(
2785 data,
2786 config,
2787 )
2788 .map(AccessControlUpgradeableErrors::NotInitializing)
2789 }
2790 NotInitializing
2791 },
2792 {
2793 fn AccessControlUnauthorizedAccount(
2794 data: &[u8],
2795 config: alloy_sol_types::abi::AbiDecoderConfig,
2796 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2797 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw_with_config(
2798 data,
2799 config,
2800 )
2801 .map(
2802 AccessControlUpgradeableErrors::AccessControlUnauthorizedAccount,
2803 )
2804 }
2805 AccessControlUnauthorizedAccount
2806 },
2807 {
2808 fn InvalidInitialization(
2809 data: &[u8],
2810 config: alloy_sol_types::abi::AbiDecoderConfig,
2811 ) -> alloy_sol_types::Result<AccessControlUpgradeableErrors> {
2812 <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw_with_config(
2813 data,
2814 config,
2815 )
2816 .map(AccessControlUpgradeableErrors::InvalidInitialization)
2817 }
2818 InvalidInitialization
2819 },
2820 ];
2821 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2822 return Err(
2823 alloy_sol_types::Error::unknown_selector(
2824 <Self as alloy_sol_types::SolInterface>::NAME,
2825 selector,
2826 ),
2827 );
2828 };
2829 DECODE_SHIMS[idx](data, config)
2830 }
2831 #[inline]
2832 #[allow(non_snake_case)]
2833 fn abi_decode_raw_validate(
2834 selector: [u8; 4],
2835 data: &[u8],
2836 ) -> alloy_sol_types::Result<Self> {
2837 Self::abi_decode_raw_with_config(
2838 selector,
2839 data,
2840 alloy_sol_types::abi::AbiDecoderConfig::new().validate(true),
2841 )
2842 }
2843 #[inline]
2844 fn abi_encoded_size(&self) -> usize {
2845 match self {
2846 Self::AccessControlBadConfirmation(inner) => {
2847 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encoded_size(
2848 inner,
2849 )
2850 }
2851 Self::AccessControlUnauthorizedAccount(inner) => {
2852 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
2853 inner,
2854 )
2855 }
2856 Self::InvalidInitialization(inner) => {
2857 <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(
2858 inner,
2859 )
2860 }
2861 Self::NotInitializing(inner) => {
2862 <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(
2863 inner,
2864 )
2865 }
2866 }
2867 }
2868 #[inline]
2869 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2870 match self {
2871 Self::AccessControlBadConfirmation(inner) => {
2872 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encode_raw(
2873 inner,
2874 out,
2875 )
2876 }
2877 Self::AccessControlUnauthorizedAccount(inner) => {
2878 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
2879 inner,
2880 out,
2881 )
2882 }
2883 Self::InvalidInitialization(inner) => {
2884 <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(
2885 inner,
2886 out,
2887 )
2888 }
2889 Self::NotInitializing(inner) => {
2890 <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(
2891 inner,
2892 out,
2893 )
2894 }
2895 }
2896 }
2897 }
2898 #[automatically_derived]
2899 impl AccessControlUpgradeableErrors {
2900 #[inline]
2906 pub fn access_control_bad_confirmation() -> Self {
2907 Self::AccessControlBadConfirmation(AccessControlBadConfirmation)
2908 }
2909 #[inline]
2915 pub fn access_control_unauthorized_account(
2916 account: alloy::sol_types::private::Address,
2917 needed_role: alloy::sol_types::private::FixedBytes<32>,
2918 ) -> Self {
2919 Self::AccessControlUnauthorizedAccount(AccessControlUnauthorizedAccount {
2920 account: account,
2921 neededRole: needed_role,
2922 })
2923 }
2924 #[inline]
2930 pub fn invalid_initialization() -> Self {
2931 Self::InvalidInitialization(InvalidInitialization)
2932 }
2933 #[inline]
2939 pub fn not_initializing() -> Self {
2940 Self::NotInitializing(NotInitializing)
2941 }
2942 }
2943 #[derive(Clone)]
2945 #[derive(serde::Serialize, serde::Deserialize)]
2946 #[derive(Debug, PartialEq, Eq, Hash)]
2947 pub enum AccessControlUpgradeableEvents {
2948 #[allow(missing_docs)]
2949 Initialized(Initialized),
2950 #[allow(missing_docs)]
2951 RoleAdminChanged(RoleAdminChanged),
2952 #[allow(missing_docs)]
2953 RoleGranted(RoleGranted),
2954 #[allow(missing_docs)]
2955 RoleRevoked(RoleRevoked),
2956 }
2957 impl AccessControlUpgradeableEvents {
2958 pub const SELECTORS: &'static [[u8; 32usize]] = &[
2965 [
2966 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
2967 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
2968 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
2969 ],
2970 [
2971 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
2972 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
2973 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
2974 ],
2975 [
2976 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8,
2977 19u8, 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8,
2978 33u8, 238u8, 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8,
2979 ],
2980 [
2981 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
2982 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
2983 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
2984 ],
2985 ];
2986 pub const VARIANT_NAMES: &'static [&'static str] = &[
2988 ::core::stringify!(RoleGranted),
2989 ::core::stringify!(RoleAdminChanged),
2990 ::core::stringify!(Initialized),
2991 ::core::stringify!(RoleRevoked),
2992 ];
2993 pub const SIGNATURES: &'static [&'static str] = &[
2995 <RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE,
2996 <RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE,
2997 <Initialized as alloy_sol_types::SolEvent>::SIGNATURE,
2998 <RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE,
2999 ];
3000 #[inline]
3002 pub fn signature_by_selector(
3003 selector: [u8; 32usize],
3004 ) -> ::core::option::Option<&'static str> {
3005 match Self::SELECTORS.binary_search(&selector) {
3006 ::core::result::Result::Ok(idx) => {
3007 ::core::option::Option::Some(Self::SIGNATURES[idx])
3008 }
3009 ::core::result::Result::Err(_) => ::core::option::Option::None,
3010 }
3011 }
3012 #[inline]
3014 pub fn name_by_selector(
3015 selector: [u8; 32usize],
3016 ) -> ::core::option::Option<&'static str> {
3017 let sig = Self::signature_by_selector(selector)?;
3018 sig.split_once('(').map(|(name, _)| name)
3019 }
3020 }
3021 #[automatically_derived]
3022 impl alloy_sol_types::SolEventInterface for AccessControlUpgradeableEvents {
3023 const NAME: &'static str = "AccessControlUpgradeableEvents";
3024 const COUNT: usize = 4usize;
3025 fn decode_raw_log(
3026 topics: &[alloy_sol_types::Word],
3027 data: &[u8],
3028 ) -> alloy_sol_types::Result<Self> {
3029 <Self as alloy_sol_types::SolEventInterface>::decode_raw_log_with_config(
3030 topics,
3031 data,
3032 alloy_sol_types::abi::AbiDecoderConfig::default(),
3033 )
3034 }
3035 fn decode_raw_log_with_config(
3036 topics: &[alloy_sol_types::Word],
3037 data: &[u8],
3038 config: alloy_sol_types::abi::AbiDecoderConfig,
3039 ) -> alloy_sol_types::Result<Self> {
3040 match topics.first().copied() {
3041 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3042 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
3043 topics,
3044 data,
3045 config,
3046 )
3047 .map(Self::Initialized)
3048 }
3049 Some(<RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3050 <RoleAdminChanged as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
3051 topics,
3052 data,
3053 config,
3054 )
3055 .map(Self::RoleAdminChanged)
3056 }
3057 Some(<RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3058 <RoleGranted as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
3059 topics,
3060 data,
3061 config,
3062 )
3063 .map(Self::RoleGranted)
3064 }
3065 Some(<RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3066 <RoleRevoked as alloy_sol_types::SolEvent>::decode_raw_log_with_config(
3067 topics,
3068 data,
3069 config,
3070 )
3071 .map(Self::RoleRevoked)
3072 }
3073 _ => {
3074 if topics
3075 .len()
3076 .checked_mul(alloy_sol_types::Word::len_bytes())
3077 .and_then(|len| len.checked_add(data.len()))
3078 .is_none_or(|len| len > config.get_memory_limit())
3079 {
3080 return alloy_sol_types::private::Err(
3081 alloy_sol_types::Error::MemoryLimitExceeded(
3082 config.get_memory_limit(),
3083 ),
3084 );
3085 }
3086 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
3087 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
3088 log: alloy_sol_types::private::Box::new(
3089 alloy_sol_types::private::LogData::new_unchecked(
3090 topics.to_vec(),
3091 data.to_vec().into(),
3092 ),
3093 ),
3094 })
3095 }
3096 }
3097 }
3098 }
3099 #[automatically_derived]
3100 impl alloy_sol_types::private::IntoLogData for AccessControlUpgradeableEvents {
3101 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3102 match self {
3103 Self::Initialized(inner) => {
3104 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3105 }
3106 Self::RoleAdminChanged(inner) => {
3107 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3108 }
3109 Self::RoleGranted(inner) => {
3110 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3111 }
3112 Self::RoleRevoked(inner) => {
3113 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3114 }
3115 }
3116 }
3117 fn into_log_data(self) -> alloy_sol_types::private::LogData {
3118 match self {
3119 Self::Initialized(inner) => {
3120 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3121 }
3122 Self::RoleAdminChanged(inner) => {
3123 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3124 }
3125 Self::RoleGranted(inner) => {
3126 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3127 }
3128 Self::RoleRevoked(inner) => {
3129 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3130 }
3131 }
3132 }
3133 }
3134 #[automatically_derived]
3135 impl AccessControlUpgradeableEvents {
3136 #[inline]
3142 pub fn initialized(version: u64) -> Self {
3143 Self::Initialized(Initialized { version: version })
3144 }
3145 #[inline]
3151 pub fn role_admin_changed(
3152 role: alloy::sol_types::private::FixedBytes<32>,
3153 previous_admin_role: alloy::sol_types::private::FixedBytes<32>,
3154 new_admin_role: alloy::sol_types::private::FixedBytes<32>,
3155 ) -> Self {
3156 Self::RoleAdminChanged(RoleAdminChanged {
3157 role: role,
3158 previousAdminRole: previous_admin_role,
3159 newAdminRole: new_admin_role,
3160 })
3161 }
3162 #[inline]
3168 pub fn role_granted(
3169 role: alloy::sol_types::private::FixedBytes<32>,
3170 account: alloy::sol_types::private::Address,
3171 sender: alloy::sol_types::private::Address,
3172 ) -> Self {
3173 Self::RoleGranted(RoleGranted {
3174 role: role,
3175 account: account,
3176 sender: sender,
3177 })
3178 }
3179 #[inline]
3185 pub fn role_revoked(
3186 role: alloy::sol_types::private::FixedBytes<32>,
3187 account: alloy::sol_types::private::Address,
3188 sender: alloy::sol_types::private::Address,
3189 ) -> Self {
3190 Self::RoleRevoked(RoleRevoked {
3191 role: role,
3192 account: account,
3193 sender: sender,
3194 })
3195 }
3196 }
3197 use alloy::contract as alloy_contract;
3198 #[inline]
3202 pub const fn new<
3203 P: alloy_contract::private::Provider<N>,
3204 N: alloy_contract::private::Network,
3205 >(
3206 address: alloy_sol_types::private::Address,
3207 __provider: P,
3208 ) -> AccessControlUpgradeableInstance<P, N> {
3209 AccessControlUpgradeableInstance::<P, N>::new(address, __provider)
3210 }
3211 #[inline]
3217 pub fn deploy<
3218 P: alloy_contract::private::Provider<N>,
3219 N: alloy_contract::private::Network,
3220 >(
3221 __provider: P,
3222 ) -> impl ::core::future::Future<
3223 Output = alloy_contract::Result<AccessControlUpgradeableInstance<P, N>>,
3224 > {
3225 AccessControlUpgradeableInstance::<P, N>::deploy(__provider)
3226 }
3227 #[inline]
3233 pub fn deploy_builder<
3234 P: alloy_contract::private::Provider<N>,
3235 N: alloy_contract::private::Network,
3236 >(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
3237 AccessControlUpgradeableInstance::<P, N>::deploy_builder(__provider)
3238 }
3239 #[derive(Clone)]
3251 pub struct AccessControlUpgradeableInstance<
3252 P,
3253 N = alloy_contract::private::Ethereum,
3254 > {
3255 address: alloy_sol_types::private::Address,
3256 provider: P,
3257 _network: ::core::marker::PhantomData<N>,
3258 }
3259 #[automatically_derived]
3260 impl<P, N> ::core::fmt::Debug for AccessControlUpgradeableInstance<P, N> {
3261 #[inline]
3262 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3263 f.debug_tuple("AccessControlUpgradeableInstance")
3264 .field(&self.address)
3265 .finish()
3266 }
3267 }
3268 impl<
3270 P: alloy_contract::private::Provider<N>,
3271 N: alloy_contract::private::Network,
3272 > AccessControlUpgradeableInstance<P, N> {
3273 #[inline]
3277 pub const fn new(
3278 address: alloy_sol_types::private::Address,
3279 __provider: P,
3280 ) -> Self {
3281 Self {
3282 address,
3283 provider: __provider,
3284 _network: ::core::marker::PhantomData,
3285 }
3286 }
3287 #[inline]
3293 pub async fn deploy(
3294 __provider: P,
3295 ) -> alloy_contract::Result<AccessControlUpgradeableInstance<P, N>> {
3296 let call_builder = Self::deploy_builder(__provider);
3297 let contract_address = call_builder.deploy().await?;
3298 Ok(Self::new(contract_address, call_builder.provider))
3299 }
3300 #[inline]
3306 pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
3307 alloy_contract::RawCallBuilder::new_raw_deploy(
3308 __provider,
3309 ::core::clone::Clone::clone(&BYTECODE),
3310 )
3311 }
3312 #[inline]
3314 pub const fn address(&self) -> &alloy_sol_types::private::Address {
3315 &self.address
3316 }
3317 #[inline]
3319 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3320 self.address = address;
3321 }
3322 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3324 self.set_address(address);
3325 self
3326 }
3327 #[inline]
3329 pub const fn provider(&self) -> &P {
3330 &self.provider
3331 }
3332 }
3333 impl<P: ::core::clone::Clone, N> AccessControlUpgradeableInstance<&P, N> {
3334 #[inline]
3336 pub fn with_cloned_provider(self) -> AccessControlUpgradeableInstance<P, N> {
3337 AccessControlUpgradeableInstance {
3338 address: self.address,
3339 provider: ::core::clone::Clone::clone(&self.provider),
3340 _network: ::core::marker::PhantomData,
3341 }
3342 }
3343 }
3344 impl<
3346 P: alloy_contract::private::Provider<N>,
3347 N: alloy_contract::private::Network,
3348 > AccessControlUpgradeableInstance<P, N> {
3349 pub fn call_builder<C: alloy_sol_types::SolCall>(
3354 &self,
3355 call: &C,
3356 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
3357 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3358 }
3359 pub fn DEFAULT_ADMIN_ROLE(
3361 &self,
3362 ) -> alloy_contract::SolCallBuilder<&P, DEFAULT_ADMIN_ROLECall, N> {
3363 self.call_builder(&DEFAULT_ADMIN_ROLECall)
3364 }
3365 pub fn getRoleAdmin(
3367 &self,
3368 role: alloy::sol_types::private::FixedBytes<32>,
3369 ) -> alloy_contract::SolCallBuilder<&P, getRoleAdminCall, N> {
3370 self.call_builder(&getRoleAdminCall { role })
3371 }
3372 pub fn grantRole(
3374 &self,
3375 role: alloy::sol_types::private::FixedBytes<32>,
3376 account: alloy::sol_types::private::Address,
3377 ) -> alloy_contract::SolCallBuilder<&P, grantRoleCall, N> {
3378 self.call_builder(&grantRoleCall { role, account })
3379 }
3380 pub fn hasRole(
3382 &self,
3383 role: alloy::sol_types::private::FixedBytes<32>,
3384 account: alloy::sol_types::private::Address,
3385 ) -> alloy_contract::SolCallBuilder<&P, hasRoleCall, N> {
3386 self.call_builder(&hasRoleCall { role, account })
3387 }
3388 pub fn renounceRole(
3390 &self,
3391 role: alloy::sol_types::private::FixedBytes<32>,
3392 callerConfirmation: alloy::sol_types::private::Address,
3393 ) -> alloy_contract::SolCallBuilder<&P, renounceRoleCall, N> {
3394 self.call_builder(
3395 &renounceRoleCall {
3396 role,
3397 callerConfirmation,
3398 },
3399 )
3400 }
3401 pub fn revokeRole(
3403 &self,
3404 role: alloy::sol_types::private::FixedBytes<32>,
3405 account: alloy::sol_types::private::Address,
3406 ) -> alloy_contract::SolCallBuilder<&P, revokeRoleCall, N> {
3407 self.call_builder(&revokeRoleCall { role, account })
3408 }
3409 pub fn supportsInterface(
3411 &self,
3412 interfaceId: alloy::sol_types::private::FixedBytes<4>,
3413 ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
3414 self.call_builder(
3415 &supportsInterfaceCall {
3416 interfaceId,
3417 },
3418 )
3419 }
3420 }
3421 impl<
3423 P: alloy_contract::private::Provider<N>,
3424 N: alloy_contract::private::Network,
3425 > AccessControlUpgradeableInstance<P, N> {
3426 pub fn event_filter<E: alloy_sol_types::SolEvent>(
3431 &self,
3432 ) -> alloy_contract::Event<&P, E, N> {
3433 alloy_contract::Event::new_sol(&self.provider, &self.address)
3434 }
3435 pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
3437 self.event_filter::<Initialized>()
3438 }
3439 pub fn RoleAdminChanged_filter(
3441 &self,
3442 ) -> alloy_contract::Event<&P, RoleAdminChanged, N> {
3443 self.event_filter::<RoleAdminChanged>()
3444 }
3445 pub fn RoleGranted_filter(&self) -> alloy_contract::Event<&P, RoleGranted, N> {
3447 self.event_filter::<RoleGranted>()
3448 }
3449 pub fn RoleRevoked_filter(&self) -> alloy_contract::Event<&P, RoleRevoked, N> {
3451 self.event_filter::<RoleRevoked>()
3452 }
3453 }
3454}