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