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