1#[allow(
362 non_camel_case_types,
363 non_snake_case,
364 clippy::pub_underscore_fields,
365 clippy::style,
366 clippy::empty_structs_with_brackets
367)]
368pub mod IERC721Metadata {
369 use super::*;
370 use alloy::sol_types as alloy_sol_types;
371 #[rustfmt::skip]
377 #[allow(clippy::all)]
378 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
379 b"",
380 );
381 #[rustfmt::skip]
387 #[allow(clippy::all)]
388 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
389 b"",
390 );
391 #[allow(
396 non_camel_case_types,
397 non_snake_case,
398 clippy::pub_underscore_fields,
399 clippy::style
400 )]
401 #[derive(Clone)]
402 pub struct Approval {
403 #[allow(missing_docs)]
404 pub _owner: alloy::sol_types::private::Address,
405 #[allow(missing_docs)]
406 pub _approved: alloy::sol_types::private::Address,
407 #[allow(missing_docs)]
408 pub _tokenId: alloy::sol_types::private::primitives::aliases::U256,
409 }
410 #[allow(
411 non_camel_case_types,
412 non_snake_case,
413 clippy::pub_underscore_fields,
414 clippy::style
415 )]
416 const _: () = {
417 use alloy::sol_types as alloy_sol_types;
418 #[automatically_derived]
419 impl alloy_sol_types::SolEvent for Approval {
420 type DataTuple<'a> = ();
421 type DataToken<'a> = <Self::DataTuple<
422 'a,
423 > as alloy_sol_types::SolType>::Token<'a>;
424 type TopicList = (
425 alloy_sol_types::sol_data::FixedBytes<32>,
426 alloy::sol_types::sol_data::Address,
427 alloy::sol_types::sol_data::Address,
428 alloy::sol_types::sol_data::Uint<256>,
429 );
430 const SIGNATURE: &'static str = "Approval(address,address,uint256)";
431 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
432 140u8,
433 91u8,
434 225u8,
435 229u8,
436 235u8,
437 236u8,
438 125u8,
439 91u8,
440 209u8,
441 79u8,
442 113u8,
443 66u8,
444 125u8,
445 30u8,
446 132u8,
447 243u8,
448 221u8,
449 3u8,
450 20u8,
451 192u8,
452 247u8,
453 178u8,
454 41u8,
455 30u8,
456 91u8,
457 32u8,
458 10u8,
459 200u8,
460 199u8,
461 195u8,
462 185u8,
463 37u8,
464 ]);
465 const ANONYMOUS: bool = false;
466 #[allow(unused_variables)]
467 #[inline]
468 fn new(
469 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
470 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
471 ) -> Self {
472 Self {
473 _owner: topics.1,
474 _approved: topics.2,
475 _tokenId: topics.3,
476 }
477 }
478 #[inline]
479 fn check_signature(
480 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
481 ) -> alloy_sol_types::Result<()> {
482 if topics.0 != Self::SIGNATURE_HASH {
483 return Err(
484 alloy_sol_types::Error::invalid_event_signature_hash(
485 Self::SIGNATURE,
486 topics.0,
487 Self::SIGNATURE_HASH,
488 ),
489 );
490 }
491 Ok(())
492 }
493 #[inline]
494 fn tokenize_body(&self) -> Self::DataToken<'_> {
495 ()
496 }
497 #[inline]
498 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
499 (
500 Self::SIGNATURE_HASH.into(),
501 self._owner.clone(),
502 self._approved.clone(),
503 self._tokenId.clone(),
504 )
505 }
506 #[inline]
507 fn encode_topics_raw(
508 &self,
509 out: &mut [alloy_sol_types::abi::token::WordToken],
510 ) -> alloy_sol_types::Result<()> {
511 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
512 return Err(alloy_sol_types::Error::Overrun);
513 }
514 out[0usize] = alloy_sol_types::abi::token::WordToken(
515 Self::SIGNATURE_HASH,
516 );
517 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
518 &self._owner,
519 );
520 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
521 &self._approved,
522 );
523 out[3usize] = <alloy::sol_types::sol_data::Uint<
524 256,
525 > as alloy_sol_types::EventTopic>::encode_topic(&self._tokenId);
526 Ok(())
527 }
528 }
529 #[automatically_derived]
530 impl alloy_sol_types::private::IntoLogData for Approval {
531 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
532 From::from(self)
533 }
534 fn into_log_data(self) -> alloy_sol_types::private::LogData {
535 From::from(&self)
536 }
537 }
538 #[automatically_derived]
539 impl From<&Approval> for alloy_sol_types::private::LogData {
540 #[inline]
541 fn from(this: &Approval) -> alloy_sol_types::private::LogData {
542 alloy_sol_types::SolEvent::encode_log_data(this)
543 }
544 }
545 };
546 #[allow(
551 non_camel_case_types,
552 non_snake_case,
553 clippy::pub_underscore_fields,
554 clippy::style
555 )]
556 #[derive(Clone)]
557 pub struct ApprovalForAll {
558 #[allow(missing_docs)]
559 pub _owner: alloy::sol_types::private::Address,
560 #[allow(missing_docs)]
561 pub _operator: alloy::sol_types::private::Address,
562 #[allow(missing_docs)]
563 pub _approved: bool,
564 }
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 #[automatically_derived]
574 impl alloy_sol_types::SolEvent for ApprovalForAll {
575 type DataTuple<'a> = (alloy::sol_types::sol_data::Bool,);
576 type DataToken<'a> = <Self::DataTuple<
577 'a,
578 > as alloy_sol_types::SolType>::Token<'a>;
579 type TopicList = (
580 alloy_sol_types::sol_data::FixedBytes<32>,
581 alloy::sol_types::sol_data::Address,
582 alloy::sol_types::sol_data::Address,
583 );
584 const SIGNATURE: &'static str = "ApprovalForAll(address,address,bool)";
585 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
586 23u8,
587 48u8,
588 126u8,
589 171u8,
590 57u8,
591 171u8,
592 97u8,
593 7u8,
594 232u8,
595 137u8,
596 152u8,
597 69u8,
598 173u8,
599 61u8,
600 89u8,
601 189u8,
602 150u8,
603 83u8,
604 242u8,
605 0u8,
606 242u8,
607 32u8,
608 146u8,
609 4u8,
610 137u8,
611 202u8,
612 43u8,
613 89u8,
614 55u8,
615 105u8,
616 108u8,
617 49u8,
618 ]);
619 const ANONYMOUS: bool = false;
620 #[allow(unused_variables)]
621 #[inline]
622 fn new(
623 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
624 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
625 ) -> Self {
626 Self {
627 _owner: topics.1,
628 _operator: topics.2,
629 _approved: data.0,
630 }
631 }
632 #[inline]
633 fn check_signature(
634 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
635 ) -> alloy_sol_types::Result<()> {
636 if topics.0 != Self::SIGNATURE_HASH {
637 return Err(
638 alloy_sol_types::Error::invalid_event_signature_hash(
639 Self::SIGNATURE,
640 topics.0,
641 Self::SIGNATURE_HASH,
642 ),
643 );
644 }
645 Ok(())
646 }
647 #[inline]
648 fn tokenize_body(&self) -> Self::DataToken<'_> {
649 (
650 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
651 &self._approved,
652 ),
653 )
654 }
655 #[inline]
656 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
657 (
658 Self::SIGNATURE_HASH.into(),
659 self._owner.clone(),
660 self._operator.clone(),
661 )
662 }
663 #[inline]
664 fn encode_topics_raw(
665 &self,
666 out: &mut [alloy_sol_types::abi::token::WordToken],
667 ) -> alloy_sol_types::Result<()> {
668 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
669 return Err(alloy_sol_types::Error::Overrun);
670 }
671 out[0usize] = alloy_sol_types::abi::token::WordToken(
672 Self::SIGNATURE_HASH,
673 );
674 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
675 &self._owner,
676 );
677 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
678 &self._operator,
679 );
680 Ok(())
681 }
682 }
683 #[automatically_derived]
684 impl alloy_sol_types::private::IntoLogData for ApprovalForAll {
685 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
686 From::from(self)
687 }
688 fn into_log_data(self) -> alloy_sol_types::private::LogData {
689 From::from(&self)
690 }
691 }
692 #[automatically_derived]
693 impl From<&ApprovalForAll> for alloy_sol_types::private::LogData {
694 #[inline]
695 fn from(this: &ApprovalForAll) -> alloy_sol_types::private::LogData {
696 alloy_sol_types::SolEvent::encode_log_data(this)
697 }
698 }
699 };
700 #[allow(
705 non_camel_case_types,
706 non_snake_case,
707 clippy::pub_underscore_fields,
708 clippy::style
709 )]
710 #[derive(Clone)]
711 pub struct Transfer {
712 #[allow(missing_docs)]
713 pub _from: alloy::sol_types::private::Address,
714 #[allow(missing_docs)]
715 pub _to: alloy::sol_types::private::Address,
716 #[allow(missing_docs)]
717 pub _tokenId: alloy::sol_types::private::primitives::aliases::U256,
718 }
719 #[allow(
720 non_camel_case_types,
721 non_snake_case,
722 clippy::pub_underscore_fields,
723 clippy::style
724 )]
725 const _: () = {
726 use alloy::sol_types as alloy_sol_types;
727 #[automatically_derived]
728 impl alloy_sol_types::SolEvent for Transfer {
729 type DataTuple<'a> = ();
730 type DataToken<'a> = <Self::DataTuple<
731 'a,
732 > as alloy_sol_types::SolType>::Token<'a>;
733 type TopicList = (
734 alloy_sol_types::sol_data::FixedBytes<32>,
735 alloy::sol_types::sol_data::Address,
736 alloy::sol_types::sol_data::Address,
737 alloy::sol_types::sol_data::Uint<256>,
738 );
739 const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
740 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
741 221u8,
742 242u8,
743 82u8,
744 173u8,
745 27u8,
746 226u8,
747 200u8,
748 155u8,
749 105u8,
750 194u8,
751 176u8,
752 104u8,
753 252u8,
754 55u8,
755 141u8,
756 170u8,
757 149u8,
758 43u8,
759 167u8,
760 241u8,
761 99u8,
762 196u8,
763 161u8,
764 22u8,
765 40u8,
766 245u8,
767 90u8,
768 77u8,
769 245u8,
770 35u8,
771 179u8,
772 239u8,
773 ]);
774 const ANONYMOUS: bool = false;
775 #[allow(unused_variables)]
776 #[inline]
777 fn new(
778 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
779 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
780 ) -> Self {
781 Self {
782 _from: topics.1,
783 _to: topics.2,
784 _tokenId: topics.3,
785 }
786 }
787 #[inline]
788 fn check_signature(
789 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
790 ) -> alloy_sol_types::Result<()> {
791 if topics.0 != Self::SIGNATURE_HASH {
792 return Err(
793 alloy_sol_types::Error::invalid_event_signature_hash(
794 Self::SIGNATURE,
795 topics.0,
796 Self::SIGNATURE_HASH,
797 ),
798 );
799 }
800 Ok(())
801 }
802 #[inline]
803 fn tokenize_body(&self) -> Self::DataToken<'_> {
804 ()
805 }
806 #[inline]
807 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
808 (
809 Self::SIGNATURE_HASH.into(),
810 self._from.clone(),
811 self._to.clone(),
812 self._tokenId.clone(),
813 )
814 }
815 #[inline]
816 fn encode_topics_raw(
817 &self,
818 out: &mut [alloy_sol_types::abi::token::WordToken],
819 ) -> alloy_sol_types::Result<()> {
820 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
821 return Err(alloy_sol_types::Error::Overrun);
822 }
823 out[0usize] = alloy_sol_types::abi::token::WordToken(
824 Self::SIGNATURE_HASH,
825 );
826 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
827 &self._from,
828 );
829 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
830 &self._to,
831 );
832 out[3usize] = <alloy::sol_types::sol_data::Uint<
833 256,
834 > as alloy_sol_types::EventTopic>::encode_topic(&self._tokenId);
835 Ok(())
836 }
837 }
838 #[automatically_derived]
839 impl alloy_sol_types::private::IntoLogData for Transfer {
840 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
841 From::from(self)
842 }
843 fn into_log_data(self) -> alloy_sol_types::private::LogData {
844 From::from(&self)
845 }
846 }
847 #[automatically_derived]
848 impl From<&Transfer> for alloy_sol_types::private::LogData {
849 #[inline]
850 fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
851 alloy_sol_types::SolEvent::encode_log_data(this)
852 }
853 }
854 };
855 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
860 #[derive(Clone)]
861 pub struct approveCall {
862 #[allow(missing_docs)]
863 pub _approved: alloy::sol_types::private::Address,
864 #[allow(missing_docs)]
865 pub _tokenId: alloy::sol_types::private::primitives::aliases::U256,
866 }
867 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
869 #[derive(Clone)]
870 pub struct approveReturn {}
871 #[allow(
872 non_camel_case_types,
873 non_snake_case,
874 clippy::pub_underscore_fields,
875 clippy::style
876 )]
877 const _: () = {
878 use alloy::sol_types as alloy_sol_types;
879 {
880 #[doc(hidden)]
881 type UnderlyingSolTuple<'a> = (
882 alloy::sol_types::sol_data::Address,
883 alloy::sol_types::sol_data::Uint<256>,
884 );
885 #[doc(hidden)]
886 type UnderlyingRustTuple<'a> = (
887 alloy::sol_types::private::Address,
888 alloy::sol_types::private::primitives::aliases::U256,
889 );
890 #[cfg(test)]
891 #[allow(dead_code, unreachable_patterns)]
892 fn _type_assertion(
893 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
894 ) {
895 match _t {
896 alloy_sol_types::private::AssertTypeEq::<
897 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
898 >(_) => {}
899 }
900 }
901 #[automatically_derived]
902 #[doc(hidden)]
903 impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
904 fn from(value: approveCall) -> Self {
905 (value._approved, value._tokenId)
906 }
907 }
908 #[automatically_derived]
909 #[doc(hidden)]
910 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
911 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
912 Self {
913 _approved: tuple.0,
914 _tokenId: tuple.1,
915 }
916 }
917 }
918 }
919 {
920 #[doc(hidden)]
921 type UnderlyingSolTuple<'a> = ();
922 #[doc(hidden)]
923 type UnderlyingRustTuple<'a> = ();
924 #[cfg(test)]
925 #[allow(dead_code, unreachable_patterns)]
926 fn _type_assertion(
927 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
928 ) {
929 match _t {
930 alloy_sol_types::private::AssertTypeEq::<
931 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
932 >(_) => {}
933 }
934 }
935 #[automatically_derived]
936 #[doc(hidden)]
937 impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
938 fn from(value: approveReturn) -> Self {
939 ()
940 }
941 }
942 #[automatically_derived]
943 #[doc(hidden)]
944 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
945 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
946 Self {}
947 }
948 }
949 }
950 #[automatically_derived]
951 impl alloy_sol_types::SolCall for approveCall {
952 type Parameters<'a> = (
953 alloy::sol_types::sol_data::Address,
954 alloy::sol_types::sol_data::Uint<256>,
955 );
956 type Token<'a> = <Self::Parameters<
957 'a,
958 > as alloy_sol_types::SolType>::Token<'a>;
959 type Return = approveReturn;
960 type ReturnTuple<'a> = ();
961 type ReturnToken<'a> = <Self::ReturnTuple<
962 'a,
963 > as alloy_sol_types::SolType>::Token<'a>;
964 const SIGNATURE: &'static str = "approve(address,uint256)";
965 const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
966 #[inline]
967 fn new<'a>(
968 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
969 ) -> Self {
970 tuple.into()
971 }
972 #[inline]
973 fn tokenize(&self) -> Self::Token<'_> {
974 (
975 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
976 &self._approved,
977 ),
978 <alloy::sol_types::sol_data::Uint<
979 256,
980 > as alloy_sol_types::SolType>::tokenize(&self._tokenId),
981 )
982 }
983 #[inline]
984 fn abi_decode_returns(
985 data: &[u8],
986 validate: bool,
987 ) -> alloy_sol_types::Result<Self::Return> {
988 <Self::ReturnTuple<
989 '_,
990 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
991 .map(Into::into)
992 }
993 }
994 };
995 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1000 #[derive(Clone)]
1001 pub struct balanceOfCall {
1002 #[allow(missing_docs)]
1003 pub _owner: alloy::sol_types::private::Address,
1004 }
1005 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1007 #[derive(Clone)]
1008 pub struct balanceOfReturn {
1009 #[allow(missing_docs)]
1010 pub _0: alloy::sol_types::private::primitives::aliases::U256,
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 {
1021 #[doc(hidden)]
1022 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1023 #[doc(hidden)]
1024 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1025 #[cfg(test)]
1026 #[allow(dead_code, unreachable_patterns)]
1027 fn _type_assertion(
1028 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1029 ) {
1030 match _t {
1031 alloy_sol_types::private::AssertTypeEq::<
1032 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1033 >(_) => {}
1034 }
1035 }
1036 #[automatically_derived]
1037 #[doc(hidden)]
1038 impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
1039 fn from(value: balanceOfCall) -> Self {
1040 (value._owner,)
1041 }
1042 }
1043 #[automatically_derived]
1044 #[doc(hidden)]
1045 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
1046 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1047 Self { _owner: tuple.0 }
1048 }
1049 }
1050 }
1051 {
1052 #[doc(hidden)]
1053 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1054 #[doc(hidden)]
1055 type UnderlyingRustTuple<'a> = (
1056 alloy::sol_types::private::primitives::aliases::U256,
1057 );
1058 #[cfg(test)]
1059 #[allow(dead_code, unreachable_patterns)]
1060 fn _type_assertion(
1061 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1062 ) {
1063 match _t {
1064 alloy_sol_types::private::AssertTypeEq::<
1065 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1066 >(_) => {}
1067 }
1068 }
1069 #[automatically_derived]
1070 #[doc(hidden)]
1071 impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
1072 fn from(value: balanceOfReturn) -> Self {
1073 (value._0,)
1074 }
1075 }
1076 #[automatically_derived]
1077 #[doc(hidden)]
1078 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
1079 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1080 Self { _0: tuple.0 }
1081 }
1082 }
1083 }
1084 #[automatically_derived]
1085 impl alloy_sol_types::SolCall for balanceOfCall {
1086 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1087 type Token<'a> = <Self::Parameters<
1088 'a,
1089 > as alloy_sol_types::SolType>::Token<'a>;
1090 type Return = balanceOfReturn;
1091 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1092 type ReturnToken<'a> = <Self::ReturnTuple<
1093 'a,
1094 > as alloy_sol_types::SolType>::Token<'a>;
1095 const SIGNATURE: &'static str = "balanceOf(address)";
1096 const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
1097 #[inline]
1098 fn new<'a>(
1099 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1100 ) -> Self {
1101 tuple.into()
1102 }
1103 #[inline]
1104 fn tokenize(&self) -> Self::Token<'_> {
1105 (
1106 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1107 &self._owner,
1108 ),
1109 )
1110 }
1111 #[inline]
1112 fn abi_decode_returns(
1113 data: &[u8],
1114 validate: bool,
1115 ) -> alloy_sol_types::Result<Self::Return> {
1116 <Self::ReturnTuple<
1117 '_,
1118 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1119 .map(Into::into)
1120 }
1121 }
1122 };
1123 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1128 #[derive(Clone)]
1129 pub struct getApprovedCall {
1130 #[allow(missing_docs)]
1131 pub _tokenId: alloy::sol_types::private::primitives::aliases::U256,
1132 }
1133 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1135 #[derive(Clone)]
1136 pub struct getApprovedReturn {
1137 #[allow(missing_docs)]
1138 pub _0: alloy::sol_types::private::Address,
1139 }
1140 #[allow(
1141 non_camel_case_types,
1142 non_snake_case,
1143 clippy::pub_underscore_fields,
1144 clippy::style
1145 )]
1146 const _: () = {
1147 use alloy::sol_types as alloy_sol_types;
1148 {
1149 #[doc(hidden)]
1150 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1151 #[doc(hidden)]
1152 type UnderlyingRustTuple<'a> = (
1153 alloy::sol_types::private::primitives::aliases::U256,
1154 );
1155 #[cfg(test)]
1156 #[allow(dead_code, unreachable_patterns)]
1157 fn _type_assertion(
1158 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1159 ) {
1160 match _t {
1161 alloy_sol_types::private::AssertTypeEq::<
1162 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1163 >(_) => {}
1164 }
1165 }
1166 #[automatically_derived]
1167 #[doc(hidden)]
1168 impl ::core::convert::From<getApprovedCall> for UnderlyingRustTuple<'_> {
1169 fn from(value: getApprovedCall) -> Self {
1170 (value._tokenId,)
1171 }
1172 }
1173 #[automatically_derived]
1174 #[doc(hidden)]
1175 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getApprovedCall {
1176 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1177 Self { _tokenId: tuple.0 }
1178 }
1179 }
1180 }
1181 {
1182 #[doc(hidden)]
1183 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1184 #[doc(hidden)]
1185 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1186 #[cfg(test)]
1187 #[allow(dead_code, unreachable_patterns)]
1188 fn _type_assertion(
1189 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1190 ) {
1191 match _t {
1192 alloy_sol_types::private::AssertTypeEq::<
1193 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1194 >(_) => {}
1195 }
1196 }
1197 #[automatically_derived]
1198 #[doc(hidden)]
1199 impl ::core::convert::From<getApprovedReturn> for UnderlyingRustTuple<'_> {
1200 fn from(value: getApprovedReturn) -> Self {
1201 (value._0,)
1202 }
1203 }
1204 #[automatically_derived]
1205 #[doc(hidden)]
1206 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getApprovedReturn {
1207 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1208 Self { _0: tuple.0 }
1209 }
1210 }
1211 }
1212 #[automatically_derived]
1213 impl alloy_sol_types::SolCall for getApprovedCall {
1214 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1215 type Token<'a> = <Self::Parameters<
1216 'a,
1217 > as alloy_sol_types::SolType>::Token<'a>;
1218 type Return = getApprovedReturn;
1219 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1220 type ReturnToken<'a> = <Self::ReturnTuple<
1221 'a,
1222 > as alloy_sol_types::SolType>::Token<'a>;
1223 const SIGNATURE: &'static str = "getApproved(uint256)";
1224 const SELECTOR: [u8; 4] = [8u8, 24u8, 18u8, 252u8];
1225 #[inline]
1226 fn new<'a>(
1227 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1228 ) -> Self {
1229 tuple.into()
1230 }
1231 #[inline]
1232 fn tokenize(&self) -> Self::Token<'_> {
1233 (
1234 <alloy::sol_types::sol_data::Uint<
1235 256,
1236 > as alloy_sol_types::SolType>::tokenize(&self._tokenId),
1237 )
1238 }
1239 #[inline]
1240 fn abi_decode_returns(
1241 data: &[u8],
1242 validate: bool,
1243 ) -> alloy_sol_types::Result<Self::Return> {
1244 <Self::ReturnTuple<
1245 '_,
1246 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1247 .map(Into::into)
1248 }
1249 }
1250 };
1251 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1256 #[derive(Clone)]
1257 pub struct isApprovedForAllCall {
1258 #[allow(missing_docs)]
1259 pub _owner: alloy::sol_types::private::Address,
1260 #[allow(missing_docs)]
1261 pub _operator: alloy::sol_types::private::Address,
1262 }
1263 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1265 #[derive(Clone)]
1266 pub struct isApprovedForAllReturn {
1267 #[allow(missing_docs)]
1268 pub _0: bool,
1269 }
1270 #[allow(
1271 non_camel_case_types,
1272 non_snake_case,
1273 clippy::pub_underscore_fields,
1274 clippy::style
1275 )]
1276 const _: () = {
1277 use alloy::sol_types as alloy_sol_types;
1278 {
1279 #[doc(hidden)]
1280 type UnderlyingSolTuple<'a> = (
1281 alloy::sol_types::sol_data::Address,
1282 alloy::sol_types::sol_data::Address,
1283 );
1284 #[doc(hidden)]
1285 type UnderlyingRustTuple<'a> = (
1286 alloy::sol_types::private::Address,
1287 alloy::sol_types::private::Address,
1288 );
1289 #[cfg(test)]
1290 #[allow(dead_code, unreachable_patterns)]
1291 fn _type_assertion(
1292 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1293 ) {
1294 match _t {
1295 alloy_sol_types::private::AssertTypeEq::<
1296 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1297 >(_) => {}
1298 }
1299 }
1300 #[automatically_derived]
1301 #[doc(hidden)]
1302 impl ::core::convert::From<isApprovedForAllCall>
1303 for UnderlyingRustTuple<'_> {
1304 fn from(value: isApprovedForAllCall) -> Self {
1305 (value._owner, value._operator)
1306 }
1307 }
1308 #[automatically_derived]
1309 #[doc(hidden)]
1310 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1311 for isApprovedForAllCall {
1312 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1313 Self {
1314 _owner: tuple.0,
1315 _operator: tuple.1,
1316 }
1317 }
1318 }
1319 }
1320 {
1321 #[doc(hidden)]
1322 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1323 #[doc(hidden)]
1324 type UnderlyingRustTuple<'a> = (bool,);
1325 #[cfg(test)]
1326 #[allow(dead_code, unreachable_patterns)]
1327 fn _type_assertion(
1328 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1329 ) {
1330 match _t {
1331 alloy_sol_types::private::AssertTypeEq::<
1332 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1333 >(_) => {}
1334 }
1335 }
1336 #[automatically_derived]
1337 #[doc(hidden)]
1338 impl ::core::convert::From<isApprovedForAllReturn>
1339 for UnderlyingRustTuple<'_> {
1340 fn from(value: isApprovedForAllReturn) -> Self {
1341 (value._0,)
1342 }
1343 }
1344 #[automatically_derived]
1345 #[doc(hidden)]
1346 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1347 for isApprovedForAllReturn {
1348 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1349 Self { _0: tuple.0 }
1350 }
1351 }
1352 }
1353 #[automatically_derived]
1354 impl alloy_sol_types::SolCall for isApprovedForAllCall {
1355 type Parameters<'a> = (
1356 alloy::sol_types::sol_data::Address,
1357 alloy::sol_types::sol_data::Address,
1358 );
1359 type Token<'a> = <Self::Parameters<
1360 'a,
1361 > as alloy_sol_types::SolType>::Token<'a>;
1362 type Return = isApprovedForAllReturn;
1363 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1364 type ReturnToken<'a> = <Self::ReturnTuple<
1365 'a,
1366 > as alloy_sol_types::SolType>::Token<'a>;
1367 const SIGNATURE: &'static str = "isApprovedForAll(address,address)";
1368 const SELECTOR: [u8; 4] = [233u8, 133u8, 233u8, 197u8];
1369 #[inline]
1370 fn new<'a>(
1371 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1372 ) -> Self {
1373 tuple.into()
1374 }
1375 #[inline]
1376 fn tokenize(&self) -> Self::Token<'_> {
1377 (
1378 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1379 &self._owner,
1380 ),
1381 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1382 &self._operator,
1383 ),
1384 )
1385 }
1386 #[inline]
1387 fn abi_decode_returns(
1388 data: &[u8],
1389 validate: bool,
1390 ) -> alloy_sol_types::Result<Self::Return> {
1391 <Self::ReturnTuple<
1392 '_,
1393 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1394 .map(Into::into)
1395 }
1396 }
1397 };
1398 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1403 #[derive(Clone)]
1404 pub struct nameCall {}
1405 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1407 #[derive(Clone)]
1408 pub struct nameReturn {
1409 #[allow(missing_docs)]
1410 pub _name: alloy::sol_types::private::String,
1411 }
1412 #[allow(
1413 non_camel_case_types,
1414 non_snake_case,
1415 clippy::pub_underscore_fields,
1416 clippy::style
1417 )]
1418 const _: () = {
1419 use alloy::sol_types as alloy_sol_types;
1420 {
1421 #[doc(hidden)]
1422 type UnderlyingSolTuple<'a> = ();
1423 #[doc(hidden)]
1424 type UnderlyingRustTuple<'a> = ();
1425 #[cfg(test)]
1426 #[allow(dead_code, unreachable_patterns)]
1427 fn _type_assertion(
1428 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1429 ) {
1430 match _t {
1431 alloy_sol_types::private::AssertTypeEq::<
1432 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1433 >(_) => {}
1434 }
1435 }
1436 #[automatically_derived]
1437 #[doc(hidden)]
1438 impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
1439 fn from(value: nameCall) -> Self {
1440 ()
1441 }
1442 }
1443 #[automatically_derived]
1444 #[doc(hidden)]
1445 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
1446 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1447 Self {}
1448 }
1449 }
1450 }
1451 {
1452 #[doc(hidden)]
1453 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1454 #[doc(hidden)]
1455 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1456 #[cfg(test)]
1457 #[allow(dead_code, unreachable_patterns)]
1458 fn _type_assertion(
1459 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1460 ) {
1461 match _t {
1462 alloy_sol_types::private::AssertTypeEq::<
1463 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1464 >(_) => {}
1465 }
1466 }
1467 #[automatically_derived]
1468 #[doc(hidden)]
1469 impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
1470 fn from(value: nameReturn) -> Self {
1471 (value._name,)
1472 }
1473 }
1474 #[automatically_derived]
1475 #[doc(hidden)]
1476 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
1477 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1478 Self { _name: tuple.0 }
1479 }
1480 }
1481 }
1482 #[automatically_derived]
1483 impl alloy_sol_types::SolCall for nameCall {
1484 type Parameters<'a> = ();
1485 type Token<'a> = <Self::Parameters<
1486 'a,
1487 > as alloy_sol_types::SolType>::Token<'a>;
1488 type Return = nameReturn;
1489 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
1490 type ReturnToken<'a> = <Self::ReturnTuple<
1491 'a,
1492 > as alloy_sol_types::SolType>::Token<'a>;
1493 const SIGNATURE: &'static str = "name()";
1494 const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
1495 #[inline]
1496 fn new<'a>(
1497 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1498 ) -> Self {
1499 tuple.into()
1500 }
1501 #[inline]
1502 fn tokenize(&self) -> Self::Token<'_> {
1503 ()
1504 }
1505 #[inline]
1506 fn abi_decode_returns(
1507 data: &[u8],
1508 validate: bool,
1509 ) -> alloy_sol_types::Result<Self::Return> {
1510 <Self::ReturnTuple<
1511 '_,
1512 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1513 .map(Into::into)
1514 }
1515 }
1516 };
1517 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1522 #[derive(Clone)]
1523 pub struct ownerOfCall {
1524 #[allow(missing_docs)]
1525 pub _tokenId: alloy::sol_types::private::primitives::aliases::U256,
1526 }
1527 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1529 #[derive(Clone)]
1530 pub struct ownerOfReturn {
1531 #[allow(missing_docs)]
1532 pub _0: alloy::sol_types::private::Address,
1533 }
1534 #[allow(
1535 non_camel_case_types,
1536 non_snake_case,
1537 clippy::pub_underscore_fields,
1538 clippy::style
1539 )]
1540 const _: () = {
1541 use alloy::sol_types as alloy_sol_types;
1542 {
1543 #[doc(hidden)]
1544 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1545 #[doc(hidden)]
1546 type UnderlyingRustTuple<'a> = (
1547 alloy::sol_types::private::primitives::aliases::U256,
1548 );
1549 #[cfg(test)]
1550 #[allow(dead_code, unreachable_patterns)]
1551 fn _type_assertion(
1552 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1553 ) {
1554 match _t {
1555 alloy_sol_types::private::AssertTypeEq::<
1556 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1557 >(_) => {}
1558 }
1559 }
1560 #[automatically_derived]
1561 #[doc(hidden)]
1562 impl ::core::convert::From<ownerOfCall> for UnderlyingRustTuple<'_> {
1563 fn from(value: ownerOfCall) -> Self {
1564 (value._tokenId,)
1565 }
1566 }
1567 #[automatically_derived]
1568 #[doc(hidden)]
1569 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerOfCall {
1570 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1571 Self { _tokenId: tuple.0 }
1572 }
1573 }
1574 }
1575 {
1576 #[doc(hidden)]
1577 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1578 #[doc(hidden)]
1579 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1580 #[cfg(test)]
1581 #[allow(dead_code, unreachable_patterns)]
1582 fn _type_assertion(
1583 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1584 ) {
1585 match _t {
1586 alloy_sol_types::private::AssertTypeEq::<
1587 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1588 >(_) => {}
1589 }
1590 }
1591 #[automatically_derived]
1592 #[doc(hidden)]
1593 impl ::core::convert::From<ownerOfReturn> for UnderlyingRustTuple<'_> {
1594 fn from(value: ownerOfReturn) -> Self {
1595 (value._0,)
1596 }
1597 }
1598 #[automatically_derived]
1599 #[doc(hidden)]
1600 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerOfReturn {
1601 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1602 Self { _0: tuple.0 }
1603 }
1604 }
1605 }
1606 #[automatically_derived]
1607 impl alloy_sol_types::SolCall for ownerOfCall {
1608 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1609 type Token<'a> = <Self::Parameters<
1610 'a,
1611 > as alloy_sol_types::SolType>::Token<'a>;
1612 type Return = ownerOfReturn;
1613 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1614 type ReturnToken<'a> = <Self::ReturnTuple<
1615 'a,
1616 > as alloy_sol_types::SolType>::Token<'a>;
1617 const SIGNATURE: &'static str = "ownerOf(uint256)";
1618 const SELECTOR: [u8; 4] = [99u8, 82u8, 33u8, 30u8];
1619 #[inline]
1620 fn new<'a>(
1621 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1622 ) -> Self {
1623 tuple.into()
1624 }
1625 #[inline]
1626 fn tokenize(&self) -> Self::Token<'_> {
1627 (
1628 <alloy::sol_types::sol_data::Uint<
1629 256,
1630 > as alloy_sol_types::SolType>::tokenize(&self._tokenId),
1631 )
1632 }
1633 #[inline]
1634 fn abi_decode_returns(
1635 data: &[u8],
1636 validate: bool,
1637 ) -> alloy_sol_types::Result<Self::Return> {
1638 <Self::ReturnTuple<
1639 '_,
1640 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1641 .map(Into::into)
1642 }
1643 }
1644 };
1645 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1650 #[derive(Clone)]
1651 pub struct safeTransferFrom_0Call {
1652 #[allow(missing_docs)]
1653 pub _from: alloy::sol_types::private::Address,
1654 #[allow(missing_docs)]
1655 pub _to: alloy::sol_types::private::Address,
1656 #[allow(missing_docs)]
1657 pub _tokenId: alloy::sol_types::private::primitives::aliases::U256,
1658 }
1659 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1661 #[derive(Clone)]
1662 pub struct safeTransferFrom_0Return {}
1663 #[allow(
1664 non_camel_case_types,
1665 non_snake_case,
1666 clippy::pub_underscore_fields,
1667 clippy::style
1668 )]
1669 const _: () = {
1670 use alloy::sol_types as alloy_sol_types;
1671 {
1672 #[doc(hidden)]
1673 type UnderlyingSolTuple<'a> = (
1674 alloy::sol_types::sol_data::Address,
1675 alloy::sol_types::sol_data::Address,
1676 alloy::sol_types::sol_data::Uint<256>,
1677 );
1678 #[doc(hidden)]
1679 type UnderlyingRustTuple<'a> = (
1680 alloy::sol_types::private::Address,
1681 alloy::sol_types::private::Address,
1682 alloy::sol_types::private::primitives::aliases::U256,
1683 );
1684 #[cfg(test)]
1685 #[allow(dead_code, unreachable_patterns)]
1686 fn _type_assertion(
1687 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1688 ) {
1689 match _t {
1690 alloy_sol_types::private::AssertTypeEq::<
1691 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1692 >(_) => {}
1693 }
1694 }
1695 #[automatically_derived]
1696 #[doc(hidden)]
1697 impl ::core::convert::From<safeTransferFrom_0Call>
1698 for UnderlyingRustTuple<'_> {
1699 fn from(value: safeTransferFrom_0Call) -> Self {
1700 (value._from, value._to, value._tokenId)
1701 }
1702 }
1703 #[automatically_derived]
1704 #[doc(hidden)]
1705 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1706 for safeTransferFrom_0Call {
1707 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1708 Self {
1709 _from: tuple.0,
1710 _to: tuple.1,
1711 _tokenId: tuple.2,
1712 }
1713 }
1714 }
1715 }
1716 {
1717 #[doc(hidden)]
1718 type UnderlyingSolTuple<'a> = ();
1719 #[doc(hidden)]
1720 type UnderlyingRustTuple<'a> = ();
1721 #[cfg(test)]
1722 #[allow(dead_code, unreachable_patterns)]
1723 fn _type_assertion(
1724 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1725 ) {
1726 match _t {
1727 alloy_sol_types::private::AssertTypeEq::<
1728 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1729 >(_) => {}
1730 }
1731 }
1732 #[automatically_derived]
1733 #[doc(hidden)]
1734 impl ::core::convert::From<safeTransferFrom_0Return>
1735 for UnderlyingRustTuple<'_> {
1736 fn from(value: safeTransferFrom_0Return) -> Self {
1737 ()
1738 }
1739 }
1740 #[automatically_derived]
1741 #[doc(hidden)]
1742 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1743 for safeTransferFrom_0Return {
1744 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1745 Self {}
1746 }
1747 }
1748 }
1749 #[automatically_derived]
1750 impl alloy_sol_types::SolCall for safeTransferFrom_0Call {
1751 type Parameters<'a> = (
1752 alloy::sol_types::sol_data::Address,
1753 alloy::sol_types::sol_data::Address,
1754 alloy::sol_types::sol_data::Uint<256>,
1755 );
1756 type Token<'a> = <Self::Parameters<
1757 'a,
1758 > as alloy_sol_types::SolType>::Token<'a>;
1759 type Return = safeTransferFrom_0Return;
1760 type ReturnTuple<'a> = ();
1761 type ReturnToken<'a> = <Self::ReturnTuple<
1762 'a,
1763 > as alloy_sol_types::SolType>::Token<'a>;
1764 const SIGNATURE: &'static str = "safeTransferFrom(address,address,uint256)";
1765 const SELECTOR: [u8; 4] = [66u8, 132u8, 46u8, 14u8];
1766 #[inline]
1767 fn new<'a>(
1768 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1769 ) -> Self {
1770 tuple.into()
1771 }
1772 #[inline]
1773 fn tokenize(&self) -> Self::Token<'_> {
1774 (
1775 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1776 &self._from,
1777 ),
1778 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1779 &self._to,
1780 ),
1781 <alloy::sol_types::sol_data::Uint<
1782 256,
1783 > as alloy_sol_types::SolType>::tokenize(&self._tokenId),
1784 )
1785 }
1786 #[inline]
1787 fn abi_decode_returns(
1788 data: &[u8],
1789 validate: bool,
1790 ) -> alloy_sol_types::Result<Self::Return> {
1791 <Self::ReturnTuple<
1792 '_,
1793 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1794 .map(Into::into)
1795 }
1796 }
1797 };
1798 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1803 #[derive(Clone)]
1804 pub struct safeTransferFrom_1Call {
1805 #[allow(missing_docs)]
1806 pub _from: alloy::sol_types::private::Address,
1807 #[allow(missing_docs)]
1808 pub _to: alloy::sol_types::private::Address,
1809 #[allow(missing_docs)]
1810 pub _tokenId: alloy::sol_types::private::primitives::aliases::U256,
1811 #[allow(missing_docs)]
1812 pub data: alloy::sol_types::private::Bytes,
1813 }
1814 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1816 #[derive(Clone)]
1817 pub struct safeTransferFrom_1Return {}
1818 #[allow(
1819 non_camel_case_types,
1820 non_snake_case,
1821 clippy::pub_underscore_fields,
1822 clippy::style
1823 )]
1824 const _: () = {
1825 use alloy::sol_types as alloy_sol_types;
1826 {
1827 #[doc(hidden)]
1828 type UnderlyingSolTuple<'a> = (
1829 alloy::sol_types::sol_data::Address,
1830 alloy::sol_types::sol_data::Address,
1831 alloy::sol_types::sol_data::Uint<256>,
1832 alloy::sol_types::sol_data::Bytes,
1833 );
1834 #[doc(hidden)]
1835 type UnderlyingRustTuple<'a> = (
1836 alloy::sol_types::private::Address,
1837 alloy::sol_types::private::Address,
1838 alloy::sol_types::private::primitives::aliases::U256,
1839 alloy::sol_types::private::Bytes,
1840 );
1841 #[cfg(test)]
1842 #[allow(dead_code, unreachable_patterns)]
1843 fn _type_assertion(
1844 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1845 ) {
1846 match _t {
1847 alloy_sol_types::private::AssertTypeEq::<
1848 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1849 >(_) => {}
1850 }
1851 }
1852 #[automatically_derived]
1853 #[doc(hidden)]
1854 impl ::core::convert::From<safeTransferFrom_1Call>
1855 for UnderlyingRustTuple<'_> {
1856 fn from(value: safeTransferFrom_1Call) -> Self {
1857 (value._from, value._to, value._tokenId, value.data)
1858 }
1859 }
1860 #[automatically_derived]
1861 #[doc(hidden)]
1862 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1863 for safeTransferFrom_1Call {
1864 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1865 Self {
1866 _from: tuple.0,
1867 _to: tuple.1,
1868 _tokenId: tuple.2,
1869 data: tuple.3,
1870 }
1871 }
1872 }
1873 }
1874 {
1875 #[doc(hidden)]
1876 type UnderlyingSolTuple<'a> = ();
1877 #[doc(hidden)]
1878 type UnderlyingRustTuple<'a> = ();
1879 #[cfg(test)]
1880 #[allow(dead_code, unreachable_patterns)]
1881 fn _type_assertion(
1882 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1883 ) {
1884 match _t {
1885 alloy_sol_types::private::AssertTypeEq::<
1886 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1887 >(_) => {}
1888 }
1889 }
1890 #[automatically_derived]
1891 #[doc(hidden)]
1892 impl ::core::convert::From<safeTransferFrom_1Return>
1893 for UnderlyingRustTuple<'_> {
1894 fn from(value: safeTransferFrom_1Return) -> Self {
1895 ()
1896 }
1897 }
1898 #[automatically_derived]
1899 #[doc(hidden)]
1900 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1901 for safeTransferFrom_1Return {
1902 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1903 Self {}
1904 }
1905 }
1906 }
1907 #[automatically_derived]
1908 impl alloy_sol_types::SolCall for safeTransferFrom_1Call {
1909 type Parameters<'a> = (
1910 alloy::sol_types::sol_data::Address,
1911 alloy::sol_types::sol_data::Address,
1912 alloy::sol_types::sol_data::Uint<256>,
1913 alloy::sol_types::sol_data::Bytes,
1914 );
1915 type Token<'a> = <Self::Parameters<
1916 'a,
1917 > as alloy_sol_types::SolType>::Token<'a>;
1918 type Return = safeTransferFrom_1Return;
1919 type ReturnTuple<'a> = ();
1920 type ReturnToken<'a> = <Self::ReturnTuple<
1921 'a,
1922 > as alloy_sol_types::SolType>::Token<'a>;
1923 const SIGNATURE: &'static str = "safeTransferFrom(address,address,uint256,bytes)";
1924 const SELECTOR: [u8; 4] = [184u8, 141u8, 79u8, 222u8];
1925 #[inline]
1926 fn new<'a>(
1927 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1928 ) -> Self {
1929 tuple.into()
1930 }
1931 #[inline]
1932 fn tokenize(&self) -> Self::Token<'_> {
1933 (
1934 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1935 &self._from,
1936 ),
1937 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1938 &self._to,
1939 ),
1940 <alloy::sol_types::sol_data::Uint<
1941 256,
1942 > as alloy_sol_types::SolType>::tokenize(&self._tokenId),
1943 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1944 &self.data,
1945 ),
1946 )
1947 }
1948 #[inline]
1949 fn abi_decode_returns(
1950 data: &[u8],
1951 validate: bool,
1952 ) -> alloy_sol_types::Result<Self::Return> {
1953 <Self::ReturnTuple<
1954 '_,
1955 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1956 .map(Into::into)
1957 }
1958 }
1959 };
1960 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1965 #[derive(Clone)]
1966 pub struct setApprovalForAllCall {
1967 #[allow(missing_docs)]
1968 pub _operator: alloy::sol_types::private::Address,
1969 #[allow(missing_docs)]
1970 pub _approved: bool,
1971 }
1972 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1974 #[derive(Clone)]
1975 pub struct setApprovalForAllReturn {}
1976 #[allow(
1977 non_camel_case_types,
1978 non_snake_case,
1979 clippy::pub_underscore_fields,
1980 clippy::style
1981 )]
1982 const _: () = {
1983 use alloy::sol_types as alloy_sol_types;
1984 {
1985 #[doc(hidden)]
1986 type UnderlyingSolTuple<'a> = (
1987 alloy::sol_types::sol_data::Address,
1988 alloy::sol_types::sol_data::Bool,
1989 );
1990 #[doc(hidden)]
1991 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, bool);
1992 #[cfg(test)]
1993 #[allow(dead_code, unreachable_patterns)]
1994 fn _type_assertion(
1995 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1996 ) {
1997 match _t {
1998 alloy_sol_types::private::AssertTypeEq::<
1999 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2000 >(_) => {}
2001 }
2002 }
2003 #[automatically_derived]
2004 #[doc(hidden)]
2005 impl ::core::convert::From<setApprovalForAllCall>
2006 for UnderlyingRustTuple<'_> {
2007 fn from(value: setApprovalForAllCall) -> Self {
2008 (value._operator, value._approved)
2009 }
2010 }
2011 #[automatically_derived]
2012 #[doc(hidden)]
2013 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2014 for setApprovalForAllCall {
2015 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2016 Self {
2017 _operator: tuple.0,
2018 _approved: tuple.1,
2019 }
2020 }
2021 }
2022 }
2023 {
2024 #[doc(hidden)]
2025 type UnderlyingSolTuple<'a> = ();
2026 #[doc(hidden)]
2027 type UnderlyingRustTuple<'a> = ();
2028 #[cfg(test)]
2029 #[allow(dead_code, unreachable_patterns)]
2030 fn _type_assertion(
2031 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2032 ) {
2033 match _t {
2034 alloy_sol_types::private::AssertTypeEq::<
2035 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2036 >(_) => {}
2037 }
2038 }
2039 #[automatically_derived]
2040 #[doc(hidden)]
2041 impl ::core::convert::From<setApprovalForAllReturn>
2042 for UnderlyingRustTuple<'_> {
2043 fn from(value: setApprovalForAllReturn) -> Self {
2044 ()
2045 }
2046 }
2047 #[automatically_derived]
2048 #[doc(hidden)]
2049 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2050 for setApprovalForAllReturn {
2051 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2052 Self {}
2053 }
2054 }
2055 }
2056 #[automatically_derived]
2057 impl alloy_sol_types::SolCall for setApprovalForAllCall {
2058 type Parameters<'a> = (
2059 alloy::sol_types::sol_data::Address,
2060 alloy::sol_types::sol_data::Bool,
2061 );
2062 type Token<'a> = <Self::Parameters<
2063 'a,
2064 > as alloy_sol_types::SolType>::Token<'a>;
2065 type Return = setApprovalForAllReturn;
2066 type ReturnTuple<'a> = ();
2067 type ReturnToken<'a> = <Self::ReturnTuple<
2068 'a,
2069 > as alloy_sol_types::SolType>::Token<'a>;
2070 const SIGNATURE: &'static str = "setApprovalForAll(address,bool)";
2071 const SELECTOR: [u8; 4] = [162u8, 44u8, 180u8, 101u8];
2072 #[inline]
2073 fn new<'a>(
2074 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2075 ) -> Self {
2076 tuple.into()
2077 }
2078 #[inline]
2079 fn tokenize(&self) -> Self::Token<'_> {
2080 (
2081 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2082 &self._operator,
2083 ),
2084 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
2085 &self._approved,
2086 ),
2087 )
2088 }
2089 #[inline]
2090 fn abi_decode_returns(
2091 data: &[u8],
2092 validate: bool,
2093 ) -> alloy_sol_types::Result<Self::Return> {
2094 <Self::ReturnTuple<
2095 '_,
2096 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2097 .map(Into::into)
2098 }
2099 }
2100 };
2101 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2106 #[derive(Clone)]
2107 pub struct supportsInterfaceCall {
2108 #[allow(missing_docs)]
2109 pub interfaceID: alloy::sol_types::private::FixedBytes<4>,
2110 }
2111 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2113 #[derive(Clone)]
2114 pub struct supportsInterfaceReturn {
2115 #[allow(missing_docs)]
2116 pub _0: bool,
2117 }
2118 #[allow(
2119 non_camel_case_types,
2120 non_snake_case,
2121 clippy::pub_underscore_fields,
2122 clippy::style
2123 )]
2124 const _: () = {
2125 use alloy::sol_types as alloy_sol_types;
2126 {
2127 #[doc(hidden)]
2128 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
2129 #[doc(hidden)]
2130 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
2131 #[cfg(test)]
2132 #[allow(dead_code, unreachable_patterns)]
2133 fn _type_assertion(
2134 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2135 ) {
2136 match _t {
2137 alloy_sol_types::private::AssertTypeEq::<
2138 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2139 >(_) => {}
2140 }
2141 }
2142 #[automatically_derived]
2143 #[doc(hidden)]
2144 impl ::core::convert::From<supportsInterfaceCall>
2145 for UnderlyingRustTuple<'_> {
2146 fn from(value: supportsInterfaceCall) -> Self {
2147 (value.interfaceID,)
2148 }
2149 }
2150 #[automatically_derived]
2151 #[doc(hidden)]
2152 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2153 for supportsInterfaceCall {
2154 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2155 Self { interfaceID: tuple.0 }
2156 }
2157 }
2158 }
2159 {
2160 #[doc(hidden)]
2161 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2162 #[doc(hidden)]
2163 type UnderlyingRustTuple<'a> = (bool,);
2164 #[cfg(test)]
2165 #[allow(dead_code, unreachable_patterns)]
2166 fn _type_assertion(
2167 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2168 ) {
2169 match _t {
2170 alloy_sol_types::private::AssertTypeEq::<
2171 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2172 >(_) => {}
2173 }
2174 }
2175 #[automatically_derived]
2176 #[doc(hidden)]
2177 impl ::core::convert::From<supportsInterfaceReturn>
2178 for UnderlyingRustTuple<'_> {
2179 fn from(value: supportsInterfaceReturn) -> Self {
2180 (value._0,)
2181 }
2182 }
2183 #[automatically_derived]
2184 #[doc(hidden)]
2185 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2186 for supportsInterfaceReturn {
2187 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2188 Self { _0: tuple.0 }
2189 }
2190 }
2191 }
2192 #[automatically_derived]
2193 impl alloy_sol_types::SolCall for supportsInterfaceCall {
2194 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
2195 type Token<'a> = <Self::Parameters<
2196 'a,
2197 > as alloy_sol_types::SolType>::Token<'a>;
2198 type Return = supportsInterfaceReturn;
2199 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2200 type ReturnToken<'a> = <Self::ReturnTuple<
2201 'a,
2202 > as alloy_sol_types::SolType>::Token<'a>;
2203 const SIGNATURE: &'static str = "supportsInterface(bytes4)";
2204 const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
2205 #[inline]
2206 fn new<'a>(
2207 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2208 ) -> Self {
2209 tuple.into()
2210 }
2211 #[inline]
2212 fn tokenize(&self) -> Self::Token<'_> {
2213 (
2214 <alloy::sol_types::sol_data::FixedBytes<
2215 4,
2216 > as alloy_sol_types::SolType>::tokenize(&self.interfaceID),
2217 )
2218 }
2219 #[inline]
2220 fn abi_decode_returns(
2221 data: &[u8],
2222 validate: bool,
2223 ) -> alloy_sol_types::Result<Self::Return> {
2224 <Self::ReturnTuple<
2225 '_,
2226 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2227 .map(Into::into)
2228 }
2229 }
2230 };
2231 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2236 #[derive(Clone)]
2237 pub struct symbolCall {}
2238 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2240 #[derive(Clone)]
2241 pub struct symbolReturn {
2242 #[allow(missing_docs)]
2243 pub _symbol: alloy::sol_types::private::String,
2244 }
2245 #[allow(
2246 non_camel_case_types,
2247 non_snake_case,
2248 clippy::pub_underscore_fields,
2249 clippy::style
2250 )]
2251 const _: () = {
2252 use alloy::sol_types as alloy_sol_types;
2253 {
2254 #[doc(hidden)]
2255 type UnderlyingSolTuple<'a> = ();
2256 #[doc(hidden)]
2257 type UnderlyingRustTuple<'a> = ();
2258 #[cfg(test)]
2259 #[allow(dead_code, unreachable_patterns)]
2260 fn _type_assertion(
2261 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2262 ) {
2263 match _t {
2264 alloy_sol_types::private::AssertTypeEq::<
2265 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2266 >(_) => {}
2267 }
2268 }
2269 #[automatically_derived]
2270 #[doc(hidden)]
2271 impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
2272 fn from(value: symbolCall) -> Self {
2273 ()
2274 }
2275 }
2276 #[automatically_derived]
2277 #[doc(hidden)]
2278 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
2279 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2280 Self {}
2281 }
2282 }
2283 }
2284 {
2285 #[doc(hidden)]
2286 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2287 #[doc(hidden)]
2288 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2289 #[cfg(test)]
2290 #[allow(dead_code, unreachable_patterns)]
2291 fn _type_assertion(
2292 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2293 ) {
2294 match _t {
2295 alloy_sol_types::private::AssertTypeEq::<
2296 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2297 >(_) => {}
2298 }
2299 }
2300 #[automatically_derived]
2301 #[doc(hidden)]
2302 impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
2303 fn from(value: symbolReturn) -> Self {
2304 (value._symbol,)
2305 }
2306 }
2307 #[automatically_derived]
2308 #[doc(hidden)]
2309 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
2310 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2311 Self { _symbol: tuple.0 }
2312 }
2313 }
2314 }
2315 #[automatically_derived]
2316 impl alloy_sol_types::SolCall for symbolCall {
2317 type Parameters<'a> = ();
2318 type Token<'a> = <Self::Parameters<
2319 'a,
2320 > as alloy_sol_types::SolType>::Token<'a>;
2321 type Return = symbolReturn;
2322 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2323 type ReturnToken<'a> = <Self::ReturnTuple<
2324 'a,
2325 > as alloy_sol_types::SolType>::Token<'a>;
2326 const SIGNATURE: &'static str = "symbol()";
2327 const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
2328 #[inline]
2329 fn new<'a>(
2330 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2331 ) -> Self {
2332 tuple.into()
2333 }
2334 #[inline]
2335 fn tokenize(&self) -> Self::Token<'_> {
2336 ()
2337 }
2338 #[inline]
2339 fn abi_decode_returns(
2340 data: &[u8],
2341 validate: bool,
2342 ) -> alloy_sol_types::Result<Self::Return> {
2343 <Self::ReturnTuple<
2344 '_,
2345 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2346 .map(Into::into)
2347 }
2348 }
2349 };
2350 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2355 #[derive(Clone)]
2356 pub struct tokenURICall {
2357 #[allow(missing_docs)]
2358 pub _tokenId: alloy::sol_types::private::primitives::aliases::U256,
2359 }
2360 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2362 #[derive(Clone)]
2363 pub struct tokenURIReturn {
2364 #[allow(missing_docs)]
2365 pub _0: alloy::sol_types::private::String,
2366 }
2367 #[allow(
2368 non_camel_case_types,
2369 non_snake_case,
2370 clippy::pub_underscore_fields,
2371 clippy::style
2372 )]
2373 const _: () = {
2374 use alloy::sol_types as alloy_sol_types;
2375 {
2376 #[doc(hidden)]
2377 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2378 #[doc(hidden)]
2379 type UnderlyingRustTuple<'a> = (
2380 alloy::sol_types::private::primitives::aliases::U256,
2381 );
2382 #[cfg(test)]
2383 #[allow(dead_code, unreachable_patterns)]
2384 fn _type_assertion(
2385 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2386 ) {
2387 match _t {
2388 alloy_sol_types::private::AssertTypeEq::<
2389 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2390 >(_) => {}
2391 }
2392 }
2393 #[automatically_derived]
2394 #[doc(hidden)]
2395 impl ::core::convert::From<tokenURICall> for UnderlyingRustTuple<'_> {
2396 fn from(value: tokenURICall) -> Self {
2397 (value._tokenId,)
2398 }
2399 }
2400 #[automatically_derived]
2401 #[doc(hidden)]
2402 impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenURICall {
2403 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2404 Self { _tokenId: tuple.0 }
2405 }
2406 }
2407 }
2408 {
2409 #[doc(hidden)]
2410 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2411 #[doc(hidden)]
2412 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2413 #[cfg(test)]
2414 #[allow(dead_code, unreachable_patterns)]
2415 fn _type_assertion(
2416 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2417 ) {
2418 match _t {
2419 alloy_sol_types::private::AssertTypeEq::<
2420 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2421 >(_) => {}
2422 }
2423 }
2424 #[automatically_derived]
2425 #[doc(hidden)]
2426 impl ::core::convert::From<tokenURIReturn> for UnderlyingRustTuple<'_> {
2427 fn from(value: tokenURIReturn) -> Self {
2428 (value._0,)
2429 }
2430 }
2431 #[automatically_derived]
2432 #[doc(hidden)]
2433 impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokenURIReturn {
2434 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2435 Self { _0: tuple.0 }
2436 }
2437 }
2438 }
2439 #[automatically_derived]
2440 impl alloy_sol_types::SolCall for tokenURICall {
2441 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2442 type Token<'a> = <Self::Parameters<
2443 'a,
2444 > as alloy_sol_types::SolType>::Token<'a>;
2445 type Return = tokenURIReturn;
2446 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2447 type ReturnToken<'a> = <Self::ReturnTuple<
2448 'a,
2449 > as alloy_sol_types::SolType>::Token<'a>;
2450 const SIGNATURE: &'static str = "tokenURI(uint256)";
2451 const SELECTOR: [u8; 4] = [200u8, 123u8, 86u8, 221u8];
2452 #[inline]
2453 fn new<'a>(
2454 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2455 ) -> Self {
2456 tuple.into()
2457 }
2458 #[inline]
2459 fn tokenize(&self) -> Self::Token<'_> {
2460 (
2461 <alloy::sol_types::sol_data::Uint<
2462 256,
2463 > as alloy_sol_types::SolType>::tokenize(&self._tokenId),
2464 )
2465 }
2466 #[inline]
2467 fn abi_decode_returns(
2468 data: &[u8],
2469 validate: bool,
2470 ) -> alloy_sol_types::Result<Self::Return> {
2471 <Self::ReturnTuple<
2472 '_,
2473 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2474 .map(Into::into)
2475 }
2476 }
2477 };
2478 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2483 #[derive(Clone)]
2484 pub struct transferFromCall {
2485 #[allow(missing_docs)]
2486 pub _from: alloy::sol_types::private::Address,
2487 #[allow(missing_docs)]
2488 pub _to: alloy::sol_types::private::Address,
2489 #[allow(missing_docs)]
2490 pub _tokenId: alloy::sol_types::private::primitives::aliases::U256,
2491 }
2492 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2494 #[derive(Clone)]
2495 pub struct transferFromReturn {}
2496 #[allow(
2497 non_camel_case_types,
2498 non_snake_case,
2499 clippy::pub_underscore_fields,
2500 clippy::style
2501 )]
2502 const _: () = {
2503 use alloy::sol_types as alloy_sol_types;
2504 {
2505 #[doc(hidden)]
2506 type UnderlyingSolTuple<'a> = (
2507 alloy::sol_types::sol_data::Address,
2508 alloy::sol_types::sol_data::Address,
2509 alloy::sol_types::sol_data::Uint<256>,
2510 );
2511 #[doc(hidden)]
2512 type UnderlyingRustTuple<'a> = (
2513 alloy::sol_types::private::Address,
2514 alloy::sol_types::private::Address,
2515 alloy::sol_types::private::primitives::aliases::U256,
2516 );
2517 #[cfg(test)]
2518 #[allow(dead_code, unreachable_patterns)]
2519 fn _type_assertion(
2520 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2521 ) {
2522 match _t {
2523 alloy_sol_types::private::AssertTypeEq::<
2524 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2525 >(_) => {}
2526 }
2527 }
2528 #[automatically_derived]
2529 #[doc(hidden)]
2530 impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
2531 fn from(value: transferFromCall) -> Self {
2532 (value._from, value._to, value._tokenId)
2533 }
2534 }
2535 #[automatically_derived]
2536 #[doc(hidden)]
2537 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
2538 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2539 Self {
2540 _from: tuple.0,
2541 _to: tuple.1,
2542 _tokenId: tuple.2,
2543 }
2544 }
2545 }
2546 }
2547 {
2548 #[doc(hidden)]
2549 type UnderlyingSolTuple<'a> = ();
2550 #[doc(hidden)]
2551 type UnderlyingRustTuple<'a> = ();
2552 #[cfg(test)]
2553 #[allow(dead_code, unreachable_patterns)]
2554 fn _type_assertion(
2555 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2556 ) {
2557 match _t {
2558 alloy_sol_types::private::AssertTypeEq::<
2559 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2560 >(_) => {}
2561 }
2562 }
2563 #[automatically_derived]
2564 #[doc(hidden)]
2565 impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
2566 fn from(value: transferFromReturn) -> Self {
2567 ()
2568 }
2569 }
2570 #[automatically_derived]
2571 #[doc(hidden)]
2572 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
2573 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2574 Self {}
2575 }
2576 }
2577 }
2578 #[automatically_derived]
2579 impl alloy_sol_types::SolCall for transferFromCall {
2580 type Parameters<'a> = (
2581 alloy::sol_types::sol_data::Address,
2582 alloy::sol_types::sol_data::Address,
2583 alloy::sol_types::sol_data::Uint<256>,
2584 );
2585 type Token<'a> = <Self::Parameters<
2586 'a,
2587 > as alloy_sol_types::SolType>::Token<'a>;
2588 type Return = transferFromReturn;
2589 type ReturnTuple<'a> = ();
2590 type ReturnToken<'a> = <Self::ReturnTuple<
2591 'a,
2592 > as alloy_sol_types::SolType>::Token<'a>;
2593 const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
2594 const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
2595 #[inline]
2596 fn new<'a>(
2597 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2598 ) -> Self {
2599 tuple.into()
2600 }
2601 #[inline]
2602 fn tokenize(&self) -> Self::Token<'_> {
2603 (
2604 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2605 &self._from,
2606 ),
2607 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2608 &self._to,
2609 ),
2610 <alloy::sol_types::sol_data::Uint<
2611 256,
2612 > as alloy_sol_types::SolType>::tokenize(&self._tokenId),
2613 )
2614 }
2615 #[inline]
2616 fn abi_decode_returns(
2617 data: &[u8],
2618 validate: bool,
2619 ) -> alloy_sol_types::Result<Self::Return> {
2620 <Self::ReturnTuple<
2621 '_,
2622 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2623 .map(Into::into)
2624 }
2625 }
2626 };
2627 pub enum IERC721MetadataCalls {
2629 #[allow(missing_docs)]
2630 approve(approveCall),
2631 #[allow(missing_docs)]
2632 balanceOf(balanceOfCall),
2633 #[allow(missing_docs)]
2634 getApproved(getApprovedCall),
2635 #[allow(missing_docs)]
2636 isApprovedForAll(isApprovedForAllCall),
2637 #[allow(missing_docs)]
2638 name(nameCall),
2639 #[allow(missing_docs)]
2640 ownerOf(ownerOfCall),
2641 #[allow(missing_docs)]
2642 safeTransferFrom_0(safeTransferFrom_0Call),
2643 #[allow(missing_docs)]
2644 safeTransferFrom_1(safeTransferFrom_1Call),
2645 #[allow(missing_docs)]
2646 setApprovalForAll(setApprovalForAllCall),
2647 #[allow(missing_docs)]
2648 supportsInterface(supportsInterfaceCall),
2649 #[allow(missing_docs)]
2650 symbol(symbolCall),
2651 #[allow(missing_docs)]
2652 tokenURI(tokenURICall),
2653 #[allow(missing_docs)]
2654 transferFrom(transferFromCall),
2655 }
2656 #[automatically_derived]
2657 impl IERC721MetadataCalls {
2658 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2665 [1u8, 255u8, 201u8, 167u8],
2666 [6u8, 253u8, 222u8, 3u8],
2667 [8u8, 24u8, 18u8, 252u8],
2668 [9u8, 94u8, 167u8, 179u8],
2669 [35u8, 184u8, 114u8, 221u8],
2670 [66u8, 132u8, 46u8, 14u8],
2671 [99u8, 82u8, 33u8, 30u8],
2672 [112u8, 160u8, 130u8, 49u8],
2673 [149u8, 216u8, 155u8, 65u8],
2674 [162u8, 44u8, 180u8, 101u8],
2675 [184u8, 141u8, 79u8, 222u8],
2676 [200u8, 123u8, 86u8, 221u8],
2677 [233u8, 133u8, 233u8, 197u8],
2678 ];
2679 }
2680 #[automatically_derived]
2681 impl alloy_sol_types::SolInterface for IERC721MetadataCalls {
2682 const NAME: &'static str = "IERC721MetadataCalls";
2683 const MIN_DATA_LENGTH: usize = 0usize;
2684 const COUNT: usize = 13usize;
2685 #[inline]
2686 fn selector(&self) -> [u8; 4] {
2687 match self {
2688 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
2689 Self::balanceOf(_) => {
2690 <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR
2691 }
2692 Self::getApproved(_) => {
2693 <getApprovedCall as alloy_sol_types::SolCall>::SELECTOR
2694 }
2695 Self::isApprovedForAll(_) => {
2696 <isApprovedForAllCall as alloy_sol_types::SolCall>::SELECTOR
2697 }
2698 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
2699 Self::ownerOf(_) => <ownerOfCall as alloy_sol_types::SolCall>::SELECTOR,
2700 Self::safeTransferFrom_0(_) => {
2701 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::SELECTOR
2702 }
2703 Self::safeTransferFrom_1(_) => {
2704 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::SELECTOR
2705 }
2706 Self::setApprovalForAll(_) => {
2707 <setApprovalForAllCall as alloy_sol_types::SolCall>::SELECTOR
2708 }
2709 Self::supportsInterface(_) => {
2710 <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
2711 }
2712 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
2713 Self::tokenURI(_) => <tokenURICall as alloy_sol_types::SolCall>::SELECTOR,
2714 Self::transferFrom(_) => {
2715 <transferFromCall as alloy_sol_types::SolCall>::SELECTOR
2716 }
2717 }
2718 }
2719 #[inline]
2720 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2721 Self::SELECTORS.get(i).copied()
2722 }
2723 #[inline]
2724 fn valid_selector(selector: [u8; 4]) -> bool {
2725 Self::SELECTORS.binary_search(&selector).is_ok()
2726 }
2727 #[inline]
2728 #[allow(non_snake_case)]
2729 fn abi_decode_raw(
2730 selector: [u8; 4],
2731 data: &[u8],
2732 validate: bool,
2733 ) -> alloy_sol_types::Result<Self> {
2734 static DECODE_SHIMS: &[fn(
2735 &[u8],
2736 bool,
2737 ) -> alloy_sol_types::Result<IERC721MetadataCalls>] = &[
2738 {
2739 fn supportsInterface(
2740 data: &[u8],
2741 validate: bool,
2742 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2743 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(
2744 data,
2745 validate,
2746 )
2747 .map(IERC721MetadataCalls::supportsInterface)
2748 }
2749 supportsInterface
2750 },
2751 {
2752 fn name(
2753 data: &[u8],
2754 validate: bool,
2755 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2756 <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(
2757 data,
2758 validate,
2759 )
2760 .map(IERC721MetadataCalls::name)
2761 }
2762 name
2763 },
2764 {
2765 fn getApproved(
2766 data: &[u8],
2767 validate: bool,
2768 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2769 <getApprovedCall as alloy_sol_types::SolCall>::abi_decode_raw(
2770 data,
2771 validate,
2772 )
2773 .map(IERC721MetadataCalls::getApproved)
2774 }
2775 getApproved
2776 },
2777 {
2778 fn approve(
2779 data: &[u8],
2780 validate: bool,
2781 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2782 <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(
2783 data,
2784 validate,
2785 )
2786 .map(IERC721MetadataCalls::approve)
2787 }
2788 approve
2789 },
2790 {
2791 fn transferFrom(
2792 data: &[u8],
2793 validate: bool,
2794 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2795 <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(
2796 data,
2797 validate,
2798 )
2799 .map(IERC721MetadataCalls::transferFrom)
2800 }
2801 transferFrom
2802 },
2803 {
2804 fn safeTransferFrom_0(
2805 data: &[u8],
2806 validate: bool,
2807 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2808 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
2809 data,
2810 validate,
2811 )
2812 .map(IERC721MetadataCalls::safeTransferFrom_0)
2813 }
2814 safeTransferFrom_0
2815 },
2816 {
2817 fn ownerOf(
2818 data: &[u8],
2819 validate: bool,
2820 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2821 <ownerOfCall as alloy_sol_types::SolCall>::abi_decode_raw(
2822 data,
2823 validate,
2824 )
2825 .map(IERC721MetadataCalls::ownerOf)
2826 }
2827 ownerOf
2828 },
2829 {
2830 fn balanceOf(
2831 data: &[u8],
2832 validate: bool,
2833 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2834 <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(
2835 data,
2836 validate,
2837 )
2838 .map(IERC721MetadataCalls::balanceOf)
2839 }
2840 balanceOf
2841 },
2842 {
2843 fn symbol(
2844 data: &[u8],
2845 validate: bool,
2846 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2847 <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(
2848 data,
2849 validate,
2850 )
2851 .map(IERC721MetadataCalls::symbol)
2852 }
2853 symbol
2854 },
2855 {
2856 fn setApprovalForAll(
2857 data: &[u8],
2858 validate: bool,
2859 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2860 <setApprovalForAllCall as alloy_sol_types::SolCall>::abi_decode_raw(
2861 data,
2862 validate,
2863 )
2864 .map(IERC721MetadataCalls::setApprovalForAll)
2865 }
2866 setApprovalForAll
2867 },
2868 {
2869 fn safeTransferFrom_1(
2870 data: &[u8],
2871 validate: bool,
2872 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2873 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
2874 data,
2875 validate,
2876 )
2877 .map(IERC721MetadataCalls::safeTransferFrom_1)
2878 }
2879 safeTransferFrom_1
2880 },
2881 {
2882 fn tokenURI(
2883 data: &[u8],
2884 validate: bool,
2885 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2886 <tokenURICall as alloy_sol_types::SolCall>::abi_decode_raw(
2887 data,
2888 validate,
2889 )
2890 .map(IERC721MetadataCalls::tokenURI)
2891 }
2892 tokenURI
2893 },
2894 {
2895 fn isApprovedForAll(
2896 data: &[u8],
2897 validate: bool,
2898 ) -> alloy_sol_types::Result<IERC721MetadataCalls> {
2899 <isApprovedForAllCall as alloy_sol_types::SolCall>::abi_decode_raw(
2900 data,
2901 validate,
2902 )
2903 .map(IERC721MetadataCalls::isApprovedForAll)
2904 }
2905 isApprovedForAll
2906 },
2907 ];
2908 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2909 return Err(
2910 alloy_sol_types::Error::unknown_selector(
2911 <Self as alloy_sol_types::SolInterface>::NAME,
2912 selector,
2913 ),
2914 );
2915 };
2916 DECODE_SHIMS[idx](data, validate)
2917 }
2918 #[inline]
2919 fn abi_encoded_size(&self) -> usize {
2920 match self {
2921 Self::approve(inner) => {
2922 <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2923 }
2924 Self::balanceOf(inner) => {
2925 <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2926 }
2927 Self::getApproved(inner) => {
2928 <getApprovedCall as alloy_sol_types::SolCall>::abi_encoded_size(
2929 inner,
2930 )
2931 }
2932 Self::isApprovedForAll(inner) => {
2933 <isApprovedForAllCall as alloy_sol_types::SolCall>::abi_encoded_size(
2934 inner,
2935 )
2936 }
2937 Self::name(inner) => {
2938 <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2939 }
2940 Self::ownerOf(inner) => {
2941 <ownerOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2942 }
2943 Self::safeTransferFrom_0(inner) => {
2944 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::abi_encoded_size(
2945 inner,
2946 )
2947 }
2948 Self::safeTransferFrom_1(inner) => {
2949 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::abi_encoded_size(
2950 inner,
2951 )
2952 }
2953 Self::setApprovalForAll(inner) => {
2954 <setApprovalForAllCall as alloy_sol_types::SolCall>::abi_encoded_size(
2955 inner,
2956 )
2957 }
2958 Self::supportsInterface(inner) => {
2959 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
2960 inner,
2961 )
2962 }
2963 Self::symbol(inner) => {
2964 <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2965 }
2966 Self::tokenURI(inner) => {
2967 <tokenURICall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2968 }
2969 Self::transferFrom(inner) => {
2970 <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
2971 inner,
2972 )
2973 }
2974 }
2975 }
2976 #[inline]
2977 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2978 match self {
2979 Self::approve(inner) => {
2980 <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2981 }
2982 Self::balanceOf(inner) => {
2983 <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(
2984 inner,
2985 out,
2986 )
2987 }
2988 Self::getApproved(inner) => {
2989 <getApprovedCall as alloy_sol_types::SolCall>::abi_encode_raw(
2990 inner,
2991 out,
2992 )
2993 }
2994 Self::isApprovedForAll(inner) => {
2995 <isApprovedForAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
2996 inner,
2997 out,
2998 )
2999 }
3000 Self::name(inner) => {
3001 <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3002 }
3003 Self::ownerOf(inner) => {
3004 <ownerOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3005 }
3006 Self::safeTransferFrom_0(inner) => {
3007 <safeTransferFrom_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
3008 inner,
3009 out,
3010 )
3011 }
3012 Self::safeTransferFrom_1(inner) => {
3013 <safeTransferFrom_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
3014 inner,
3015 out,
3016 )
3017 }
3018 Self::setApprovalForAll(inner) => {
3019 <setApprovalForAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
3020 inner,
3021 out,
3022 )
3023 }
3024 Self::supportsInterface(inner) => {
3025 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
3026 inner,
3027 out,
3028 )
3029 }
3030 Self::symbol(inner) => {
3031 <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3032 }
3033 Self::tokenURI(inner) => {
3034 <tokenURICall as alloy_sol_types::SolCall>::abi_encode_raw(
3035 inner,
3036 out,
3037 )
3038 }
3039 Self::transferFrom(inner) => {
3040 <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
3041 inner,
3042 out,
3043 )
3044 }
3045 }
3046 }
3047 }
3048 pub enum IERC721MetadataEvents {
3050 #[allow(missing_docs)]
3051 Approval(Approval),
3052 #[allow(missing_docs)]
3053 ApprovalForAll(ApprovalForAll),
3054 #[allow(missing_docs)]
3055 Transfer(Transfer),
3056 }
3057 #[automatically_derived]
3058 impl IERC721MetadataEvents {
3059 pub const SELECTORS: &'static [[u8; 32usize]] = &[
3066 [
3067 23u8,
3068 48u8,
3069 126u8,
3070 171u8,
3071 57u8,
3072 171u8,
3073 97u8,
3074 7u8,
3075 232u8,
3076 137u8,
3077 152u8,
3078 69u8,
3079 173u8,
3080 61u8,
3081 89u8,
3082 189u8,
3083 150u8,
3084 83u8,
3085 242u8,
3086 0u8,
3087 242u8,
3088 32u8,
3089 146u8,
3090 4u8,
3091 137u8,
3092 202u8,
3093 43u8,
3094 89u8,
3095 55u8,
3096 105u8,
3097 108u8,
3098 49u8,
3099 ],
3100 [
3101 140u8,
3102 91u8,
3103 225u8,
3104 229u8,
3105 235u8,
3106 236u8,
3107 125u8,
3108 91u8,
3109 209u8,
3110 79u8,
3111 113u8,
3112 66u8,
3113 125u8,
3114 30u8,
3115 132u8,
3116 243u8,
3117 221u8,
3118 3u8,
3119 20u8,
3120 192u8,
3121 247u8,
3122 178u8,
3123 41u8,
3124 30u8,
3125 91u8,
3126 32u8,
3127 10u8,
3128 200u8,
3129 199u8,
3130 195u8,
3131 185u8,
3132 37u8,
3133 ],
3134 [
3135 221u8,
3136 242u8,
3137 82u8,
3138 173u8,
3139 27u8,
3140 226u8,
3141 200u8,
3142 155u8,
3143 105u8,
3144 194u8,
3145 176u8,
3146 104u8,
3147 252u8,
3148 55u8,
3149 141u8,
3150 170u8,
3151 149u8,
3152 43u8,
3153 167u8,
3154 241u8,
3155 99u8,
3156 196u8,
3157 161u8,
3158 22u8,
3159 40u8,
3160 245u8,
3161 90u8,
3162 77u8,
3163 245u8,
3164 35u8,
3165 179u8,
3166 239u8,
3167 ],
3168 ];
3169 }
3170 #[automatically_derived]
3171 impl alloy_sol_types::SolEventInterface for IERC721MetadataEvents {
3172 const NAME: &'static str = "IERC721MetadataEvents";
3173 const COUNT: usize = 3usize;
3174 fn decode_raw_log(
3175 topics: &[alloy_sol_types::Word],
3176 data: &[u8],
3177 validate: bool,
3178 ) -> alloy_sol_types::Result<Self> {
3179 match topics.first().copied() {
3180 Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3181 <Approval as alloy_sol_types::SolEvent>::decode_raw_log(
3182 topics,
3183 data,
3184 validate,
3185 )
3186 .map(Self::Approval)
3187 }
3188 Some(<ApprovalForAll as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3189 <ApprovalForAll as alloy_sol_types::SolEvent>::decode_raw_log(
3190 topics,
3191 data,
3192 validate,
3193 )
3194 .map(Self::ApprovalForAll)
3195 }
3196 Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3197 <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(
3198 topics,
3199 data,
3200 validate,
3201 )
3202 .map(Self::Transfer)
3203 }
3204 _ => {
3205 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
3206 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
3207 log: alloy_sol_types::private::Box::new(
3208 alloy_sol_types::private::LogData::new_unchecked(
3209 topics.to_vec(),
3210 data.to_vec().into(),
3211 ),
3212 ),
3213 })
3214 }
3215 }
3216 }
3217 }
3218 #[automatically_derived]
3219 impl alloy_sol_types::private::IntoLogData for IERC721MetadataEvents {
3220 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3221 match self {
3222 Self::Approval(inner) => {
3223 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3224 }
3225 Self::ApprovalForAll(inner) => {
3226 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3227 }
3228 Self::Transfer(inner) => {
3229 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3230 }
3231 }
3232 }
3233 fn into_log_data(self) -> alloy_sol_types::private::LogData {
3234 match self {
3235 Self::Approval(inner) => {
3236 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3237 }
3238 Self::ApprovalForAll(inner) => {
3239 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3240 }
3241 Self::Transfer(inner) => {
3242 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3243 }
3244 }
3245 }
3246 }
3247 use alloy::contract as alloy_contract;
3248 #[inline]
3252 pub const fn new<
3253 T: alloy_contract::private::Transport + ::core::clone::Clone,
3254 P: alloy_contract::private::Provider<T, N>,
3255 N: alloy_contract::private::Network,
3256 >(
3257 address: alloy_sol_types::private::Address,
3258 provider: P,
3259 ) -> IERC721MetadataInstance<T, P, N> {
3260 IERC721MetadataInstance::<T, P, N>::new(address, provider)
3261 }
3262 #[inline]
3268 pub fn deploy<
3269 T: alloy_contract::private::Transport + ::core::clone::Clone,
3270 P: alloy_contract::private::Provider<T, N>,
3271 N: alloy_contract::private::Network,
3272 >(
3273 provider: P,
3274 ) -> impl ::core::future::Future<
3275 Output = alloy_contract::Result<IERC721MetadataInstance<T, P, N>>,
3276 > {
3277 IERC721MetadataInstance::<T, P, N>::deploy(provider)
3278 }
3279 #[inline]
3285 pub fn deploy_builder<
3286 T: alloy_contract::private::Transport + ::core::clone::Clone,
3287 P: alloy_contract::private::Provider<T, N>,
3288 N: alloy_contract::private::Network,
3289 >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
3290 IERC721MetadataInstance::<T, P, N>::deploy_builder(provider)
3291 }
3292 #[derive(Clone)]
3304 pub struct IERC721MetadataInstance<T, P, N = alloy_contract::private::Ethereum> {
3305 address: alloy_sol_types::private::Address,
3306 provider: P,
3307 _network_transport: ::core::marker::PhantomData<(N, T)>,
3308 }
3309 #[automatically_derived]
3310 impl<T, P, N> ::core::fmt::Debug for IERC721MetadataInstance<T, P, N> {
3311 #[inline]
3312 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3313 f.debug_tuple("IERC721MetadataInstance").field(&self.address).finish()
3314 }
3315 }
3316 #[automatically_derived]
3318 impl<
3319 T: alloy_contract::private::Transport + ::core::clone::Clone,
3320 P: alloy_contract::private::Provider<T, N>,
3321 N: alloy_contract::private::Network,
3322 > IERC721MetadataInstance<T, P, N> {
3323 #[inline]
3327 pub const fn new(
3328 address: alloy_sol_types::private::Address,
3329 provider: P,
3330 ) -> Self {
3331 Self {
3332 address,
3333 provider,
3334 _network_transport: ::core::marker::PhantomData,
3335 }
3336 }
3337 #[inline]
3343 pub async fn deploy(
3344 provider: P,
3345 ) -> alloy_contract::Result<IERC721MetadataInstance<T, P, N>> {
3346 let call_builder = Self::deploy_builder(provider);
3347 let contract_address = call_builder.deploy().await?;
3348 Ok(Self::new(contract_address, call_builder.provider))
3349 }
3350 #[inline]
3356 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
3357 alloy_contract::RawCallBuilder::new_raw_deploy(
3358 provider,
3359 ::core::clone::Clone::clone(&BYTECODE),
3360 )
3361 }
3362 #[inline]
3364 pub const fn address(&self) -> &alloy_sol_types::private::Address {
3365 &self.address
3366 }
3367 #[inline]
3369 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3370 self.address = address;
3371 }
3372 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3374 self.set_address(address);
3375 self
3376 }
3377 #[inline]
3379 pub const fn provider(&self) -> &P {
3380 &self.provider
3381 }
3382 }
3383 impl<T, P: ::core::clone::Clone, N> IERC721MetadataInstance<T, &P, N> {
3384 #[inline]
3386 pub fn with_cloned_provider(self) -> IERC721MetadataInstance<T, P, N> {
3387 IERC721MetadataInstance {
3388 address: self.address,
3389 provider: ::core::clone::Clone::clone(&self.provider),
3390 _network_transport: ::core::marker::PhantomData,
3391 }
3392 }
3393 }
3394 #[automatically_derived]
3396 impl<
3397 T: alloy_contract::private::Transport + ::core::clone::Clone,
3398 P: alloy_contract::private::Provider<T, N>,
3399 N: alloy_contract::private::Network,
3400 > IERC721MetadataInstance<T, P, N> {
3401 pub fn call_builder<C: alloy_sol_types::SolCall>(
3406 &self,
3407 call: &C,
3408 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
3409 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3410 }
3411 pub fn approve(
3413 &self,
3414 _approved: alloy::sol_types::private::Address,
3415 _tokenId: alloy::sol_types::private::primitives::aliases::U256,
3416 ) -> alloy_contract::SolCallBuilder<T, &P, approveCall, N> {
3417 self.call_builder(&approveCall { _approved, _tokenId })
3418 }
3419 pub fn balanceOf(
3421 &self,
3422 _owner: alloy::sol_types::private::Address,
3423 ) -> alloy_contract::SolCallBuilder<T, &P, balanceOfCall, N> {
3424 self.call_builder(&balanceOfCall { _owner })
3425 }
3426 pub fn getApproved(
3428 &self,
3429 _tokenId: alloy::sol_types::private::primitives::aliases::U256,
3430 ) -> alloy_contract::SolCallBuilder<T, &P, getApprovedCall, N> {
3431 self.call_builder(&getApprovedCall { _tokenId })
3432 }
3433 pub fn isApprovedForAll(
3435 &self,
3436 _owner: alloy::sol_types::private::Address,
3437 _operator: alloy::sol_types::private::Address,
3438 ) -> alloy_contract::SolCallBuilder<T, &P, isApprovedForAllCall, N> {
3439 self.call_builder(
3440 &isApprovedForAllCall {
3441 _owner,
3442 _operator,
3443 },
3444 )
3445 }
3446 pub fn name(&self) -> alloy_contract::SolCallBuilder<T, &P, nameCall, N> {
3448 self.call_builder(&nameCall {})
3449 }
3450 pub fn ownerOf(
3452 &self,
3453 _tokenId: alloy::sol_types::private::primitives::aliases::U256,
3454 ) -> alloy_contract::SolCallBuilder<T, &P, ownerOfCall, N> {
3455 self.call_builder(&ownerOfCall { _tokenId })
3456 }
3457 pub fn safeTransferFrom_0(
3459 &self,
3460 _from: alloy::sol_types::private::Address,
3461 _to: alloy::sol_types::private::Address,
3462 _tokenId: alloy::sol_types::private::primitives::aliases::U256,
3463 ) -> alloy_contract::SolCallBuilder<T, &P, safeTransferFrom_0Call, N> {
3464 self.call_builder(
3465 &safeTransferFrom_0Call {
3466 _from,
3467 _to,
3468 _tokenId,
3469 },
3470 )
3471 }
3472 pub fn safeTransferFrom_1(
3474 &self,
3475 _from: alloy::sol_types::private::Address,
3476 _to: alloy::sol_types::private::Address,
3477 _tokenId: alloy::sol_types::private::primitives::aliases::U256,
3478 data: alloy::sol_types::private::Bytes,
3479 ) -> alloy_contract::SolCallBuilder<T, &P, safeTransferFrom_1Call, N> {
3480 self.call_builder(
3481 &safeTransferFrom_1Call {
3482 _from,
3483 _to,
3484 _tokenId,
3485 data,
3486 },
3487 )
3488 }
3489 pub fn setApprovalForAll(
3491 &self,
3492 _operator: alloy::sol_types::private::Address,
3493 _approved: bool,
3494 ) -> alloy_contract::SolCallBuilder<T, &P, setApprovalForAllCall, N> {
3495 self.call_builder(
3496 &setApprovalForAllCall {
3497 _operator,
3498 _approved,
3499 },
3500 )
3501 }
3502 pub fn supportsInterface(
3504 &self,
3505 interfaceID: alloy::sol_types::private::FixedBytes<4>,
3506 ) -> alloy_contract::SolCallBuilder<T, &P, supportsInterfaceCall, N> {
3507 self.call_builder(
3508 &supportsInterfaceCall {
3509 interfaceID,
3510 },
3511 )
3512 }
3513 pub fn symbol(&self) -> alloy_contract::SolCallBuilder<T, &P, symbolCall, N> {
3515 self.call_builder(&symbolCall {})
3516 }
3517 pub fn tokenURI(
3519 &self,
3520 _tokenId: alloy::sol_types::private::primitives::aliases::U256,
3521 ) -> alloy_contract::SolCallBuilder<T, &P, tokenURICall, N> {
3522 self.call_builder(&tokenURICall { _tokenId })
3523 }
3524 pub fn transferFrom(
3526 &self,
3527 _from: alloy::sol_types::private::Address,
3528 _to: alloy::sol_types::private::Address,
3529 _tokenId: alloy::sol_types::private::primitives::aliases::U256,
3530 ) -> alloy_contract::SolCallBuilder<T, &P, transferFromCall, N> {
3531 self.call_builder(
3532 &transferFromCall {
3533 _from,
3534 _to,
3535 _tokenId,
3536 },
3537 )
3538 }
3539 }
3540 #[automatically_derived]
3542 impl<
3543 T: alloy_contract::private::Transport + ::core::clone::Clone,
3544 P: alloy_contract::private::Provider<T, N>,
3545 N: alloy_contract::private::Network,
3546 > IERC721MetadataInstance<T, P, N> {
3547 pub fn event_filter<E: alloy_sol_types::SolEvent>(
3552 &self,
3553 ) -> alloy_contract::Event<T, &P, E, N> {
3554 alloy_contract::Event::new_sol(&self.provider, &self.address)
3555 }
3556 pub fn Approval_filter(&self) -> alloy_contract::Event<T, &P, Approval, N> {
3558 self.event_filter::<Approval>()
3559 }
3560 pub fn ApprovalForAll_filter(
3562 &self,
3563 ) -> alloy_contract::Event<T, &P, ApprovalForAll, N> {
3564 self.event_filter::<ApprovalForAll>()
3565 }
3566 pub fn Transfer_filter(&self) -> alloy_contract::Event<T, &P, Transfer, N> {
3568 self.event_filter::<Transfer>()
3569 }
3570 }
3571}