1#[allow(
522 non_camel_case_types,
523 non_snake_case,
524 clippy::pub_underscore_fields,
525 clippy::style,
526 clippy::empty_structs_with_brackets
527)]
528pub mod Pi2 {
529 use super::*;
530 use alloy::sol_types as alloy_sol_types;
531 #[rustfmt::skip]
537 #[allow(clippy::all)]
538 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
539 b"",
540 );
541 #[rustfmt::skip]
547 #[allow(clippy::all)]
548 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
549 b"",
550 );
551 #[derive(Default, Debug, PartialEq, Eq, Hash)]
552 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
556 #[derive(Clone)]
557 pub struct Account {
558 #[allow(missing_docs)]
559 pub proof: <AccountProof as alloy::sol_types::SolType>::RustType,
560 #[allow(missing_docs)]
561 pub code: alloy::sol_types::private::Bytes,
562 }
563 #[allow(
564 non_camel_case_types,
565 non_snake_case,
566 clippy::pub_underscore_fields,
567 clippy::style
568 )]
569 const _: () = {
570 use alloy::sol_types as alloy_sol_types;
571 #[doc(hidden)]
572 type UnderlyingSolTuple<'a> = (AccountProof, alloy::sol_types::sol_data::Bytes);
573 #[doc(hidden)]
574 type UnderlyingRustTuple<'a> = (
575 <AccountProof as alloy::sol_types::SolType>::RustType,
576 alloy::sol_types::private::Bytes,
577 );
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<Account> for UnderlyingRustTuple<'_> {
592 fn from(value: Account) -> Self {
593 (value.proof, value.code)
594 }
595 }
596 #[automatically_derived]
597 #[doc(hidden)]
598 impl ::core::convert::From<UnderlyingRustTuple<'_>> for Account {
599 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
600 Self {
601 proof: tuple.0,
602 code: tuple.1,
603 }
604 }
605 }
606 #[automatically_derived]
607 impl alloy_sol_types::SolValue for Account {
608 type SolType = Self;
609 }
610 #[automatically_derived]
611 impl alloy_sol_types::private::SolTypeValue<Self> for Account {
612 #[inline]
613 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
614 (
615 <AccountProof as alloy_sol_types::SolType>::tokenize(&self.proof),
616 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
617 &self.code,
618 ),
619 )
620 }
621 #[inline]
622 fn stv_abi_encoded_size(&self) -> usize {
623 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
624 return size;
625 }
626 let tuple = <UnderlyingRustTuple<
627 '_,
628 > as ::core::convert::From<Self>>::from(self.clone());
629 <UnderlyingSolTuple<
630 '_,
631 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
632 }
633 #[inline]
634 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
635 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
636 }
637 #[inline]
638 fn stv_abi_encode_packed_to(
639 &self,
640 out: &mut alloy_sol_types::private::Vec<u8>,
641 ) {
642 let tuple = <UnderlyingRustTuple<
643 '_,
644 > as ::core::convert::From<Self>>::from(self.clone());
645 <UnderlyingSolTuple<
646 '_,
647 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
648 }
649 #[inline]
650 fn stv_abi_packed_encoded_size(&self) -> usize {
651 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
652 return size;
653 }
654 let tuple = <UnderlyingRustTuple<
655 '_,
656 > as ::core::convert::From<Self>>::from(self.clone());
657 <UnderlyingSolTuple<
658 '_,
659 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
660 }
661 }
662 #[automatically_derived]
663 impl alloy_sol_types::SolType for Account {
664 type RustType = Self;
665 type Token<'a> = <UnderlyingSolTuple<
666 'a,
667 > as alloy_sol_types::SolType>::Token<'a>;
668 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
669 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
670 '_,
671 > as alloy_sol_types::SolType>::ENCODED_SIZE;
672 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
673 '_,
674 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
675 #[inline]
676 fn valid_token(token: &Self::Token<'_>) -> bool {
677 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
678 }
679 #[inline]
680 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
681 let tuple = <UnderlyingSolTuple<
682 '_,
683 > as alloy_sol_types::SolType>::detokenize(token);
684 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
685 }
686 }
687 #[automatically_derived]
688 impl alloy_sol_types::SolStruct for Account {
689 const NAME: &'static str = "Account";
690 #[inline]
691 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
692 alloy_sol_types::private::Cow::Borrowed(
693 "Account(AccountProof proof,bytes code)",
694 )
695 }
696 #[inline]
697 fn eip712_components() -> alloy_sol_types::private::Vec<
698 alloy_sol_types::private::Cow<'static, str>,
699 > {
700 let mut components = alloy_sol_types::private::Vec::with_capacity(1);
701 components
702 .push(
703 <AccountProof as alloy_sol_types::SolStruct>::eip712_root_type(),
704 );
705 components
706 .extend(
707 <AccountProof as alloy_sol_types::SolStruct>::eip712_components(),
708 );
709 components
710 }
711 #[inline]
712 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
713 [
714 <AccountProof as alloy_sol_types::SolType>::eip712_data_word(
715 &self.proof,
716 )
717 .0,
718 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
719 &self.code,
720 )
721 .0,
722 ]
723 .concat()
724 }
725 }
726 #[automatically_derived]
727 impl alloy_sol_types::EventTopic for Account {
728 #[inline]
729 fn topic_preimage_length(rust: &Self::RustType) -> usize {
730 0usize
731 + <AccountProof as alloy_sol_types::EventTopic>::topic_preimage_length(
732 &rust.proof,
733 )
734 + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
735 &rust.code,
736 )
737 }
738 #[inline]
739 fn encode_topic_preimage(
740 rust: &Self::RustType,
741 out: &mut alloy_sol_types::private::Vec<u8>,
742 ) {
743 out.reserve(
744 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
745 );
746 <AccountProof as alloy_sol_types::EventTopic>::encode_topic_preimage(
747 &rust.proof,
748 out,
749 );
750 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
751 &rust.code,
752 out,
753 );
754 }
755 #[inline]
756 fn encode_topic(
757 rust: &Self::RustType,
758 ) -> alloy_sol_types::abi::token::WordToken {
759 let mut out = alloy_sol_types::private::Vec::new();
760 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
761 rust,
762 &mut out,
763 );
764 alloy_sol_types::abi::token::WordToken(
765 alloy_sol_types::private::keccak256(out),
766 )
767 }
768 }
769 };
770 #[derive(Default, Debug, PartialEq, Eq, Hash)]
771 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
775 #[derive(Clone)]
776 pub struct AccountProof {
777 #[allow(missing_docs)]
778 pub addr: alloy::sol_types::private::Address,
779 #[allow(missing_docs)]
780 pub accountProof: alloy::sol_types::private::Vec<
781 alloy::sol_types::private::Bytes,
782 >,
783 #[allow(missing_docs)]
784 pub balance: alloy::sol_types::private::primitives::aliases::U256,
785 #[allow(missing_docs)]
786 pub codeHash: alloy::sol_types::private::FixedBytes<32>,
787 #[allow(missing_docs)]
788 pub nonce: alloy::sol_types::private::primitives::aliases::U256,
789 #[allow(missing_docs)]
790 pub storageHash: alloy::sol_types::private::FixedBytes<32>,
791 #[allow(missing_docs)]
792 pub storageProof: alloy::sol_types::private::Vec<
793 <StorageProof as alloy::sol_types::SolType>::RustType,
794 >,
795 }
796 #[allow(
797 non_camel_case_types,
798 non_snake_case,
799 clippy::pub_underscore_fields,
800 clippy::style
801 )]
802 const _: () = {
803 use alloy::sol_types as alloy_sol_types;
804 #[doc(hidden)]
805 type UnderlyingSolTuple<'a> = (
806 alloy::sol_types::sol_data::Address,
807 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
808 alloy::sol_types::sol_data::Uint<256>,
809 alloy::sol_types::sol_data::FixedBytes<32>,
810 alloy::sol_types::sol_data::Uint<256>,
811 alloy::sol_types::sol_data::FixedBytes<32>,
812 alloy::sol_types::sol_data::Array<StorageProof>,
813 );
814 #[doc(hidden)]
815 type UnderlyingRustTuple<'a> = (
816 alloy::sol_types::private::Address,
817 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
818 alloy::sol_types::private::primitives::aliases::U256,
819 alloy::sol_types::private::FixedBytes<32>,
820 alloy::sol_types::private::primitives::aliases::U256,
821 alloy::sol_types::private::FixedBytes<32>,
822 alloy::sol_types::private::Vec<
823 <StorageProof as alloy::sol_types::SolType>::RustType,
824 >,
825 );
826 #[cfg(test)]
827 #[allow(dead_code, unreachable_patterns)]
828 fn _type_assertion(
829 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
830 ) {
831 match _t {
832 alloy_sol_types::private::AssertTypeEq::<
833 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
834 >(_) => {}
835 }
836 }
837 #[automatically_derived]
838 #[doc(hidden)]
839 impl ::core::convert::From<AccountProof> for UnderlyingRustTuple<'_> {
840 fn from(value: AccountProof) -> Self {
841 (
842 value.addr,
843 value.accountProof,
844 value.balance,
845 value.codeHash,
846 value.nonce,
847 value.storageHash,
848 value.storageProof,
849 )
850 }
851 }
852 #[automatically_derived]
853 #[doc(hidden)]
854 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AccountProof {
855 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
856 Self {
857 addr: tuple.0,
858 accountProof: tuple.1,
859 balance: tuple.2,
860 codeHash: tuple.3,
861 nonce: tuple.4,
862 storageHash: tuple.5,
863 storageProof: tuple.6,
864 }
865 }
866 }
867 #[automatically_derived]
868 impl alloy_sol_types::SolValue for AccountProof {
869 type SolType = Self;
870 }
871 #[automatically_derived]
872 impl alloy_sol_types::private::SolTypeValue<Self> for AccountProof {
873 #[inline]
874 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
875 (
876 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
877 &self.addr,
878 ),
879 <alloy::sol_types::sol_data::Array<
880 alloy::sol_types::sol_data::Bytes,
881 > as alloy_sol_types::SolType>::tokenize(&self.accountProof),
882 <alloy::sol_types::sol_data::Uint<
883 256,
884 > as alloy_sol_types::SolType>::tokenize(&self.balance),
885 <alloy::sol_types::sol_data::FixedBytes<
886 32,
887 > as alloy_sol_types::SolType>::tokenize(&self.codeHash),
888 <alloy::sol_types::sol_data::Uint<
889 256,
890 > as alloy_sol_types::SolType>::tokenize(&self.nonce),
891 <alloy::sol_types::sol_data::FixedBytes<
892 32,
893 > as alloy_sol_types::SolType>::tokenize(&self.storageHash),
894 <alloy::sol_types::sol_data::Array<
895 StorageProof,
896 > as alloy_sol_types::SolType>::tokenize(&self.storageProof),
897 )
898 }
899 #[inline]
900 fn stv_abi_encoded_size(&self) -> usize {
901 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
902 return size;
903 }
904 let tuple = <UnderlyingRustTuple<
905 '_,
906 > as ::core::convert::From<Self>>::from(self.clone());
907 <UnderlyingSolTuple<
908 '_,
909 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
910 }
911 #[inline]
912 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
913 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
914 }
915 #[inline]
916 fn stv_abi_encode_packed_to(
917 &self,
918 out: &mut alloy_sol_types::private::Vec<u8>,
919 ) {
920 let tuple = <UnderlyingRustTuple<
921 '_,
922 > as ::core::convert::From<Self>>::from(self.clone());
923 <UnderlyingSolTuple<
924 '_,
925 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
926 }
927 #[inline]
928 fn stv_abi_packed_encoded_size(&self) -> usize {
929 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
930 return size;
931 }
932 let tuple = <UnderlyingRustTuple<
933 '_,
934 > as ::core::convert::From<Self>>::from(self.clone());
935 <UnderlyingSolTuple<
936 '_,
937 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
938 }
939 }
940 #[automatically_derived]
941 impl alloy_sol_types::SolType for AccountProof {
942 type RustType = Self;
943 type Token<'a> = <UnderlyingSolTuple<
944 'a,
945 > as alloy_sol_types::SolType>::Token<'a>;
946 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
947 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
948 '_,
949 > as alloy_sol_types::SolType>::ENCODED_SIZE;
950 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
951 '_,
952 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
953 #[inline]
954 fn valid_token(token: &Self::Token<'_>) -> bool {
955 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
956 }
957 #[inline]
958 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
959 let tuple = <UnderlyingSolTuple<
960 '_,
961 > as alloy_sol_types::SolType>::detokenize(token);
962 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
963 }
964 }
965 #[automatically_derived]
966 impl alloy_sol_types::SolStruct for AccountProof {
967 const NAME: &'static str = "AccountProof";
968 #[inline]
969 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
970 alloy_sol_types::private::Cow::Borrowed(
971 "AccountProof(address addr,bytes[] accountProof,uint256 balance,bytes32 codeHash,uint256 nonce,bytes32 storageHash,StorageProof[] storageProof)",
972 )
973 }
974 #[inline]
975 fn eip712_components() -> alloy_sol_types::private::Vec<
976 alloy_sol_types::private::Cow<'static, str>,
977 > {
978 let mut components = alloy_sol_types::private::Vec::with_capacity(1);
979 components
980 .push(
981 <StorageProof as alloy_sol_types::SolStruct>::eip712_root_type(),
982 );
983 components
984 .extend(
985 <StorageProof as alloy_sol_types::SolStruct>::eip712_components(),
986 );
987 components
988 }
989 #[inline]
990 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
991 [
992 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
993 &self.addr,
994 )
995 .0,
996 <alloy::sol_types::sol_data::Array<
997 alloy::sol_types::sol_data::Bytes,
998 > as alloy_sol_types::SolType>::eip712_data_word(&self.accountProof)
999 .0,
1000 <alloy::sol_types::sol_data::Uint<
1001 256,
1002 > as alloy_sol_types::SolType>::eip712_data_word(&self.balance)
1003 .0,
1004 <alloy::sol_types::sol_data::FixedBytes<
1005 32,
1006 > as alloy_sol_types::SolType>::eip712_data_word(&self.codeHash)
1007 .0,
1008 <alloy::sol_types::sol_data::Uint<
1009 256,
1010 > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
1011 .0,
1012 <alloy::sol_types::sol_data::FixedBytes<
1013 32,
1014 > as alloy_sol_types::SolType>::eip712_data_word(&self.storageHash)
1015 .0,
1016 <alloy::sol_types::sol_data::Array<
1017 StorageProof,
1018 > as alloy_sol_types::SolType>::eip712_data_word(&self.storageProof)
1019 .0,
1020 ]
1021 .concat()
1022 }
1023 }
1024 #[automatically_derived]
1025 impl alloy_sol_types::EventTopic for AccountProof {
1026 #[inline]
1027 fn topic_preimage_length(rust: &Self::RustType) -> usize {
1028 0usize
1029 + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1030 &rust.addr,
1031 )
1032 + <alloy::sol_types::sol_data::Array<
1033 alloy::sol_types::sol_data::Bytes,
1034 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1035 &rust.accountProof,
1036 )
1037 + <alloy::sol_types::sol_data::Uint<
1038 256,
1039 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1040 &rust.balance,
1041 )
1042 + <alloy::sol_types::sol_data::FixedBytes<
1043 32,
1044 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1045 &rust.codeHash,
1046 )
1047 + <alloy::sol_types::sol_data::Uint<
1048 256,
1049 > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
1050 + <alloy::sol_types::sol_data::FixedBytes<
1051 32,
1052 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1053 &rust.storageHash,
1054 )
1055 + <alloy::sol_types::sol_data::Array<
1056 StorageProof,
1057 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1058 &rust.storageProof,
1059 )
1060 }
1061 #[inline]
1062 fn encode_topic_preimage(
1063 rust: &Self::RustType,
1064 out: &mut alloy_sol_types::private::Vec<u8>,
1065 ) {
1066 out.reserve(
1067 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1068 );
1069 <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1070 &rust.addr,
1071 out,
1072 );
1073 <alloy::sol_types::sol_data::Array<
1074 alloy::sol_types::sol_data::Bytes,
1075 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1076 &rust.accountProof,
1077 out,
1078 );
1079 <alloy::sol_types::sol_data::Uint<
1080 256,
1081 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1082 &rust.balance,
1083 out,
1084 );
1085 <alloy::sol_types::sol_data::FixedBytes<
1086 32,
1087 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1088 &rust.codeHash,
1089 out,
1090 );
1091 <alloy::sol_types::sol_data::Uint<
1092 256,
1093 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1094 &rust.nonce,
1095 out,
1096 );
1097 <alloy::sol_types::sol_data::FixedBytes<
1098 32,
1099 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1100 &rust.storageHash,
1101 out,
1102 );
1103 <alloy::sol_types::sol_data::Array<
1104 StorageProof,
1105 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1106 &rust.storageProof,
1107 out,
1108 );
1109 }
1110 #[inline]
1111 fn encode_topic(
1112 rust: &Self::RustType,
1113 ) -> alloy_sol_types::abi::token::WordToken {
1114 let mut out = alloy_sol_types::private::Vec::new();
1115 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1116 rust,
1117 &mut out,
1118 );
1119 alloy_sol_types::abi::token::WordToken(
1120 alloy_sol_types::private::keccak256(out),
1121 )
1122 }
1123 }
1124 };
1125 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1126 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1130 #[derive(Clone)]
1131 pub struct Claim {
1132 #[allow(missing_docs)]
1133 pub claimType: alloy::sol_types::private::String,
1134 #[allow(missing_docs)]
1135 pub trustBaseSpec: alloy::sol_types::private::String,
1136 #[allow(missing_docs)]
1137 pub assumptions: <Header as alloy::sol_types::SolType>::RustType,
1138 #[allow(missing_docs)]
1139 pub action: <EVMCall as alloy::sol_types::SolType>::RustType,
1140 #[allow(missing_docs)]
1141 pub result: alloy::sol_types::private::Bytes,
1142 #[allow(missing_docs)]
1143 pub metadata: <EVMMetadata as alloy::sol_types::SolType>::RustType,
1144 }
1145 #[allow(
1146 non_camel_case_types,
1147 non_snake_case,
1148 clippy::pub_underscore_fields,
1149 clippy::style
1150 )]
1151 const _: () = {
1152 use alloy::sol_types as alloy_sol_types;
1153 #[doc(hidden)]
1154 type UnderlyingSolTuple<'a> = (
1155 alloy::sol_types::sol_data::String,
1156 alloy::sol_types::sol_data::String,
1157 Header,
1158 EVMCall,
1159 alloy::sol_types::sol_data::Bytes,
1160 EVMMetadata,
1161 );
1162 #[doc(hidden)]
1163 type UnderlyingRustTuple<'a> = (
1164 alloy::sol_types::private::String,
1165 alloy::sol_types::private::String,
1166 <Header as alloy::sol_types::SolType>::RustType,
1167 <EVMCall as alloy::sol_types::SolType>::RustType,
1168 alloy::sol_types::private::Bytes,
1169 <EVMMetadata as alloy::sol_types::SolType>::RustType,
1170 );
1171 #[cfg(test)]
1172 #[allow(dead_code, unreachable_patterns)]
1173 fn _type_assertion(
1174 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1175 ) {
1176 match _t {
1177 alloy_sol_types::private::AssertTypeEq::<
1178 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1179 >(_) => {}
1180 }
1181 }
1182 #[automatically_derived]
1183 #[doc(hidden)]
1184 impl ::core::convert::From<Claim> for UnderlyingRustTuple<'_> {
1185 fn from(value: Claim) -> Self {
1186 (
1187 value.claimType,
1188 value.trustBaseSpec,
1189 value.assumptions,
1190 value.action,
1191 value.result,
1192 value.metadata,
1193 )
1194 }
1195 }
1196 #[automatically_derived]
1197 #[doc(hidden)]
1198 impl ::core::convert::From<UnderlyingRustTuple<'_>> for Claim {
1199 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1200 Self {
1201 claimType: tuple.0,
1202 trustBaseSpec: tuple.1,
1203 assumptions: tuple.2,
1204 action: tuple.3,
1205 result: tuple.4,
1206 metadata: tuple.5,
1207 }
1208 }
1209 }
1210 #[automatically_derived]
1211 impl alloy_sol_types::SolValue for Claim {
1212 type SolType = Self;
1213 }
1214 #[automatically_derived]
1215 impl alloy_sol_types::private::SolTypeValue<Self> for Claim {
1216 #[inline]
1217 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1218 (
1219 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1220 &self.claimType,
1221 ),
1222 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1223 &self.trustBaseSpec,
1224 ),
1225 <Header as alloy_sol_types::SolType>::tokenize(&self.assumptions),
1226 <EVMCall as alloy_sol_types::SolType>::tokenize(&self.action),
1227 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1228 &self.result,
1229 ),
1230 <EVMMetadata as alloy_sol_types::SolType>::tokenize(&self.metadata),
1231 )
1232 }
1233 #[inline]
1234 fn stv_abi_encoded_size(&self) -> usize {
1235 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1236 return size;
1237 }
1238 let tuple = <UnderlyingRustTuple<
1239 '_,
1240 > as ::core::convert::From<Self>>::from(self.clone());
1241 <UnderlyingSolTuple<
1242 '_,
1243 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1244 }
1245 #[inline]
1246 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1247 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1248 }
1249 #[inline]
1250 fn stv_abi_encode_packed_to(
1251 &self,
1252 out: &mut alloy_sol_types::private::Vec<u8>,
1253 ) {
1254 let tuple = <UnderlyingRustTuple<
1255 '_,
1256 > as ::core::convert::From<Self>>::from(self.clone());
1257 <UnderlyingSolTuple<
1258 '_,
1259 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1260 }
1261 #[inline]
1262 fn stv_abi_packed_encoded_size(&self) -> usize {
1263 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1264 return size;
1265 }
1266 let tuple = <UnderlyingRustTuple<
1267 '_,
1268 > as ::core::convert::From<Self>>::from(self.clone());
1269 <UnderlyingSolTuple<
1270 '_,
1271 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1272 }
1273 }
1274 #[automatically_derived]
1275 impl alloy_sol_types::SolType for Claim {
1276 type RustType = Self;
1277 type Token<'a> = <UnderlyingSolTuple<
1278 'a,
1279 > as alloy_sol_types::SolType>::Token<'a>;
1280 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1281 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1282 '_,
1283 > as alloy_sol_types::SolType>::ENCODED_SIZE;
1284 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1285 '_,
1286 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1287 #[inline]
1288 fn valid_token(token: &Self::Token<'_>) -> bool {
1289 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1290 }
1291 #[inline]
1292 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1293 let tuple = <UnderlyingSolTuple<
1294 '_,
1295 > as alloy_sol_types::SolType>::detokenize(token);
1296 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1297 }
1298 }
1299 #[automatically_derived]
1300 impl alloy_sol_types::SolStruct for Claim {
1301 const NAME: &'static str = "Claim";
1302 #[inline]
1303 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1304 alloy_sol_types::private::Cow::Borrowed(
1305 "Claim(string claimType,string trustBaseSpec,Header assumptions,EVMCall action,bytes result,EVMMetadata metadata)",
1306 )
1307 }
1308 #[inline]
1309 fn eip712_components() -> alloy_sol_types::private::Vec<
1310 alloy_sol_types::private::Cow<'static, str>,
1311 > {
1312 let mut components = alloy_sol_types::private::Vec::with_capacity(3);
1313 components
1314 .push(<Header as alloy_sol_types::SolStruct>::eip712_root_type());
1315 components
1316 .extend(<Header as alloy_sol_types::SolStruct>::eip712_components());
1317 components
1318 .push(<EVMCall as alloy_sol_types::SolStruct>::eip712_root_type());
1319 components
1320 .extend(
1321 <EVMCall as alloy_sol_types::SolStruct>::eip712_components(),
1322 );
1323 components
1324 .push(
1325 <EVMMetadata as alloy_sol_types::SolStruct>::eip712_root_type(),
1326 );
1327 components
1328 .extend(
1329 <EVMMetadata as alloy_sol_types::SolStruct>::eip712_components(),
1330 );
1331 components
1332 }
1333 #[inline]
1334 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1335 [
1336 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
1337 &self.claimType,
1338 )
1339 .0,
1340 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
1341 &self.trustBaseSpec,
1342 )
1343 .0,
1344 <Header as alloy_sol_types::SolType>::eip712_data_word(
1345 &self.assumptions,
1346 )
1347 .0,
1348 <EVMCall as alloy_sol_types::SolType>::eip712_data_word(&self.action)
1349 .0,
1350 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
1351 &self.result,
1352 )
1353 .0,
1354 <EVMMetadata as alloy_sol_types::SolType>::eip712_data_word(
1355 &self.metadata,
1356 )
1357 .0,
1358 ]
1359 .concat()
1360 }
1361 }
1362 #[automatically_derived]
1363 impl alloy_sol_types::EventTopic for Claim {
1364 #[inline]
1365 fn topic_preimage_length(rust: &Self::RustType) -> usize {
1366 0usize
1367 + <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
1368 &rust.claimType,
1369 )
1370 + <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
1371 &rust.trustBaseSpec,
1372 )
1373 + <Header as alloy_sol_types::EventTopic>::topic_preimage_length(
1374 &rust.assumptions,
1375 )
1376 + <EVMCall as alloy_sol_types::EventTopic>::topic_preimage_length(
1377 &rust.action,
1378 )
1379 + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
1380 &rust.result,
1381 )
1382 + <EVMMetadata as alloy_sol_types::EventTopic>::topic_preimage_length(
1383 &rust.metadata,
1384 )
1385 }
1386 #[inline]
1387 fn encode_topic_preimage(
1388 rust: &Self::RustType,
1389 out: &mut alloy_sol_types::private::Vec<u8>,
1390 ) {
1391 out.reserve(
1392 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1393 );
1394 <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
1395 &rust.claimType,
1396 out,
1397 );
1398 <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
1399 &rust.trustBaseSpec,
1400 out,
1401 );
1402 <Header as alloy_sol_types::EventTopic>::encode_topic_preimage(
1403 &rust.assumptions,
1404 out,
1405 );
1406 <EVMCall as alloy_sol_types::EventTopic>::encode_topic_preimage(
1407 &rust.action,
1408 out,
1409 );
1410 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
1411 &rust.result,
1412 out,
1413 );
1414 <EVMMetadata as alloy_sol_types::EventTopic>::encode_topic_preimage(
1415 &rust.metadata,
1416 out,
1417 );
1418 }
1419 #[inline]
1420 fn encode_topic(
1421 rust: &Self::RustType,
1422 ) -> alloy_sol_types::abi::token::WordToken {
1423 let mut out = alloy_sol_types::private::Vec::new();
1424 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1425 rust,
1426 &mut out,
1427 );
1428 alloy_sol_types::abi::token::WordToken(
1429 alloy_sol_types::private::keccak256(out),
1430 )
1431 }
1432 }
1433 };
1434 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1435 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1439 #[derive(Clone)]
1440 pub struct EVMCall {
1441 #[allow(missing_docs)]
1442 pub from: alloy::sol_types::private::Address,
1443 #[allow(missing_docs)]
1444 pub to: alloy::sol_types::private::Address,
1445 #[allow(missing_docs)]
1446 pub input: alloy::sol_types::private::Bytes,
1447 }
1448 #[allow(
1449 non_camel_case_types,
1450 non_snake_case,
1451 clippy::pub_underscore_fields,
1452 clippy::style
1453 )]
1454 const _: () = {
1455 use alloy::sol_types as alloy_sol_types;
1456 #[doc(hidden)]
1457 type UnderlyingSolTuple<'a> = (
1458 alloy::sol_types::sol_data::Address,
1459 alloy::sol_types::sol_data::Address,
1460 alloy::sol_types::sol_data::Bytes,
1461 );
1462 #[doc(hidden)]
1463 type UnderlyingRustTuple<'a> = (
1464 alloy::sol_types::private::Address,
1465 alloy::sol_types::private::Address,
1466 alloy::sol_types::private::Bytes,
1467 );
1468 #[cfg(test)]
1469 #[allow(dead_code, unreachable_patterns)]
1470 fn _type_assertion(
1471 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1472 ) {
1473 match _t {
1474 alloy_sol_types::private::AssertTypeEq::<
1475 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1476 >(_) => {}
1477 }
1478 }
1479 #[automatically_derived]
1480 #[doc(hidden)]
1481 impl ::core::convert::From<EVMCall> for UnderlyingRustTuple<'_> {
1482 fn from(value: EVMCall) -> Self {
1483 (value.from, value.to, value.input)
1484 }
1485 }
1486 #[automatically_derived]
1487 #[doc(hidden)]
1488 impl ::core::convert::From<UnderlyingRustTuple<'_>> for EVMCall {
1489 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1490 Self {
1491 from: tuple.0,
1492 to: tuple.1,
1493 input: tuple.2,
1494 }
1495 }
1496 }
1497 #[automatically_derived]
1498 impl alloy_sol_types::SolValue for EVMCall {
1499 type SolType = Self;
1500 }
1501 #[automatically_derived]
1502 impl alloy_sol_types::private::SolTypeValue<Self> for EVMCall {
1503 #[inline]
1504 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1505 (
1506 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1507 &self.from,
1508 ),
1509 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1510 &self.to,
1511 ),
1512 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1513 &self.input,
1514 ),
1515 )
1516 }
1517 #[inline]
1518 fn stv_abi_encoded_size(&self) -> usize {
1519 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1520 return size;
1521 }
1522 let tuple = <UnderlyingRustTuple<
1523 '_,
1524 > as ::core::convert::From<Self>>::from(self.clone());
1525 <UnderlyingSolTuple<
1526 '_,
1527 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1528 }
1529 #[inline]
1530 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1531 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1532 }
1533 #[inline]
1534 fn stv_abi_encode_packed_to(
1535 &self,
1536 out: &mut alloy_sol_types::private::Vec<u8>,
1537 ) {
1538 let tuple = <UnderlyingRustTuple<
1539 '_,
1540 > as ::core::convert::From<Self>>::from(self.clone());
1541 <UnderlyingSolTuple<
1542 '_,
1543 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1544 }
1545 #[inline]
1546 fn stv_abi_packed_encoded_size(&self) -> usize {
1547 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1548 return size;
1549 }
1550 let tuple = <UnderlyingRustTuple<
1551 '_,
1552 > as ::core::convert::From<Self>>::from(self.clone());
1553 <UnderlyingSolTuple<
1554 '_,
1555 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1556 }
1557 }
1558 #[automatically_derived]
1559 impl alloy_sol_types::SolType for EVMCall {
1560 type RustType = Self;
1561 type Token<'a> = <UnderlyingSolTuple<
1562 'a,
1563 > as alloy_sol_types::SolType>::Token<'a>;
1564 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1565 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1566 '_,
1567 > as alloy_sol_types::SolType>::ENCODED_SIZE;
1568 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1569 '_,
1570 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1571 #[inline]
1572 fn valid_token(token: &Self::Token<'_>) -> bool {
1573 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1574 }
1575 #[inline]
1576 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1577 let tuple = <UnderlyingSolTuple<
1578 '_,
1579 > as alloy_sol_types::SolType>::detokenize(token);
1580 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1581 }
1582 }
1583 #[automatically_derived]
1584 impl alloy_sol_types::SolStruct for EVMCall {
1585 const NAME: &'static str = "EVMCall";
1586 #[inline]
1587 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1588 alloy_sol_types::private::Cow::Borrowed(
1589 "EVMCall(address from,address to,bytes input)",
1590 )
1591 }
1592 #[inline]
1593 fn eip712_components() -> alloy_sol_types::private::Vec<
1594 alloy_sol_types::private::Cow<'static, str>,
1595 > {
1596 alloy_sol_types::private::Vec::new()
1597 }
1598 #[inline]
1599 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1600 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1601 }
1602 #[inline]
1603 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1604 [
1605 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1606 &self.from,
1607 )
1608 .0,
1609 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1610 &self.to,
1611 )
1612 .0,
1613 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
1614 &self.input,
1615 )
1616 .0,
1617 ]
1618 .concat()
1619 }
1620 }
1621 #[automatically_derived]
1622 impl alloy_sol_types::EventTopic for EVMCall {
1623 #[inline]
1624 fn topic_preimage_length(rust: &Self::RustType) -> usize {
1625 0usize
1626 + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1627 &rust.from,
1628 )
1629 + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1630 &rust.to,
1631 )
1632 + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
1633 &rust.input,
1634 )
1635 }
1636 #[inline]
1637 fn encode_topic_preimage(
1638 rust: &Self::RustType,
1639 out: &mut alloy_sol_types::private::Vec<u8>,
1640 ) {
1641 out.reserve(
1642 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1643 );
1644 <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1645 &rust.from,
1646 out,
1647 );
1648 <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1649 &rust.to,
1650 out,
1651 );
1652 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
1653 &rust.input,
1654 out,
1655 );
1656 }
1657 #[inline]
1658 fn encode_topic(
1659 rust: &Self::RustType,
1660 ) -> alloy_sol_types::abi::token::WordToken {
1661 let mut out = alloy_sol_types::private::Vec::new();
1662 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1663 rust,
1664 &mut out,
1665 );
1666 alloy_sol_types::abi::token::WordToken(
1667 alloy_sol_types::private::keccak256(out),
1668 )
1669 }
1670 }
1671 };
1672 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1673 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1677 #[derive(Clone)]
1678 pub struct EVMMetadata {
1679 #[allow(missing_docs)]
1680 pub chainId: alloy::sol_types::private::primitives::aliases::U256,
1681 }
1682 #[allow(
1683 non_camel_case_types,
1684 non_snake_case,
1685 clippy::pub_underscore_fields,
1686 clippy::style
1687 )]
1688 const _: () = {
1689 use alloy::sol_types as alloy_sol_types;
1690 #[doc(hidden)]
1691 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1692 #[doc(hidden)]
1693 type UnderlyingRustTuple<'a> = (
1694 alloy::sol_types::private::primitives::aliases::U256,
1695 );
1696 #[cfg(test)]
1697 #[allow(dead_code, unreachable_patterns)]
1698 fn _type_assertion(
1699 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1700 ) {
1701 match _t {
1702 alloy_sol_types::private::AssertTypeEq::<
1703 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1704 >(_) => {}
1705 }
1706 }
1707 #[automatically_derived]
1708 #[doc(hidden)]
1709 impl ::core::convert::From<EVMMetadata> for UnderlyingRustTuple<'_> {
1710 fn from(value: EVMMetadata) -> Self {
1711 (value.chainId,)
1712 }
1713 }
1714 #[automatically_derived]
1715 #[doc(hidden)]
1716 impl ::core::convert::From<UnderlyingRustTuple<'_>> for EVMMetadata {
1717 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1718 Self { chainId: tuple.0 }
1719 }
1720 }
1721 #[automatically_derived]
1722 impl alloy_sol_types::SolValue for EVMMetadata {
1723 type SolType = Self;
1724 }
1725 #[automatically_derived]
1726 impl alloy_sol_types::private::SolTypeValue<Self> for EVMMetadata {
1727 #[inline]
1728 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1729 (
1730 <alloy::sol_types::sol_data::Uint<
1731 256,
1732 > as alloy_sol_types::SolType>::tokenize(&self.chainId),
1733 )
1734 }
1735 #[inline]
1736 fn stv_abi_encoded_size(&self) -> usize {
1737 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1738 return size;
1739 }
1740 let tuple = <UnderlyingRustTuple<
1741 '_,
1742 > as ::core::convert::From<Self>>::from(self.clone());
1743 <UnderlyingSolTuple<
1744 '_,
1745 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1746 }
1747 #[inline]
1748 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1749 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1750 }
1751 #[inline]
1752 fn stv_abi_encode_packed_to(
1753 &self,
1754 out: &mut alloy_sol_types::private::Vec<u8>,
1755 ) {
1756 let tuple = <UnderlyingRustTuple<
1757 '_,
1758 > as ::core::convert::From<Self>>::from(self.clone());
1759 <UnderlyingSolTuple<
1760 '_,
1761 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1762 }
1763 #[inline]
1764 fn stv_abi_packed_encoded_size(&self) -> usize {
1765 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1766 return size;
1767 }
1768 let tuple = <UnderlyingRustTuple<
1769 '_,
1770 > as ::core::convert::From<Self>>::from(self.clone());
1771 <UnderlyingSolTuple<
1772 '_,
1773 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1774 }
1775 }
1776 #[automatically_derived]
1777 impl alloy_sol_types::SolType for EVMMetadata {
1778 type RustType = Self;
1779 type Token<'a> = <UnderlyingSolTuple<
1780 'a,
1781 > as alloy_sol_types::SolType>::Token<'a>;
1782 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1783 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1784 '_,
1785 > as alloy_sol_types::SolType>::ENCODED_SIZE;
1786 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1787 '_,
1788 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1789 #[inline]
1790 fn valid_token(token: &Self::Token<'_>) -> bool {
1791 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1792 }
1793 #[inline]
1794 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1795 let tuple = <UnderlyingSolTuple<
1796 '_,
1797 > as alloy_sol_types::SolType>::detokenize(token);
1798 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1799 }
1800 }
1801 #[automatically_derived]
1802 impl alloy_sol_types::SolStruct for EVMMetadata {
1803 const NAME: &'static str = "EVMMetadata";
1804 #[inline]
1805 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1806 alloy_sol_types::private::Cow::Borrowed("EVMMetadata(uint256 chainId)")
1807 }
1808 #[inline]
1809 fn eip712_components() -> alloy_sol_types::private::Vec<
1810 alloy_sol_types::private::Cow<'static, str>,
1811 > {
1812 alloy_sol_types::private::Vec::new()
1813 }
1814 #[inline]
1815 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1816 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1817 }
1818 #[inline]
1819 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1820 <alloy::sol_types::sol_data::Uint<
1821 256,
1822 > as alloy_sol_types::SolType>::eip712_data_word(&self.chainId)
1823 .0
1824 .to_vec()
1825 }
1826 }
1827 #[automatically_derived]
1828 impl alloy_sol_types::EventTopic for EVMMetadata {
1829 #[inline]
1830 fn topic_preimage_length(rust: &Self::RustType) -> usize {
1831 0usize
1832 + <alloy::sol_types::sol_data::Uint<
1833 256,
1834 > as alloy_sol_types::EventTopic>::topic_preimage_length(
1835 &rust.chainId,
1836 )
1837 }
1838 #[inline]
1839 fn encode_topic_preimage(
1840 rust: &Self::RustType,
1841 out: &mut alloy_sol_types::private::Vec<u8>,
1842 ) {
1843 out.reserve(
1844 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1845 );
1846 <alloy::sol_types::sol_data::Uint<
1847 256,
1848 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1849 &rust.chainId,
1850 out,
1851 );
1852 }
1853 #[inline]
1854 fn encode_topic(
1855 rust: &Self::RustType,
1856 ) -> alloy_sol_types::abi::token::WordToken {
1857 let mut out = alloy_sol_types::private::Vec::new();
1858 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1859 rust,
1860 &mut out,
1861 );
1862 alloy_sol_types::abi::token::WordToken(
1863 alloy_sol_types::private::keccak256(out),
1864 )
1865 }
1866 }
1867 };
1868 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1869 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1873 #[derive(Clone)]
1874 pub struct Header {
1875 #[allow(missing_docs)]
1876 pub parentHash: alloy::sol_types::private::FixedBytes<32>,
1877 #[allow(missing_docs)]
1878 pub uncleHash: alloy::sol_types::private::FixedBytes<32>,
1879 #[allow(missing_docs)]
1880 pub coinbase: alloy::sol_types::private::Address,
1881 #[allow(missing_docs)]
1882 pub root: alloy::sol_types::private::FixedBytes<32>,
1883 #[allow(missing_docs)]
1884 pub txHash: alloy::sol_types::private::FixedBytes<32>,
1885 #[allow(missing_docs)]
1886 pub receiptHash: alloy::sol_types::private::FixedBytes<32>,
1887 #[allow(missing_docs)]
1888 pub bloom: alloy::sol_types::private::Bytes,
1889 #[allow(missing_docs)]
1890 pub difficulty: alloy::sol_types::private::primitives::aliases::U256,
1891 #[allow(missing_docs)]
1892 pub number: alloy::sol_types::private::primitives::aliases::U256,
1893 #[allow(missing_docs)]
1894 pub gasLimit: alloy::sol_types::private::primitives::aliases::U256,
1895 #[allow(missing_docs)]
1896 pub gasUsed: alloy::sol_types::private::primitives::aliases::U256,
1897 #[allow(missing_docs)]
1898 pub time: alloy::sol_types::private::primitives::aliases::U256,
1899 #[allow(missing_docs)]
1900 pub extra: alloy::sol_types::private::Bytes,
1901 #[allow(missing_docs)]
1902 pub mixDigest: alloy::sol_types::private::FixedBytes<32>,
1903 #[allow(missing_docs)]
1904 pub nonce: alloy::sol_types::private::FixedBytes<8>,
1905 }
1906 #[allow(
1907 non_camel_case_types,
1908 non_snake_case,
1909 clippy::pub_underscore_fields,
1910 clippy::style
1911 )]
1912 const _: () = {
1913 use alloy::sol_types as alloy_sol_types;
1914 #[doc(hidden)]
1915 type UnderlyingSolTuple<'a> = (
1916 alloy::sol_types::sol_data::FixedBytes<32>,
1917 alloy::sol_types::sol_data::FixedBytes<32>,
1918 alloy::sol_types::sol_data::Address,
1919 alloy::sol_types::sol_data::FixedBytes<32>,
1920 alloy::sol_types::sol_data::FixedBytes<32>,
1921 alloy::sol_types::sol_data::FixedBytes<32>,
1922 alloy::sol_types::sol_data::Bytes,
1923 alloy::sol_types::sol_data::Uint<256>,
1924 alloy::sol_types::sol_data::Uint<256>,
1925 alloy::sol_types::sol_data::Uint<256>,
1926 alloy::sol_types::sol_data::Uint<256>,
1927 alloy::sol_types::sol_data::Uint<256>,
1928 alloy::sol_types::sol_data::Bytes,
1929 alloy::sol_types::sol_data::FixedBytes<32>,
1930 alloy::sol_types::sol_data::FixedBytes<8>,
1931 );
1932 #[doc(hidden)]
1933 type UnderlyingRustTuple<'a> = (
1934 alloy::sol_types::private::FixedBytes<32>,
1935 alloy::sol_types::private::FixedBytes<32>,
1936 alloy::sol_types::private::Address,
1937 alloy::sol_types::private::FixedBytes<32>,
1938 alloy::sol_types::private::FixedBytes<32>,
1939 alloy::sol_types::private::FixedBytes<32>,
1940 alloy::sol_types::private::Bytes,
1941 alloy::sol_types::private::primitives::aliases::U256,
1942 alloy::sol_types::private::primitives::aliases::U256,
1943 alloy::sol_types::private::primitives::aliases::U256,
1944 alloy::sol_types::private::primitives::aliases::U256,
1945 alloy::sol_types::private::primitives::aliases::U256,
1946 alloy::sol_types::private::Bytes,
1947 alloy::sol_types::private::FixedBytes<32>,
1948 alloy::sol_types::private::FixedBytes<8>,
1949 );
1950 #[cfg(test)]
1951 #[allow(dead_code, unreachable_patterns)]
1952 fn _type_assertion(
1953 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1954 ) {
1955 match _t {
1956 alloy_sol_types::private::AssertTypeEq::<
1957 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1958 >(_) => {}
1959 }
1960 }
1961 #[automatically_derived]
1962 #[doc(hidden)]
1963 impl ::core::convert::From<Header> for UnderlyingRustTuple<'_> {
1964 fn from(value: Header) -> Self {
1965 (
1966 value.parentHash,
1967 value.uncleHash,
1968 value.coinbase,
1969 value.root,
1970 value.txHash,
1971 value.receiptHash,
1972 value.bloom,
1973 value.difficulty,
1974 value.number,
1975 value.gasLimit,
1976 value.gasUsed,
1977 value.time,
1978 value.extra,
1979 value.mixDigest,
1980 value.nonce,
1981 )
1982 }
1983 }
1984 #[automatically_derived]
1985 #[doc(hidden)]
1986 impl ::core::convert::From<UnderlyingRustTuple<'_>> for Header {
1987 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1988 Self {
1989 parentHash: tuple.0,
1990 uncleHash: tuple.1,
1991 coinbase: tuple.2,
1992 root: tuple.3,
1993 txHash: tuple.4,
1994 receiptHash: tuple.5,
1995 bloom: tuple.6,
1996 difficulty: tuple.7,
1997 number: tuple.8,
1998 gasLimit: tuple.9,
1999 gasUsed: tuple.10,
2000 time: tuple.11,
2001 extra: tuple.12,
2002 mixDigest: tuple.13,
2003 nonce: tuple.14,
2004 }
2005 }
2006 }
2007 #[automatically_derived]
2008 impl alloy_sol_types::SolValue for Header {
2009 type SolType = Self;
2010 }
2011 #[automatically_derived]
2012 impl alloy_sol_types::private::SolTypeValue<Self> for Header {
2013 #[inline]
2014 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
2015 (
2016 <alloy::sol_types::sol_data::FixedBytes<
2017 32,
2018 > as alloy_sol_types::SolType>::tokenize(&self.parentHash),
2019 <alloy::sol_types::sol_data::FixedBytes<
2020 32,
2021 > as alloy_sol_types::SolType>::tokenize(&self.uncleHash),
2022 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2023 &self.coinbase,
2024 ),
2025 <alloy::sol_types::sol_data::FixedBytes<
2026 32,
2027 > as alloy_sol_types::SolType>::tokenize(&self.root),
2028 <alloy::sol_types::sol_data::FixedBytes<
2029 32,
2030 > as alloy_sol_types::SolType>::tokenize(&self.txHash),
2031 <alloy::sol_types::sol_data::FixedBytes<
2032 32,
2033 > as alloy_sol_types::SolType>::tokenize(&self.receiptHash),
2034 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2035 &self.bloom,
2036 ),
2037 <alloy::sol_types::sol_data::Uint<
2038 256,
2039 > as alloy_sol_types::SolType>::tokenize(&self.difficulty),
2040 <alloy::sol_types::sol_data::Uint<
2041 256,
2042 > as alloy_sol_types::SolType>::tokenize(&self.number),
2043 <alloy::sol_types::sol_data::Uint<
2044 256,
2045 > as alloy_sol_types::SolType>::tokenize(&self.gasLimit),
2046 <alloy::sol_types::sol_data::Uint<
2047 256,
2048 > as alloy_sol_types::SolType>::tokenize(&self.gasUsed),
2049 <alloy::sol_types::sol_data::Uint<
2050 256,
2051 > as alloy_sol_types::SolType>::tokenize(&self.time),
2052 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2053 &self.extra,
2054 ),
2055 <alloy::sol_types::sol_data::FixedBytes<
2056 32,
2057 > as alloy_sol_types::SolType>::tokenize(&self.mixDigest),
2058 <alloy::sol_types::sol_data::FixedBytes<
2059 8,
2060 > as alloy_sol_types::SolType>::tokenize(&self.nonce),
2061 )
2062 }
2063 #[inline]
2064 fn stv_abi_encoded_size(&self) -> usize {
2065 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
2066 return size;
2067 }
2068 let tuple = <UnderlyingRustTuple<
2069 '_,
2070 > as ::core::convert::From<Self>>::from(self.clone());
2071 <UnderlyingSolTuple<
2072 '_,
2073 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
2074 }
2075 #[inline]
2076 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2077 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
2078 }
2079 #[inline]
2080 fn stv_abi_encode_packed_to(
2081 &self,
2082 out: &mut alloy_sol_types::private::Vec<u8>,
2083 ) {
2084 let tuple = <UnderlyingRustTuple<
2085 '_,
2086 > as ::core::convert::From<Self>>::from(self.clone());
2087 <UnderlyingSolTuple<
2088 '_,
2089 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
2090 }
2091 #[inline]
2092 fn stv_abi_packed_encoded_size(&self) -> usize {
2093 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
2094 return size;
2095 }
2096 let tuple = <UnderlyingRustTuple<
2097 '_,
2098 > as ::core::convert::From<Self>>::from(self.clone());
2099 <UnderlyingSolTuple<
2100 '_,
2101 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
2102 }
2103 }
2104 #[automatically_derived]
2105 impl alloy_sol_types::SolType for Header {
2106 type RustType = Self;
2107 type Token<'a> = <UnderlyingSolTuple<
2108 'a,
2109 > as alloy_sol_types::SolType>::Token<'a>;
2110 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
2111 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2112 '_,
2113 > as alloy_sol_types::SolType>::ENCODED_SIZE;
2114 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2115 '_,
2116 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2117 #[inline]
2118 fn valid_token(token: &Self::Token<'_>) -> bool {
2119 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
2120 }
2121 #[inline]
2122 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2123 let tuple = <UnderlyingSolTuple<
2124 '_,
2125 > as alloy_sol_types::SolType>::detokenize(token);
2126 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
2127 }
2128 }
2129 #[automatically_derived]
2130 impl alloy_sol_types::SolStruct for Header {
2131 const NAME: &'static str = "Header";
2132 #[inline]
2133 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
2134 alloy_sol_types::private::Cow::Borrowed(
2135 "Header(bytes32 parentHash,bytes32 uncleHash,address coinbase,bytes32 root,bytes32 txHash,bytes32 receiptHash,bytes bloom,uint256 difficulty,uint256 number,uint256 gasLimit,uint256 gasUsed,uint256 time,bytes extra,bytes32 mixDigest,bytes8 nonce)",
2136 )
2137 }
2138 #[inline]
2139 fn eip712_components() -> alloy_sol_types::private::Vec<
2140 alloy_sol_types::private::Cow<'static, str>,
2141 > {
2142 alloy_sol_types::private::Vec::new()
2143 }
2144 #[inline]
2145 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
2146 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
2147 }
2148 #[inline]
2149 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
2150 [
2151 <alloy::sol_types::sol_data::FixedBytes<
2152 32,
2153 > as alloy_sol_types::SolType>::eip712_data_word(&self.parentHash)
2154 .0,
2155 <alloy::sol_types::sol_data::FixedBytes<
2156 32,
2157 > as alloy_sol_types::SolType>::eip712_data_word(&self.uncleHash)
2158 .0,
2159 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
2160 &self.coinbase,
2161 )
2162 .0,
2163 <alloy::sol_types::sol_data::FixedBytes<
2164 32,
2165 > as alloy_sol_types::SolType>::eip712_data_word(&self.root)
2166 .0,
2167 <alloy::sol_types::sol_data::FixedBytes<
2168 32,
2169 > as alloy_sol_types::SolType>::eip712_data_word(&self.txHash)
2170 .0,
2171 <alloy::sol_types::sol_data::FixedBytes<
2172 32,
2173 > as alloy_sol_types::SolType>::eip712_data_word(&self.receiptHash)
2174 .0,
2175 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
2176 &self.bloom,
2177 )
2178 .0,
2179 <alloy::sol_types::sol_data::Uint<
2180 256,
2181 > as alloy_sol_types::SolType>::eip712_data_word(&self.difficulty)
2182 .0,
2183 <alloy::sol_types::sol_data::Uint<
2184 256,
2185 > as alloy_sol_types::SolType>::eip712_data_word(&self.number)
2186 .0,
2187 <alloy::sol_types::sol_data::Uint<
2188 256,
2189 > as alloy_sol_types::SolType>::eip712_data_word(&self.gasLimit)
2190 .0,
2191 <alloy::sol_types::sol_data::Uint<
2192 256,
2193 > as alloy_sol_types::SolType>::eip712_data_word(&self.gasUsed)
2194 .0,
2195 <alloy::sol_types::sol_data::Uint<
2196 256,
2197 > as alloy_sol_types::SolType>::eip712_data_word(&self.time)
2198 .0,
2199 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
2200 &self.extra,
2201 )
2202 .0,
2203 <alloy::sol_types::sol_data::FixedBytes<
2204 32,
2205 > as alloy_sol_types::SolType>::eip712_data_word(&self.mixDigest)
2206 .0,
2207 <alloy::sol_types::sol_data::FixedBytes<
2208 8,
2209 > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
2210 .0,
2211 ]
2212 .concat()
2213 }
2214 }
2215 #[automatically_derived]
2216 impl alloy_sol_types::EventTopic for Header {
2217 #[inline]
2218 fn topic_preimage_length(rust: &Self::RustType) -> usize {
2219 0usize
2220 + <alloy::sol_types::sol_data::FixedBytes<
2221 32,
2222 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2223 &rust.parentHash,
2224 )
2225 + <alloy::sol_types::sol_data::FixedBytes<
2226 32,
2227 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2228 &rust.uncleHash,
2229 )
2230 + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
2231 &rust.coinbase,
2232 )
2233 + <alloy::sol_types::sol_data::FixedBytes<
2234 32,
2235 > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.root)
2236 + <alloy::sol_types::sol_data::FixedBytes<
2237 32,
2238 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2239 &rust.txHash,
2240 )
2241 + <alloy::sol_types::sol_data::FixedBytes<
2242 32,
2243 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2244 &rust.receiptHash,
2245 )
2246 + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
2247 &rust.bloom,
2248 )
2249 + <alloy::sol_types::sol_data::Uint<
2250 256,
2251 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2252 &rust.difficulty,
2253 )
2254 + <alloy::sol_types::sol_data::Uint<
2255 256,
2256 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2257 &rust.number,
2258 )
2259 + <alloy::sol_types::sol_data::Uint<
2260 256,
2261 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2262 &rust.gasLimit,
2263 )
2264 + <alloy::sol_types::sol_data::Uint<
2265 256,
2266 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2267 &rust.gasUsed,
2268 )
2269 + <alloy::sol_types::sol_data::Uint<
2270 256,
2271 > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.time)
2272 + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
2273 &rust.extra,
2274 )
2275 + <alloy::sol_types::sol_data::FixedBytes<
2276 32,
2277 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2278 &rust.mixDigest,
2279 )
2280 + <alloy::sol_types::sol_data::FixedBytes<
2281 8,
2282 > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
2283 }
2284 #[inline]
2285 fn encode_topic_preimage(
2286 rust: &Self::RustType,
2287 out: &mut alloy_sol_types::private::Vec<u8>,
2288 ) {
2289 out.reserve(
2290 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
2291 );
2292 <alloy::sol_types::sol_data::FixedBytes<
2293 32,
2294 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2295 &rust.parentHash,
2296 out,
2297 );
2298 <alloy::sol_types::sol_data::FixedBytes<
2299 32,
2300 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2301 &rust.uncleHash,
2302 out,
2303 );
2304 <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
2305 &rust.coinbase,
2306 out,
2307 );
2308 <alloy::sol_types::sol_data::FixedBytes<
2309 32,
2310 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2311 &rust.root,
2312 out,
2313 );
2314 <alloy::sol_types::sol_data::FixedBytes<
2315 32,
2316 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2317 &rust.txHash,
2318 out,
2319 );
2320 <alloy::sol_types::sol_data::FixedBytes<
2321 32,
2322 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2323 &rust.receiptHash,
2324 out,
2325 );
2326 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
2327 &rust.bloom,
2328 out,
2329 );
2330 <alloy::sol_types::sol_data::Uint<
2331 256,
2332 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2333 &rust.difficulty,
2334 out,
2335 );
2336 <alloy::sol_types::sol_data::Uint<
2337 256,
2338 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2339 &rust.number,
2340 out,
2341 );
2342 <alloy::sol_types::sol_data::Uint<
2343 256,
2344 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2345 &rust.gasLimit,
2346 out,
2347 );
2348 <alloy::sol_types::sol_data::Uint<
2349 256,
2350 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2351 &rust.gasUsed,
2352 out,
2353 );
2354 <alloy::sol_types::sol_data::Uint<
2355 256,
2356 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2357 &rust.time,
2358 out,
2359 );
2360 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
2361 &rust.extra,
2362 out,
2363 );
2364 <alloy::sol_types::sol_data::FixedBytes<
2365 32,
2366 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2367 &rust.mixDigest,
2368 out,
2369 );
2370 <alloy::sol_types::sol_data::FixedBytes<
2371 8,
2372 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2373 &rust.nonce,
2374 out,
2375 );
2376 }
2377 #[inline]
2378 fn encode_topic(
2379 rust: &Self::RustType,
2380 ) -> alloy_sol_types::abi::token::WordToken {
2381 let mut out = alloy_sol_types::private::Vec::new();
2382 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
2383 rust,
2384 &mut out,
2385 );
2386 alloy_sol_types::abi::token::WordToken(
2387 alloy_sol_types::private::keccak256(out),
2388 )
2389 }
2390 }
2391 };
2392 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2393 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2397 #[derive(Clone)]
2398 pub struct StorageProof {
2399 #[allow(missing_docs)]
2400 pub key: alloy::sol_types::private::FixedBytes<32>,
2401 #[allow(missing_docs)]
2402 pub value: alloy::sol_types::private::FixedBytes<32>,
2403 #[allow(missing_docs)]
2404 pub proof: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
2405 }
2406 #[allow(
2407 non_camel_case_types,
2408 non_snake_case,
2409 clippy::pub_underscore_fields,
2410 clippy::style
2411 )]
2412 const _: () = {
2413 use alloy::sol_types as alloy_sol_types;
2414 #[doc(hidden)]
2415 type UnderlyingSolTuple<'a> = (
2416 alloy::sol_types::sol_data::FixedBytes<32>,
2417 alloy::sol_types::sol_data::FixedBytes<32>,
2418 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
2419 );
2420 #[doc(hidden)]
2421 type UnderlyingRustTuple<'a> = (
2422 alloy::sol_types::private::FixedBytes<32>,
2423 alloy::sol_types::private::FixedBytes<32>,
2424 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
2425 );
2426 #[cfg(test)]
2427 #[allow(dead_code, unreachable_patterns)]
2428 fn _type_assertion(
2429 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2430 ) {
2431 match _t {
2432 alloy_sol_types::private::AssertTypeEq::<
2433 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2434 >(_) => {}
2435 }
2436 }
2437 #[automatically_derived]
2438 #[doc(hidden)]
2439 impl ::core::convert::From<StorageProof> for UnderlyingRustTuple<'_> {
2440 fn from(value: StorageProof) -> Self {
2441 (value.key, value.value, value.proof)
2442 }
2443 }
2444 #[automatically_derived]
2445 #[doc(hidden)]
2446 impl ::core::convert::From<UnderlyingRustTuple<'_>> for StorageProof {
2447 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2448 Self {
2449 key: tuple.0,
2450 value: tuple.1,
2451 proof: tuple.2,
2452 }
2453 }
2454 }
2455 #[automatically_derived]
2456 impl alloy_sol_types::SolValue for StorageProof {
2457 type SolType = Self;
2458 }
2459 #[automatically_derived]
2460 impl alloy_sol_types::private::SolTypeValue<Self> for StorageProof {
2461 #[inline]
2462 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
2463 (
2464 <alloy::sol_types::sol_data::FixedBytes<
2465 32,
2466 > as alloy_sol_types::SolType>::tokenize(&self.key),
2467 <alloy::sol_types::sol_data::FixedBytes<
2468 32,
2469 > as alloy_sol_types::SolType>::tokenize(&self.value),
2470 <alloy::sol_types::sol_data::Array<
2471 alloy::sol_types::sol_data::Bytes,
2472 > as alloy_sol_types::SolType>::tokenize(&self.proof),
2473 )
2474 }
2475 #[inline]
2476 fn stv_abi_encoded_size(&self) -> usize {
2477 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
2478 return size;
2479 }
2480 let tuple = <UnderlyingRustTuple<
2481 '_,
2482 > as ::core::convert::From<Self>>::from(self.clone());
2483 <UnderlyingSolTuple<
2484 '_,
2485 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
2486 }
2487 #[inline]
2488 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2489 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
2490 }
2491 #[inline]
2492 fn stv_abi_encode_packed_to(
2493 &self,
2494 out: &mut alloy_sol_types::private::Vec<u8>,
2495 ) {
2496 let tuple = <UnderlyingRustTuple<
2497 '_,
2498 > as ::core::convert::From<Self>>::from(self.clone());
2499 <UnderlyingSolTuple<
2500 '_,
2501 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
2502 }
2503 #[inline]
2504 fn stv_abi_packed_encoded_size(&self) -> usize {
2505 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
2506 return size;
2507 }
2508 let tuple = <UnderlyingRustTuple<
2509 '_,
2510 > as ::core::convert::From<Self>>::from(self.clone());
2511 <UnderlyingSolTuple<
2512 '_,
2513 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
2514 }
2515 }
2516 #[automatically_derived]
2517 impl alloy_sol_types::SolType for StorageProof {
2518 type RustType = Self;
2519 type Token<'a> = <UnderlyingSolTuple<
2520 'a,
2521 > as alloy_sol_types::SolType>::Token<'a>;
2522 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
2523 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2524 '_,
2525 > as alloy_sol_types::SolType>::ENCODED_SIZE;
2526 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2527 '_,
2528 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2529 #[inline]
2530 fn valid_token(token: &Self::Token<'_>) -> bool {
2531 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
2532 }
2533 #[inline]
2534 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2535 let tuple = <UnderlyingSolTuple<
2536 '_,
2537 > as alloy_sol_types::SolType>::detokenize(token);
2538 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
2539 }
2540 }
2541 #[automatically_derived]
2542 impl alloy_sol_types::SolStruct for StorageProof {
2543 const NAME: &'static str = "StorageProof";
2544 #[inline]
2545 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
2546 alloy_sol_types::private::Cow::Borrowed(
2547 "StorageProof(bytes32 key,bytes32 value,bytes[] proof)",
2548 )
2549 }
2550 #[inline]
2551 fn eip712_components() -> alloy_sol_types::private::Vec<
2552 alloy_sol_types::private::Cow<'static, str>,
2553 > {
2554 alloy_sol_types::private::Vec::new()
2555 }
2556 #[inline]
2557 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
2558 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
2559 }
2560 #[inline]
2561 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
2562 [
2563 <alloy::sol_types::sol_data::FixedBytes<
2564 32,
2565 > as alloy_sol_types::SolType>::eip712_data_word(&self.key)
2566 .0,
2567 <alloy::sol_types::sol_data::FixedBytes<
2568 32,
2569 > as alloy_sol_types::SolType>::eip712_data_word(&self.value)
2570 .0,
2571 <alloy::sol_types::sol_data::Array<
2572 alloy::sol_types::sol_data::Bytes,
2573 > as alloy_sol_types::SolType>::eip712_data_word(&self.proof)
2574 .0,
2575 ]
2576 .concat()
2577 }
2578 }
2579 #[automatically_derived]
2580 impl alloy_sol_types::EventTopic for StorageProof {
2581 #[inline]
2582 fn topic_preimage_length(rust: &Self::RustType) -> usize {
2583 0usize
2584 + <alloy::sol_types::sol_data::FixedBytes<
2585 32,
2586 > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.key)
2587 + <alloy::sol_types::sol_data::FixedBytes<
2588 32,
2589 > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.value)
2590 + <alloy::sol_types::sol_data::Array<
2591 alloy::sol_types::sol_data::Bytes,
2592 > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.proof)
2593 }
2594 #[inline]
2595 fn encode_topic_preimage(
2596 rust: &Self::RustType,
2597 out: &mut alloy_sol_types::private::Vec<u8>,
2598 ) {
2599 out.reserve(
2600 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
2601 );
2602 <alloy::sol_types::sol_data::FixedBytes<
2603 32,
2604 > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.key, out);
2605 <alloy::sol_types::sol_data::FixedBytes<
2606 32,
2607 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2608 &rust.value,
2609 out,
2610 );
2611 <alloy::sol_types::sol_data::Array<
2612 alloy::sol_types::sol_data::Bytes,
2613 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2614 &rust.proof,
2615 out,
2616 );
2617 }
2618 #[inline]
2619 fn encode_topic(
2620 rust: &Self::RustType,
2621 ) -> alloy_sol_types::abi::token::WordToken {
2622 let mut out = alloy_sol_types::private::Vec::new();
2623 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
2624 rust,
2625 &mut out,
2626 );
2627 alloy_sol_types::abi::token::WordToken(
2628 alloy_sol_types::private::keccak256(out),
2629 )
2630 }
2631 }
2632 };
2633 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2634 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2638 #[derive(Clone)]
2639 pub struct VerificationData {
2640 #[allow(missing_docs)]
2641 pub accounts: alloy::sol_types::private::Vec<
2642 <Account as alloy::sol_types::SolType>::RustType,
2643 >,
2644 }
2645 #[allow(
2646 non_camel_case_types,
2647 non_snake_case,
2648 clippy::pub_underscore_fields,
2649 clippy::style
2650 )]
2651 const _: () = {
2652 use alloy::sol_types as alloy_sol_types;
2653 #[doc(hidden)]
2654 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Array<Account>,);
2655 #[doc(hidden)]
2656 type UnderlyingRustTuple<'a> = (
2657 alloy::sol_types::private::Vec<
2658 <Account as alloy::sol_types::SolType>::RustType,
2659 >,
2660 );
2661 #[cfg(test)]
2662 #[allow(dead_code, unreachable_patterns)]
2663 fn _type_assertion(
2664 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2665 ) {
2666 match _t {
2667 alloy_sol_types::private::AssertTypeEq::<
2668 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2669 >(_) => {}
2670 }
2671 }
2672 #[automatically_derived]
2673 #[doc(hidden)]
2674 impl ::core::convert::From<VerificationData> for UnderlyingRustTuple<'_> {
2675 fn from(value: VerificationData) -> Self {
2676 (value.accounts,)
2677 }
2678 }
2679 #[automatically_derived]
2680 #[doc(hidden)]
2681 impl ::core::convert::From<UnderlyingRustTuple<'_>> for VerificationData {
2682 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2683 Self { accounts: tuple.0 }
2684 }
2685 }
2686 #[automatically_derived]
2687 impl alloy_sol_types::SolValue for VerificationData {
2688 type SolType = Self;
2689 }
2690 #[automatically_derived]
2691 impl alloy_sol_types::private::SolTypeValue<Self> for VerificationData {
2692 #[inline]
2693 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
2694 (
2695 <alloy::sol_types::sol_data::Array<
2696 Account,
2697 > as alloy_sol_types::SolType>::tokenize(&self.accounts),
2698 )
2699 }
2700 #[inline]
2701 fn stv_abi_encoded_size(&self) -> usize {
2702 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
2703 return size;
2704 }
2705 let tuple = <UnderlyingRustTuple<
2706 '_,
2707 > as ::core::convert::From<Self>>::from(self.clone());
2708 <UnderlyingSolTuple<
2709 '_,
2710 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
2711 }
2712 #[inline]
2713 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
2714 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
2715 }
2716 #[inline]
2717 fn stv_abi_encode_packed_to(
2718 &self,
2719 out: &mut alloy_sol_types::private::Vec<u8>,
2720 ) {
2721 let tuple = <UnderlyingRustTuple<
2722 '_,
2723 > as ::core::convert::From<Self>>::from(self.clone());
2724 <UnderlyingSolTuple<
2725 '_,
2726 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
2727 }
2728 #[inline]
2729 fn stv_abi_packed_encoded_size(&self) -> usize {
2730 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
2731 return size;
2732 }
2733 let tuple = <UnderlyingRustTuple<
2734 '_,
2735 > as ::core::convert::From<Self>>::from(self.clone());
2736 <UnderlyingSolTuple<
2737 '_,
2738 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
2739 }
2740 }
2741 #[automatically_derived]
2742 impl alloy_sol_types::SolType for VerificationData {
2743 type RustType = Self;
2744 type Token<'a> = <UnderlyingSolTuple<
2745 'a,
2746 > as alloy_sol_types::SolType>::Token<'a>;
2747 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
2748 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2749 '_,
2750 > as alloy_sol_types::SolType>::ENCODED_SIZE;
2751 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
2752 '_,
2753 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
2754 #[inline]
2755 fn valid_token(token: &Self::Token<'_>) -> bool {
2756 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
2757 }
2758 #[inline]
2759 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
2760 let tuple = <UnderlyingSolTuple<
2761 '_,
2762 > as alloy_sol_types::SolType>::detokenize(token);
2763 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
2764 }
2765 }
2766 #[automatically_derived]
2767 impl alloy_sol_types::SolStruct for VerificationData {
2768 const NAME: &'static str = "VerificationData";
2769 #[inline]
2770 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
2771 alloy_sol_types::private::Cow::Borrowed(
2772 "VerificationData(Account[] accounts)",
2773 )
2774 }
2775 #[inline]
2776 fn eip712_components() -> alloy_sol_types::private::Vec<
2777 alloy_sol_types::private::Cow<'static, str>,
2778 > {
2779 let mut components = alloy_sol_types::private::Vec::with_capacity(1);
2780 components
2781 .push(<Account as alloy_sol_types::SolStruct>::eip712_root_type());
2782 components
2783 .extend(
2784 <Account as alloy_sol_types::SolStruct>::eip712_components(),
2785 );
2786 components
2787 }
2788 #[inline]
2789 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
2790 <alloy::sol_types::sol_data::Array<
2791 Account,
2792 > as alloy_sol_types::SolType>::eip712_data_word(&self.accounts)
2793 .0
2794 .to_vec()
2795 }
2796 }
2797 #[automatically_derived]
2798 impl alloy_sol_types::EventTopic for VerificationData {
2799 #[inline]
2800 fn topic_preimage_length(rust: &Self::RustType) -> usize {
2801 0usize
2802 + <alloy::sol_types::sol_data::Array<
2803 Account,
2804 > as alloy_sol_types::EventTopic>::topic_preimage_length(
2805 &rust.accounts,
2806 )
2807 }
2808 #[inline]
2809 fn encode_topic_preimage(
2810 rust: &Self::RustType,
2811 out: &mut alloy_sol_types::private::Vec<u8>,
2812 ) {
2813 out.reserve(
2814 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
2815 );
2816 <alloy::sol_types::sol_data::Array<
2817 Account,
2818 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
2819 &rust.accounts,
2820 out,
2821 );
2822 }
2823 #[inline]
2824 fn encode_topic(
2825 rust: &Self::RustType,
2826 ) -> alloy_sol_types::abi::token::WordToken {
2827 let mut out = alloy_sol_types::private::Vec::new();
2828 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
2829 rust,
2830 &mut out,
2831 );
2832 alloy_sol_types::abi::token::WordToken(
2833 alloy_sol_types::private::keccak256(out),
2834 )
2835 }
2836 }
2837 };
2838 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2839 #[allow(
2844 non_camel_case_types,
2845 non_snake_case,
2846 clippy::pub_underscore_fields,
2847 clippy::style
2848 )]
2849 #[derive(Clone)]
2850 pub struct ClaimAppended {
2851 #[allow(missing_docs)]
2852 pub claim: <Claim as alloy::sol_types::SolType>::RustType,
2853 #[allow(missing_docs)]
2854 pub verData: alloy::sol_types::private::FixedBytes<32>,
2855 }
2856 #[allow(
2857 non_camel_case_types,
2858 non_snake_case,
2859 clippy::pub_underscore_fields,
2860 clippy::style
2861 )]
2862 const _: () = {
2863 use alloy::sol_types as alloy_sol_types;
2864 #[automatically_derived]
2865 impl alloy_sol_types::SolEvent for ClaimAppended {
2866 type DataTuple<'a> = (Claim,);
2867 type DataToken<'a> = <Self::DataTuple<
2868 'a,
2869 > as alloy_sol_types::SolType>::Token<'a>;
2870 type TopicList = (
2871 alloy_sol_types::sol_data::FixedBytes<32>,
2872 alloy::sol_types::sol_data::FixedBytes<32>,
2873 );
2874 const SIGNATURE: &'static str = "ClaimAppended((string,string,(bytes32,bytes32,address,bytes32,bytes32,bytes32,bytes,uint256,uint256,uint256,uint256,uint256,bytes,bytes32,bytes8),(address,address,bytes),bytes,(uint256)),(((address,bytes[],uint256,bytes32,uint256,bytes32,(bytes32,bytes32,bytes[])[]),bytes)[]))";
2875 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2876 42u8, 173u8, 219u8, 132u8, 208u8, 51u8, 216u8, 189u8, 80u8, 31u8, 167u8,
2877 24u8, 86u8, 39u8, 206u8, 226u8, 156u8, 64u8, 129u8, 179u8, 235u8, 107u8,
2878 23u8, 153u8, 167u8, 45u8, 237u8, 131u8, 41u8, 30u8, 39u8, 132u8,
2879 ]);
2880 const ANONYMOUS: bool = false;
2881 #[allow(unused_variables)]
2882 #[inline]
2883 fn new(
2884 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2885 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2886 ) -> Self {
2887 Self {
2888 claim: data.0,
2889 verData: topics.1,
2890 }
2891 }
2892 #[inline]
2893 fn check_signature(
2894 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2895 ) -> alloy_sol_types::Result<()> {
2896 if topics.0 != Self::SIGNATURE_HASH {
2897 return Err(
2898 alloy_sol_types::Error::invalid_event_signature_hash(
2899 Self::SIGNATURE,
2900 topics.0,
2901 Self::SIGNATURE_HASH,
2902 ),
2903 );
2904 }
2905 Ok(())
2906 }
2907 #[inline]
2908 fn tokenize_body(&self) -> Self::DataToken<'_> {
2909 (<Claim as alloy_sol_types::SolType>::tokenize(&self.claim),)
2910 }
2911 #[inline]
2912 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2913 (Self::SIGNATURE_HASH.into(), self.verData.clone())
2914 }
2915 #[inline]
2916 fn encode_topics_raw(
2917 &self,
2918 out: &mut [alloy_sol_types::abi::token::WordToken],
2919 ) -> alloy_sol_types::Result<()> {
2920 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2921 return Err(alloy_sol_types::Error::Overrun);
2922 }
2923 out[0usize] = alloy_sol_types::abi::token::WordToken(
2924 Self::SIGNATURE_HASH,
2925 );
2926 out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
2927 32,
2928 > as alloy_sol_types::EventTopic>::encode_topic(&self.verData);
2929 Ok(())
2930 }
2931 }
2932 #[automatically_derived]
2933 impl alloy_sol_types::private::IntoLogData for ClaimAppended {
2934 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2935 From::from(self)
2936 }
2937 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2938 From::from(&self)
2939 }
2940 }
2941 #[automatically_derived]
2942 impl From<&ClaimAppended> for alloy_sol_types::private::LogData {
2943 #[inline]
2944 fn from(this: &ClaimAppended) -> alloy_sol_types::private::LogData {
2945 alloy_sol_types::SolEvent::encode_log_data(this)
2946 }
2947 }
2948 };
2949 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2950 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2955 #[derive(Clone)]
2956 pub struct verifyCall {
2957 #[allow(missing_docs)]
2958 pub claim: <Claim as alloy::sol_types::SolType>::RustType,
2959 #[allow(missing_docs)]
2960 pub verData: <VerificationData as alloy::sol_types::SolType>::RustType,
2961 }
2962 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2964 #[derive(Clone)]
2965 pub struct verifyReturn {}
2966 #[allow(
2967 non_camel_case_types,
2968 non_snake_case,
2969 clippy::pub_underscore_fields,
2970 clippy::style
2971 )]
2972 const _: () = {
2973 use alloy::sol_types as alloy_sol_types;
2974 {
2975 #[doc(hidden)]
2976 type UnderlyingSolTuple<'a> = (Claim, VerificationData);
2977 #[doc(hidden)]
2978 type UnderlyingRustTuple<'a> = (
2979 <Claim as alloy::sol_types::SolType>::RustType,
2980 <VerificationData as alloy::sol_types::SolType>::RustType,
2981 );
2982 #[cfg(test)]
2983 #[allow(dead_code, unreachable_patterns)]
2984 fn _type_assertion(
2985 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2986 ) {
2987 match _t {
2988 alloy_sol_types::private::AssertTypeEq::<
2989 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2990 >(_) => {}
2991 }
2992 }
2993 #[automatically_derived]
2994 #[doc(hidden)]
2995 impl ::core::convert::From<verifyCall> for UnderlyingRustTuple<'_> {
2996 fn from(value: verifyCall) -> Self {
2997 (value.claim, value.verData)
2998 }
2999 }
3000 #[automatically_derived]
3001 #[doc(hidden)]
3002 impl ::core::convert::From<UnderlyingRustTuple<'_>> for verifyCall {
3003 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3004 Self {
3005 claim: tuple.0,
3006 verData: tuple.1,
3007 }
3008 }
3009 }
3010 }
3011 {
3012 #[doc(hidden)]
3013 type UnderlyingSolTuple<'a> = ();
3014 #[doc(hidden)]
3015 type UnderlyingRustTuple<'a> = ();
3016 #[cfg(test)]
3017 #[allow(dead_code, unreachable_patterns)]
3018 fn _type_assertion(
3019 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3020 ) {
3021 match _t {
3022 alloy_sol_types::private::AssertTypeEq::<
3023 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3024 >(_) => {}
3025 }
3026 }
3027 #[automatically_derived]
3028 #[doc(hidden)]
3029 impl ::core::convert::From<verifyReturn> for UnderlyingRustTuple<'_> {
3030 fn from(value: verifyReturn) -> Self {
3031 ()
3032 }
3033 }
3034 #[automatically_derived]
3035 #[doc(hidden)]
3036 impl ::core::convert::From<UnderlyingRustTuple<'_>> for verifyReturn {
3037 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3038 Self {}
3039 }
3040 }
3041 }
3042 #[automatically_derived]
3043 impl alloy_sol_types::SolCall for verifyCall {
3044 type Parameters<'a> = (Claim, VerificationData);
3045 type Token<'a> = <Self::Parameters<
3046 'a,
3047 > as alloy_sol_types::SolType>::Token<'a>;
3048 type Return = verifyReturn;
3049 type ReturnTuple<'a> = ();
3050 type ReturnToken<'a> = <Self::ReturnTuple<
3051 'a,
3052 > as alloy_sol_types::SolType>::Token<'a>;
3053 const SIGNATURE: &'static str = "verify((string,string,(bytes32,bytes32,address,bytes32,bytes32,bytes32,bytes,uint256,uint256,uint256,uint256,uint256,bytes,bytes32,bytes8),(address,address,bytes),bytes,(uint256)),(((address,bytes[],uint256,bytes32,uint256,bytes32,(bytes32,bytes32,bytes[])[]),bytes)[]))";
3054 const SELECTOR: [u8; 4] = [11u8, 14u8, 150u8, 89u8];
3055 #[inline]
3056 fn new<'a>(
3057 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3058 ) -> Self {
3059 tuple.into()
3060 }
3061 #[inline]
3062 fn tokenize(&self) -> Self::Token<'_> {
3063 (
3064 <Claim as alloy_sol_types::SolType>::tokenize(&self.claim),
3065 <VerificationData as alloy_sol_types::SolType>::tokenize(
3066 &self.verData,
3067 ),
3068 )
3069 }
3070 #[inline]
3071 fn abi_decode_returns(
3072 data: &[u8],
3073 validate: bool,
3074 ) -> alloy_sol_types::Result<Self::Return> {
3075 <Self::ReturnTuple<
3076 '_,
3077 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3078 .map(Into::into)
3079 }
3080 }
3081 };
3082 #[derive()]
3084 pub enum Pi2Calls {
3085 #[allow(missing_docs)]
3086 verify(verifyCall),
3087 }
3088 #[automatically_derived]
3089 impl Pi2Calls {
3090 pub const SELECTORS: &'static [[u8; 4usize]] = &[[11u8, 14u8, 150u8, 89u8]];
3097 }
3098 #[automatically_derived]
3099 impl alloy_sol_types::SolInterface for Pi2Calls {
3100 const NAME: &'static str = "Pi2Calls";
3101 const MIN_DATA_LENGTH: usize = 960usize;
3102 const COUNT: usize = 1usize;
3103 #[inline]
3104 fn selector(&self) -> [u8; 4] {
3105 match self {
3106 Self::verify(_) => <verifyCall as alloy_sol_types::SolCall>::SELECTOR,
3107 }
3108 }
3109 #[inline]
3110 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
3111 Self::SELECTORS.get(i).copied()
3112 }
3113 #[inline]
3114 fn valid_selector(selector: [u8; 4]) -> bool {
3115 Self::SELECTORS.binary_search(&selector).is_ok()
3116 }
3117 #[inline]
3118 #[allow(non_snake_case)]
3119 fn abi_decode_raw(
3120 selector: [u8; 4],
3121 data: &[u8],
3122 validate: bool,
3123 ) -> alloy_sol_types::Result<Self> {
3124 static DECODE_SHIMS: &[fn(
3125 &[u8],
3126 bool,
3127 ) -> alloy_sol_types::Result<Pi2Calls>] = &[
3128 {
3129 fn verify(
3130 data: &[u8],
3131 validate: bool,
3132 ) -> alloy_sol_types::Result<Pi2Calls> {
3133 <verifyCall as alloy_sol_types::SolCall>::abi_decode_raw(
3134 data,
3135 validate,
3136 )
3137 .map(Pi2Calls::verify)
3138 }
3139 verify
3140 },
3141 ];
3142 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3143 return Err(
3144 alloy_sol_types::Error::unknown_selector(
3145 <Self as alloy_sol_types::SolInterface>::NAME,
3146 selector,
3147 ),
3148 );
3149 };
3150 DECODE_SHIMS[idx](data, validate)
3151 }
3152 #[inline]
3153 fn abi_encoded_size(&self) -> usize {
3154 match self {
3155 Self::verify(inner) => {
3156 <verifyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
3157 }
3158 }
3159 }
3160 #[inline]
3161 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
3162 match self {
3163 Self::verify(inner) => {
3164 <verifyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3165 }
3166 }
3167 }
3168 }
3169 #[derive(Debug, PartialEq, Eq, Hash)]
3171 pub enum Pi2Events {
3172 #[allow(missing_docs)]
3173 ClaimAppended(ClaimAppended),
3174 }
3175 #[automatically_derived]
3176 impl Pi2Events {
3177 pub const SELECTORS: &'static [[u8; 32usize]] = &[
3184 [
3185 42u8, 173u8, 219u8, 132u8, 208u8, 51u8, 216u8, 189u8, 80u8, 31u8, 167u8,
3186 24u8, 86u8, 39u8, 206u8, 226u8, 156u8, 64u8, 129u8, 179u8, 235u8, 107u8,
3187 23u8, 153u8, 167u8, 45u8, 237u8, 131u8, 41u8, 30u8, 39u8, 132u8,
3188 ],
3189 ];
3190 }
3191 #[automatically_derived]
3192 impl alloy_sol_types::SolEventInterface for Pi2Events {
3193 const NAME: &'static str = "Pi2Events";
3194 const COUNT: usize = 1usize;
3195 fn decode_raw_log(
3196 topics: &[alloy_sol_types::Word],
3197 data: &[u8],
3198 validate: bool,
3199 ) -> alloy_sol_types::Result<Self> {
3200 match topics.first().copied() {
3201 Some(<ClaimAppended as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3202 <ClaimAppended as alloy_sol_types::SolEvent>::decode_raw_log(
3203 topics,
3204 data,
3205 validate,
3206 )
3207 .map(Self::ClaimAppended)
3208 }
3209 _ => {
3210 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
3211 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
3212 log: alloy_sol_types::private::Box::new(
3213 alloy_sol_types::private::LogData::new_unchecked(
3214 topics.to_vec(),
3215 data.to_vec().into(),
3216 ),
3217 ),
3218 })
3219 }
3220 }
3221 }
3222 }
3223 #[automatically_derived]
3224 impl alloy_sol_types::private::IntoLogData for Pi2Events {
3225 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3226 match self {
3227 Self::ClaimAppended(inner) => {
3228 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3229 }
3230 }
3231 }
3232 fn into_log_data(self) -> alloy_sol_types::private::LogData {
3233 match self {
3234 Self::ClaimAppended(inner) => {
3235 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3236 }
3237 }
3238 }
3239 }
3240 use alloy::contract as alloy_contract;
3241 #[inline]
3245 pub const fn new<
3246 T: alloy_contract::private::Transport + ::core::clone::Clone,
3247 P: alloy_contract::private::Provider<T, N>,
3248 N: alloy_contract::private::Network,
3249 >(address: alloy_sol_types::private::Address, provider: P) -> Pi2Instance<T, P, N> {
3250 Pi2Instance::<T, P, N>::new(address, provider)
3251 }
3252 #[inline]
3258 pub fn deploy<
3259 T: alloy_contract::private::Transport + ::core::clone::Clone,
3260 P: alloy_contract::private::Provider<T, N>,
3261 N: alloy_contract::private::Network,
3262 >(
3263 provider: P,
3264 ) -> impl ::core::future::Future<
3265 Output = alloy_contract::Result<Pi2Instance<T, P, N>>,
3266 > {
3267 Pi2Instance::<T, P, N>::deploy(provider)
3268 }
3269 #[inline]
3275 pub fn deploy_builder<
3276 T: alloy_contract::private::Transport + ::core::clone::Clone,
3277 P: alloy_contract::private::Provider<T, N>,
3278 N: alloy_contract::private::Network,
3279 >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
3280 Pi2Instance::<T, P, N>::deploy_builder(provider)
3281 }
3282 #[derive(Clone)]
3294 pub struct Pi2Instance<T, P, N = alloy_contract::private::Ethereum> {
3295 address: alloy_sol_types::private::Address,
3296 provider: P,
3297 _network_transport: ::core::marker::PhantomData<(N, T)>,
3298 }
3299 #[automatically_derived]
3300 impl<T, P, N> ::core::fmt::Debug for Pi2Instance<T, P, N> {
3301 #[inline]
3302 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3303 f.debug_tuple("Pi2Instance").field(&self.address).finish()
3304 }
3305 }
3306 #[automatically_derived]
3308 impl<
3309 T: alloy_contract::private::Transport + ::core::clone::Clone,
3310 P: alloy_contract::private::Provider<T, N>,
3311 N: alloy_contract::private::Network,
3312 > Pi2Instance<T, P, N> {
3313 #[inline]
3317 pub const fn new(
3318 address: alloy_sol_types::private::Address,
3319 provider: P,
3320 ) -> Self {
3321 Self {
3322 address,
3323 provider,
3324 _network_transport: ::core::marker::PhantomData,
3325 }
3326 }
3327 #[inline]
3333 pub async fn deploy(
3334 provider: P,
3335 ) -> alloy_contract::Result<Pi2Instance<T, P, N>> {
3336 let call_builder = Self::deploy_builder(provider);
3337 let contract_address = call_builder.deploy().await?;
3338 Ok(Self::new(contract_address, call_builder.provider))
3339 }
3340 #[inline]
3346 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
3347 alloy_contract::RawCallBuilder::new_raw_deploy(
3348 provider,
3349 ::core::clone::Clone::clone(&BYTECODE),
3350 )
3351 }
3352 #[inline]
3354 pub const fn address(&self) -> &alloy_sol_types::private::Address {
3355 &self.address
3356 }
3357 #[inline]
3359 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3360 self.address = address;
3361 }
3362 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3364 self.set_address(address);
3365 self
3366 }
3367 #[inline]
3369 pub const fn provider(&self) -> &P {
3370 &self.provider
3371 }
3372 }
3373 impl<T, P: ::core::clone::Clone, N> Pi2Instance<T, &P, N> {
3374 #[inline]
3376 pub fn with_cloned_provider(self) -> Pi2Instance<T, P, N> {
3377 Pi2Instance {
3378 address: self.address,
3379 provider: ::core::clone::Clone::clone(&self.provider),
3380 _network_transport: ::core::marker::PhantomData,
3381 }
3382 }
3383 }
3384 #[automatically_derived]
3386 impl<
3387 T: alloy_contract::private::Transport + ::core::clone::Clone,
3388 P: alloy_contract::private::Provider<T, N>,
3389 N: alloy_contract::private::Network,
3390 > Pi2Instance<T, P, N> {
3391 pub fn call_builder<C: alloy_sol_types::SolCall>(
3396 &self,
3397 call: &C,
3398 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
3399 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3400 }
3401 pub fn verify(
3403 &self,
3404 claim: <Claim as alloy::sol_types::SolType>::RustType,
3405 verData: <VerificationData as alloy::sol_types::SolType>::RustType,
3406 ) -> alloy_contract::SolCallBuilder<T, &P, verifyCall, N> {
3407 self.call_builder(&verifyCall { claim, verData })
3408 }
3409 }
3410 #[automatically_derived]
3412 impl<
3413 T: alloy_contract::private::Transport + ::core::clone::Clone,
3414 P: alloy_contract::private::Provider<T, N>,
3415 N: alloy_contract::private::Network,
3416 > Pi2Instance<T, P, N> {
3417 pub fn event_filter<E: alloy_sol_types::SolEvent>(
3422 &self,
3423 ) -> alloy_contract::Event<T, &P, E, N> {
3424 alloy_contract::Event::new_sol(&self.provider, &self.address)
3425 }
3426 pub fn ClaimAppended_filter(
3428 &self,
3429 ) -> alloy_contract::Event<T, &P, ClaimAppended, N> {
3430 self.event_filter::<ClaimAppended>()
3431 }
3432 }
3433}