@apibara/evm 2.1.0-beta.23 → 2.1.0-beta.24

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (12) hide show
  1. package/dist/index.cjs +386 -475
  2. package/dist/index.d.cts +1068 -2054
  3. package/dist/index.d.mts +1068 -2054
  4. package/dist/index.d.ts +1068 -2054
  5. package/dist/index.mjs +388 -466
  6. package/package.json +2 -4
  7. package/src/block.ts +312 -308
  8. package/src/common.ts +64 -101
  9. package/src/filter.ts +128 -138
  10. package/src/common.test.ts +0 -79
  11. package/src/filter.test.ts +0 -187
  12. package/src/helpers.ts +0 -8
package/dist/index.d.mts CHANGED
@@ -1,7 +1,6 @@
1
1
  import { StreamConfig } from '@apibara/protocol';
2
2
  import _m0 from 'protobufjs/minimal.js';
3
- import * as _effect_schema_AST from '@effect/schema/AST';
4
- import { Schema } from '@effect/schema';
3
+ import { Codec, CodecType, MessageCodec } from '@apibara/protocol/codec';
5
4
 
6
5
  declare const protobufPackage$2 = "evm.v2";
7
6
  /**
@@ -721,73 +720,17 @@ declare namespace index {
721
720
  }
722
721
 
723
722
  /** An Ethereum address. */
724
- declare const Address: Schema.transform<Schema.Struct<{
725
- x0: typeof Schema.BigIntFromSelf;
726
- x1: typeof Schema.BigIntFromSelf;
727
- x2: typeof Schema.Number;
728
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
729
- type Address = typeof Address.Type;
730
- /** Wire representation of `B256`. */
731
- declare const B256Proto: Schema.Struct<{
732
- x0: typeof Schema.BigIntFromSelf;
733
- x1: typeof Schema.BigIntFromSelf;
734
- x2: typeof Schema.BigIntFromSelf;
735
- x3: typeof Schema.BigIntFromSelf;
736
- }>;
723
+ declare const Address: Codec<`0x${string}`, Address$1>;
724
+ type Address = CodecType<typeof Address>;
737
725
  /** Data with length 256 bits. */
738
- declare const B256: Schema.transform<Schema.Struct<{
739
- x0: typeof Schema.BigIntFromSelf;
740
- x1: typeof Schema.BigIntFromSelf;
741
- x2: typeof Schema.BigIntFromSelf;
742
- x3: typeof Schema.BigIntFromSelf;
743
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
744
- type B256 = typeof B256.Type;
745
- declare const b256ToProto: (a: `0x${string}`, overrideOptions?: _effect_schema_AST.ParseOptions) => {
746
- readonly x0: bigint;
747
- readonly x1: bigint;
748
- readonly x2: bigint;
749
- readonly x3: bigint;
750
- };
751
- declare const b256FromProto: (i: {
752
- readonly x0: bigint;
753
- readonly x1: bigint;
754
- readonly x2: bigint;
755
- readonly x3: bigint;
756
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => `0x${string}`;
726
+ declare const B256: Codec<`0x${string}`, B256$1>;
727
+ type B256 = CodecType<typeof B256>;
757
728
  /** Data with length 256 bits. */
758
- declare const U256: Schema.transform<Schema.Struct<{
759
- x0: typeof Schema.BigIntFromSelf;
760
- x1: typeof Schema.BigIntFromSelf;
761
- x2: typeof Schema.BigIntFromSelf;
762
- x3: typeof Schema.BigIntFromSelf;
763
- }>, typeof Schema.BigIntFromSelf>;
764
- type U256 = typeof U256.Type;
765
- declare const u256ToProto: (a: bigint, overrideOptions?: _effect_schema_AST.ParseOptions) => {
766
- readonly x0: bigint;
767
- readonly x1: bigint;
768
- readonly x2: bigint;
769
- readonly x3: bigint;
770
- };
771
- declare const u256FromProto: (i: {
772
- readonly x0: bigint;
773
- readonly x1: bigint;
774
- readonly x2: bigint;
775
- readonly x3: bigint;
776
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => bigint;
729
+ declare const U256: Codec<bigint, U256$1>;
730
+ type U256 = CodecType<typeof U256>;
777
731
  /** Data with length 128 bits. */
778
- declare const U128: Schema.transform<Schema.Struct<{
779
- x0: typeof Schema.BigIntFromSelf;
780
- x1: typeof Schema.BigIntFromSelf;
781
- }>, typeof Schema.BigIntFromSelf>;
782
- type U128 = typeof U128.Type;
783
- declare const u128ToProto: (a: bigint, overrideOptions?: _effect_schema_AST.ParseOptions) => {
784
- readonly x0: bigint;
785
- readonly x1: bigint;
786
- };
787
- declare const u128FromProto: (i: {
788
- readonly x0: bigint;
789
- readonly x1: bigint;
790
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => bigint;
732
+ declare const U128: Codec<bigint, U128$1>;
733
+ type U128 = CodecType<typeof U128>;
791
734
 
792
735
  /** Header options.
793
736
  *
@@ -795,2035 +738,1106 @@ declare const u128FromProto: (i: {
795
738
  * - `on_data`: receive headers only if any other filter matches.
796
739
  * - `on_data_or_on_new_block`: receive headers only if any other filter matches and for "live" blocks.
797
740
  */
798
- declare const HeaderFilter: Schema.transform<Schema.Enums<typeof HeaderFilter$1>, Schema.Literal<["always", "on_data", "on_data_or_on_new_block", "unknown"]>>;
799
- type HeaderFilter = typeof HeaderFilter.Type;
800
- declare const WithdrawalFilter: Schema.Struct<{
801
- id: Schema.optional<typeof Schema.Number>;
802
- validatorIndex: Schema.optional<typeof Schema.Number>;
803
- address: Schema.optional<Schema.transform<Schema.Struct<{
804
- x0: typeof Schema.BigIntFromSelf;
805
- x1: typeof Schema.BigIntFromSelf;
806
- x2: typeof Schema.Number;
807
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
741
+ declare const HeaderFilter: Codec<"always" | "on_data" | "on_data_or_on_new_block" | "unknown", HeaderFilter$1>;
742
+ type HeaderFilter = CodecType<typeof HeaderFilter>;
743
+ declare const WithdrawalFilter: MessageCodec<{
744
+ id: Codec<number | undefined, number | undefined>;
745
+ validatorIndex: Codec<number | undefined, number | undefined>;
746
+ address: Codec<`0x${string}` | undefined, Address$1 | undefined>;
808
747
  }>;
809
- type WithdrawalFilter = typeof WithdrawalFilter.Type;
810
- declare const TransactionStatusFilter: Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>;
811
- type TransactionStatusFilter = typeof TransactionStatusFilter.Type;
812
- declare const Topic: Schema.transform<Schema.Struct<{
813
- value: Schema.UndefinedOr<Schema.Struct<{
814
- x0: typeof Schema.BigIntFromSelf;
815
- x1: typeof Schema.BigIntFromSelf;
816
- x2: typeof Schema.BigIntFromSelf;
817
- x3: typeof Schema.BigIntFromSelf;
818
- }>>;
819
- }>, Schema.NullOr<Schema.transform<Schema.Struct<{
820
- x0: typeof Schema.BigIntFromSelf;
821
- x1: typeof Schema.BigIntFromSelf;
822
- x2: typeof Schema.BigIntFromSelf;
823
- x3: typeof Schema.BigIntFromSelf;
824
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>>;
825
- type Topic = typeof Topic.Type;
826
- declare const LogFilter: Schema.Struct<{
827
- id: Schema.optional<typeof Schema.Number>;
828
- address: Schema.optional<Schema.transform<Schema.Struct<{
829
- x0: typeof Schema.BigIntFromSelf;
830
- x1: typeof Schema.BigIntFromSelf;
831
- x2: typeof Schema.Number;
832
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
833
- topics: Schema.optional<Schema.Array$<Schema.transform<Schema.Struct<{
834
- value: Schema.UndefinedOr<Schema.Struct<{
835
- x0: typeof Schema.BigIntFromSelf;
836
- x1: typeof Schema.BigIntFromSelf;
837
- x2: typeof Schema.BigIntFromSelf;
838
- x3: typeof Schema.BigIntFromSelf;
839
- }>>;
840
- }>, Schema.NullOr<Schema.transform<Schema.Struct<{
841
- x0: typeof Schema.BigIntFromSelf;
842
- x1: typeof Schema.BigIntFromSelf;
843
- x2: typeof Schema.BigIntFromSelf;
844
- x3: typeof Schema.BigIntFromSelf;
845
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>>>>;
846
- strict: Schema.optional<typeof Schema.Boolean>;
847
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
848
- includeTransaction: Schema.optional<typeof Schema.Boolean>;
849
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
850
- includeTransactionTrace: Schema.optional<typeof Schema.Boolean>;
748
+ type WithdrawalFilter = CodecType<typeof WithdrawalFilter>;
749
+ declare const TransactionStatusFilter: Codec<"succeeded" | "reverted" | "all" | "unknown", TransactionStatusFilter$1>;
750
+ type TransactionStatusFilter = CodecType<typeof TransactionStatusFilter>;
751
+ declare const Topic: Codec<B256 | null, {
752
+ value?: B256$1 | undefined;
851
753
  }>;
852
- type LogFilter = typeof LogFilter.Type;
853
- declare const TransactionFilter: Schema.Struct<{
854
- id: Schema.optional<typeof Schema.Number>;
855
- from: Schema.optional<Schema.transform<Schema.Struct<{
856
- x0: typeof Schema.BigIntFromSelf;
857
- x1: typeof Schema.BigIntFromSelf;
858
- x2: typeof Schema.Number;
859
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
860
- to: Schema.optional<Schema.transform<Schema.Struct<{
861
- x0: typeof Schema.BigIntFromSelf;
862
- x1: typeof Schema.BigIntFromSelf;
863
- x2: typeof Schema.Number;
864
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
865
- create: Schema.optional<typeof Schema.Boolean>;
866
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
867
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
868
- includeLogs: Schema.optional<typeof Schema.Boolean>;
869
- includeTransactionTrace: Schema.optional<typeof Schema.Boolean>;
754
+ type Topic = CodecType<typeof Topic>;
755
+ declare const LogFilter: MessageCodec<{
756
+ id: Codec<number | undefined, number | undefined>;
757
+ address: Codec<`0x${string}` | undefined, Address$1 | undefined>;
758
+ topics: Codec<readonly (`0x${string}` | null)[] | undefined, readonly {
759
+ value?: B256$1 | undefined;
760
+ }[] | undefined>;
761
+ strict: Codec<boolean | undefined, boolean | undefined>;
762
+ transactionStatus: Codec<"unknown" | "succeeded" | "reverted" | "all" | undefined, TransactionStatusFilter$1 | undefined>;
763
+ includeTransaction: Codec<boolean | undefined, boolean | undefined>;
764
+ includeReceipt: Codec<boolean | undefined, boolean | undefined>;
765
+ includeTransactionTrace: Codec<boolean | undefined, boolean | undefined>;
870
766
  }>;
871
- type TransactionFilter = typeof TransactionFilter.Type;
872
- declare const Filter: Schema.Struct<{
873
- header: Schema.optional<Schema.transform<Schema.Enums<typeof HeaderFilter$1>, Schema.Literal<["always", "on_data", "on_data_or_on_new_block", "unknown"]>>>;
874
- withdrawals: Schema.optional<Schema.Array$<Schema.Struct<{
875
- id: Schema.optional<typeof Schema.Number>;
876
- validatorIndex: Schema.optional<typeof Schema.Number>;
877
- address: Schema.optional<Schema.transform<Schema.Struct<{
878
- x0: typeof Schema.BigIntFromSelf;
879
- x1: typeof Schema.BigIntFromSelf;
880
- x2: typeof Schema.Number;
881
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
882
- }>>>;
883
- transactions: Schema.optional<Schema.Array$<Schema.Struct<{
884
- id: Schema.optional<typeof Schema.Number>;
885
- from: Schema.optional<Schema.transform<Schema.Struct<{
886
- x0: typeof Schema.BigIntFromSelf;
887
- x1: typeof Schema.BigIntFromSelf;
888
- x2: typeof Schema.Number;
889
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
890
- to: Schema.optional<Schema.transform<Schema.Struct<{
891
- x0: typeof Schema.BigIntFromSelf;
892
- x1: typeof Schema.BigIntFromSelf;
893
- x2: typeof Schema.Number;
894
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
895
- create: Schema.optional<typeof Schema.Boolean>;
896
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
897
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
898
- includeLogs: Schema.optional<typeof Schema.Boolean>;
899
- includeTransactionTrace: Schema.optional<typeof Schema.Boolean>;
900
- }>>>;
901
- logs: Schema.optional<Schema.Array$<Schema.Struct<{
902
- id: Schema.optional<typeof Schema.Number>;
903
- address: Schema.optional<Schema.transform<Schema.Struct<{
904
- x0: typeof Schema.BigIntFromSelf;
905
- x1: typeof Schema.BigIntFromSelf;
906
- x2: typeof Schema.Number;
907
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
908
- topics: Schema.optional<Schema.Array$<Schema.transform<Schema.Struct<{
909
- value: Schema.UndefinedOr<Schema.Struct<{
910
- x0: typeof Schema.BigIntFromSelf;
911
- x1: typeof Schema.BigIntFromSelf;
912
- x2: typeof Schema.BigIntFromSelf;
913
- x3: typeof Schema.BigIntFromSelf;
914
- }>>;
915
- }>, Schema.NullOr<Schema.transform<Schema.Struct<{
916
- x0: typeof Schema.BigIntFromSelf;
917
- x1: typeof Schema.BigIntFromSelf;
918
- x2: typeof Schema.BigIntFromSelf;
919
- x3: typeof Schema.BigIntFromSelf;
920
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>>>>;
921
- strict: Schema.optional<typeof Schema.Boolean>;
922
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
923
- includeTransaction: Schema.optional<typeof Schema.Boolean>;
924
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
925
- includeTransactionTrace: Schema.optional<typeof Schema.Boolean>;
926
- }>>>;
767
+ type LogFilter = Readonly<CodecType<typeof LogFilter>>;
768
+ declare const TransactionFilter: MessageCodec<{
769
+ id: Codec<number | undefined, number | undefined>;
770
+ from: Codec<`0x${string}` | undefined, Address$1 | undefined>;
771
+ to: Codec<`0x${string}` | undefined, Address$1 | undefined>;
772
+ create: Codec<boolean | undefined, boolean | undefined>;
773
+ transactionStatus: Codec<"unknown" | "succeeded" | "reverted" | "all" | undefined, TransactionStatusFilter$1 | undefined>;
774
+ includeReceipt: Codec<boolean | undefined, boolean | undefined>;
775
+ includeLogs: Codec<boolean | undefined, boolean | undefined>;
776
+ includeTransactionTrace: Codec<boolean | undefined, boolean | undefined>;
927
777
  }>;
928
- type Filter = typeof Filter.Type;
929
- declare const filterToProto: (a: {
930
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
931
- readonly withdrawals?: readonly {
932
- readonly id?: number | undefined;
933
- readonly validatorIndex?: number | undefined;
934
- readonly address?: `0x${string}` | undefined;
935
- }[] | undefined;
936
- readonly transactions?: readonly {
937
- readonly id?: number | undefined;
938
- readonly from?: `0x${string}` | undefined;
939
- readonly to?: `0x${string}` | undefined;
940
- readonly create?: boolean | undefined;
941
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
942
- readonly includeReceipt?: boolean | undefined;
943
- readonly includeLogs?: boolean | undefined;
944
- readonly includeTransactionTrace?: boolean | undefined;
945
- }[] | undefined;
946
- readonly logs?: readonly {
947
- readonly id?: number | undefined;
948
- readonly address?: `0x${string}` | undefined;
949
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
950
- readonly includeReceipt?: boolean | undefined;
951
- readonly includeTransactionTrace?: boolean | undefined;
952
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
953
- readonly strict?: boolean | undefined;
954
- readonly includeTransaction?: boolean | undefined;
955
- }[] | undefined;
956
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => {
957
- readonly header?: HeaderFilter$1 | undefined;
958
- readonly withdrawals?: readonly {
959
- readonly id?: number | undefined;
960
- readonly validatorIndex?: number | undefined;
961
- readonly address?: {
962
- readonly x0: bigint;
963
- readonly x1: bigint;
964
- readonly x2: number;
965
- } | undefined;
966
- }[] | undefined;
967
- readonly transactions?: readonly {
968
- readonly id?: number | undefined;
969
- readonly from?: {
970
- readonly x0: bigint;
971
- readonly x1: bigint;
972
- readonly x2: number;
973
- } | undefined;
974
- readonly to?: {
975
- readonly x0: bigint;
976
- readonly x1: bigint;
977
- readonly x2: number;
978
- } | undefined;
979
- readonly create?: boolean | undefined;
980
- readonly transactionStatus?: TransactionStatusFilter$1 | undefined;
981
- readonly includeReceipt?: boolean | undefined;
982
- readonly includeLogs?: boolean | undefined;
983
- readonly includeTransactionTrace?: boolean | undefined;
984
- }[] | undefined;
985
- readonly logs?: readonly {
986
- readonly id?: number | undefined;
987
- readonly address?: {
988
- readonly x0: bigint;
989
- readonly x1: bigint;
990
- readonly x2: number;
991
- } | undefined;
992
- readonly transactionStatus?: TransactionStatusFilter$1 | undefined;
993
- readonly includeReceipt?: boolean | undefined;
994
- readonly includeTransactionTrace?: boolean | undefined;
995
- readonly topics?: readonly {
996
- readonly value: {
997
- readonly x0: bigint;
998
- readonly x1: bigint;
999
- readonly x2: bigint;
1000
- readonly x3: bigint;
1001
- } | undefined;
1002
- }[] | undefined;
1003
- readonly strict?: boolean | undefined;
1004
- readonly includeTransaction?: boolean | undefined;
1005
- }[] | undefined;
1006
- };
1007
- declare const filterFromProto: (i: {
1008
- readonly header?: HeaderFilter$1 | undefined;
1009
- readonly withdrawals?: readonly {
1010
- readonly id?: number | undefined;
1011
- readonly validatorIndex?: number | undefined;
1012
- readonly address?: {
1013
- readonly x0: bigint;
1014
- readonly x1: bigint;
1015
- readonly x2: number;
1016
- } | undefined;
1017
- }[] | undefined;
1018
- readonly transactions?: readonly {
1019
- readonly id?: number | undefined;
1020
- readonly from?: {
1021
- readonly x0: bigint;
1022
- readonly x1: bigint;
1023
- readonly x2: number;
1024
- } | undefined;
1025
- readonly to?: {
1026
- readonly x0: bigint;
1027
- readonly x1: bigint;
1028
- readonly x2: number;
1029
- } | undefined;
1030
- readonly create?: boolean | undefined;
1031
- readonly transactionStatus?: TransactionStatusFilter$1 | undefined;
1032
- readonly includeReceipt?: boolean | undefined;
1033
- readonly includeLogs?: boolean | undefined;
1034
- readonly includeTransactionTrace?: boolean | undefined;
1035
- }[] | undefined;
1036
- readonly logs?: readonly {
1037
- readonly id?: number | undefined;
1038
- readonly address?: {
1039
- readonly x0: bigint;
1040
- readonly x1: bigint;
1041
- readonly x2: number;
1042
- } | undefined;
1043
- readonly transactionStatus?: TransactionStatusFilter$1 | undefined;
1044
- readonly includeReceipt?: boolean | undefined;
1045
- readonly includeTransactionTrace?: boolean | undefined;
1046
- readonly topics?: readonly {
1047
- readonly value: {
1048
- readonly x0: bigint;
1049
- readonly x1: bigint;
1050
- readonly x2: bigint;
1051
- readonly x3: bigint;
1052
- } | undefined;
778
+ type TransactionFilter = Readonly<CodecType<typeof TransactionFilter>>;
779
+ declare const Filter: MessageCodec<{
780
+ header: Codec<"always" | "on_data" | "on_data_or_on_new_block" | "unknown" | undefined, HeaderFilter$1 | undefined>;
781
+ withdrawals: Codec<readonly {
782
+ id?: number | undefined;
783
+ validatorIndex?: number | undefined;
784
+ address?: `0x${string}` | undefined;
785
+ }[] | undefined, readonly {
786
+ id?: number | undefined;
787
+ validatorIndex?: number | undefined;
788
+ address?: Address$1 | undefined;
789
+ }[] | undefined>;
790
+ transactions: Codec<readonly {
791
+ id?: number | undefined;
792
+ from?: `0x${string}` | undefined;
793
+ to?: `0x${string}` | undefined;
794
+ create?: boolean | undefined;
795
+ transactionStatus?: "unknown" | "succeeded" | "reverted" | "all" | undefined;
796
+ includeReceipt?: boolean | undefined;
797
+ includeLogs?: boolean | undefined;
798
+ includeTransactionTrace?: boolean | undefined;
799
+ }[] | undefined, readonly {
800
+ id?: number | undefined;
801
+ from?: Address$1 | undefined;
802
+ to?: Address$1 | undefined;
803
+ create?: boolean | undefined;
804
+ transactionStatus?: TransactionStatusFilter$1 | undefined;
805
+ includeReceipt?: boolean | undefined;
806
+ includeLogs?: boolean | undefined;
807
+ includeTransactionTrace?: boolean | undefined;
808
+ }[] | undefined>;
809
+ logs: Codec<readonly {
810
+ id?: number | undefined;
811
+ address?: `0x${string}` | undefined;
812
+ topics?: readonly (`0x${string}` | null)[] | undefined;
813
+ strict?: boolean | undefined;
814
+ transactionStatus?: "unknown" | "succeeded" | "reverted" | "all" | undefined;
815
+ includeTransaction?: boolean | undefined;
816
+ includeReceipt?: boolean | undefined;
817
+ includeTransactionTrace?: boolean | undefined;
818
+ }[] | undefined, readonly {
819
+ id?: number | undefined;
820
+ address?: Address$1 | undefined;
821
+ topics?: readonly {
822
+ value?: B256$1 | undefined;
1053
823
  }[] | undefined;
1054
- readonly strict?: boolean | undefined;
1055
- readonly includeTransaction?: boolean | undefined;
1056
- }[] | undefined;
1057
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => {
1058
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
1059
- readonly withdrawals?: readonly {
1060
- readonly id?: number | undefined;
1061
- readonly validatorIndex?: number | undefined;
1062
- readonly address?: `0x${string}` | undefined;
1063
- }[] | undefined;
1064
- readonly transactions?: readonly {
1065
- readonly id?: number | undefined;
1066
- readonly from?: `0x${string}` | undefined;
1067
- readonly to?: `0x${string}` | undefined;
1068
- readonly create?: boolean | undefined;
1069
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
1070
- readonly includeReceipt?: boolean | undefined;
1071
- readonly includeLogs?: boolean | undefined;
1072
- readonly includeTransactionTrace?: boolean | undefined;
1073
- }[] | undefined;
1074
- readonly logs?: readonly {
1075
- readonly id?: number | undefined;
1076
- readonly address?: `0x${string}` | undefined;
1077
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
1078
- readonly includeReceipt?: boolean | undefined;
1079
- readonly includeTransactionTrace?: boolean | undefined;
1080
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
1081
- readonly strict?: boolean | undefined;
1082
- readonly includeTransaction?: boolean | undefined;
1083
- }[] | undefined;
1084
- };
1085
- declare const FilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
1086
- header: Schema.optional<Schema.transform<Schema.Enums<typeof HeaderFilter$1>, Schema.Literal<["always", "on_data", "on_data_or_on_new_block", "unknown"]>>>;
1087
- withdrawals: Schema.optional<Schema.Array$<Schema.Struct<{
1088
- id: Schema.optional<typeof Schema.Number>;
1089
- validatorIndex: Schema.optional<typeof Schema.Number>;
1090
- address: Schema.optional<Schema.transform<Schema.Struct<{
1091
- x0: typeof Schema.BigIntFromSelf;
1092
- x1: typeof Schema.BigIntFromSelf;
1093
- x2: typeof Schema.Number;
1094
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1095
- }>>>;
1096
- transactions: Schema.optional<Schema.Array$<Schema.Struct<{
1097
- id: Schema.optional<typeof Schema.Number>;
1098
- from: Schema.optional<Schema.transform<Schema.Struct<{
1099
- x0: typeof Schema.BigIntFromSelf;
1100
- x1: typeof Schema.BigIntFromSelf;
1101
- x2: typeof Schema.Number;
1102
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1103
- to: Schema.optional<Schema.transform<Schema.Struct<{
1104
- x0: typeof Schema.BigIntFromSelf;
1105
- x1: typeof Schema.BigIntFromSelf;
1106
- x2: typeof Schema.Number;
1107
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1108
- create: Schema.optional<typeof Schema.Boolean>;
1109
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
1110
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
1111
- includeLogs: Schema.optional<typeof Schema.Boolean>;
1112
- includeTransactionTrace: Schema.optional<typeof Schema.Boolean>;
1113
- }>>>;
1114
- logs: Schema.optional<Schema.Array$<Schema.Struct<{
1115
- id: Schema.optional<typeof Schema.Number>;
1116
- address: Schema.optional<Schema.transform<Schema.Struct<{
1117
- x0: typeof Schema.BigIntFromSelf;
1118
- x1: typeof Schema.BigIntFromSelf;
1119
- x2: typeof Schema.Number;
1120
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1121
- topics: Schema.optional<Schema.Array$<Schema.transform<Schema.Struct<{
1122
- value: Schema.UndefinedOr<Schema.Struct<{
1123
- x0: typeof Schema.BigIntFromSelf;
1124
- x1: typeof Schema.BigIntFromSelf;
1125
- x2: typeof Schema.BigIntFromSelf;
1126
- x3: typeof Schema.BigIntFromSelf;
1127
- }>>;
1128
- }>, Schema.NullOr<Schema.transform<Schema.Struct<{
1129
- x0: typeof Schema.BigIntFromSelf;
1130
- x1: typeof Schema.BigIntFromSelf;
1131
- x2: typeof Schema.BigIntFromSelf;
1132
- x3: typeof Schema.BigIntFromSelf;
1133
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>>>>;
1134
- strict: Schema.optional<typeof Schema.Boolean>;
1135
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
1136
- includeTransaction: Schema.optional<typeof Schema.Boolean>;
1137
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
1138
- includeTransactionTrace: Schema.optional<typeof Schema.Boolean>;
1139
- }>>>;
1140
- }>>;
1141
- declare const filterToBytes: (a: {
1142
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
1143
- readonly withdrawals?: readonly {
1144
- readonly id?: number | undefined;
1145
- readonly validatorIndex?: number | undefined;
1146
- readonly address?: `0x${string}` | undefined;
1147
- }[] | undefined;
1148
- readonly transactions?: readonly {
1149
- readonly id?: number | undefined;
1150
- readonly from?: `0x${string}` | undefined;
1151
- readonly to?: `0x${string}` | undefined;
1152
- readonly create?: boolean | undefined;
1153
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
1154
- readonly includeReceipt?: boolean | undefined;
1155
- readonly includeLogs?: boolean | undefined;
1156
- readonly includeTransactionTrace?: boolean | undefined;
1157
- }[] | undefined;
1158
- readonly logs?: readonly {
1159
- readonly id?: number | undefined;
1160
- readonly address?: `0x${string}` | undefined;
1161
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
1162
- readonly includeReceipt?: boolean | undefined;
1163
- readonly includeTransactionTrace?: boolean | undefined;
1164
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
1165
- readonly strict?: boolean | undefined;
1166
- readonly includeTransaction?: boolean | undefined;
1167
- }[] | undefined;
1168
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => Uint8Array;
1169
- declare const filterFromBytes: (i: Uint8Array, overrideOptions?: _effect_schema_AST.ParseOptions) => {
1170
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
1171
- readonly withdrawals?: readonly {
1172
- readonly id?: number | undefined;
1173
- readonly validatorIndex?: number | undefined;
1174
- readonly address?: `0x${string}` | undefined;
1175
- }[] | undefined;
1176
- readonly transactions?: readonly {
1177
- readonly id?: number | undefined;
1178
- readonly from?: `0x${string}` | undefined;
1179
- readonly to?: `0x${string}` | undefined;
1180
- readonly create?: boolean | undefined;
1181
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
1182
- readonly includeReceipt?: boolean | undefined;
1183
- readonly includeLogs?: boolean | undefined;
1184
- readonly includeTransactionTrace?: boolean | undefined;
1185
- }[] | undefined;
1186
- readonly logs?: readonly {
1187
- readonly id?: number | undefined;
1188
- readonly address?: `0x${string}` | undefined;
1189
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
1190
- readonly includeReceipt?: boolean | undefined;
1191
- readonly includeTransactionTrace?: boolean | undefined;
1192
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
1193
- readonly strict?: boolean | undefined;
1194
- readonly includeTransaction?: boolean | undefined;
1195
- }[] | undefined;
1196
- };
824
+ strict?: boolean | undefined;
825
+ transactionStatus?: TransactionStatusFilter$1 | undefined;
826
+ includeTransaction?: boolean | undefined;
827
+ includeReceipt?: boolean | undefined;
828
+ includeTransactionTrace?: boolean | undefined;
829
+ }[] | undefined>;
830
+ }>;
831
+ type Filter = Readonly<CodecType<typeof Filter>>;
832
+ declare const FilterFromBytes: Codec<Filter, Uint8Array>;
1197
833
  declare function mergeFilter(a: Filter, b: Filter): Filter;
1198
834
 
1199
- declare const Bloom: Schema.transform<Schema.Struct<{
1200
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1201
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1202
- type Bloom = typeof Bloom.Type;
1203
- declare const TransactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
1204
- type TransactionStatus = typeof TransactionStatus.Type;
1205
- declare const BlockHeader: Schema.Struct<{
1206
- blockNumber: typeof Schema.BigIntFromSelf;
1207
- blockHash: Schema.transform<Schema.Struct<{
1208
- x0: typeof Schema.BigIntFromSelf;
1209
- x1: typeof Schema.BigIntFromSelf;
1210
- x2: typeof Schema.BigIntFromSelf;
1211
- x3: typeof Schema.BigIntFromSelf;
1212
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1213
- parentBlockHash: Schema.transform<Schema.Struct<{
1214
- x0: typeof Schema.BigIntFromSelf;
1215
- x1: typeof Schema.BigIntFromSelf;
1216
- x2: typeof Schema.BigIntFromSelf;
1217
- x3: typeof Schema.BigIntFromSelf;
1218
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1219
- unclesHash: Schema.transform<Schema.Struct<{
1220
- x0: typeof Schema.BigIntFromSelf;
1221
- x1: typeof Schema.BigIntFromSelf;
1222
- x2: typeof Schema.BigIntFromSelf;
1223
- x3: typeof Schema.BigIntFromSelf;
1224
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1225
- miner: Schema.transform<Schema.Struct<{
1226
- x0: typeof Schema.BigIntFromSelf;
1227
- x1: typeof Schema.BigIntFromSelf;
1228
- x2: typeof Schema.Number;
1229
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1230
- stateRoot: Schema.transform<Schema.Struct<{
1231
- x0: typeof Schema.BigIntFromSelf;
1232
- x1: typeof Schema.BigIntFromSelf;
1233
- x2: typeof Schema.BigIntFromSelf;
1234
- x3: typeof Schema.BigIntFromSelf;
1235
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1236
- transactionsRoot: Schema.transform<Schema.Struct<{
1237
- x0: typeof Schema.BigIntFromSelf;
1238
- x1: typeof Schema.BigIntFromSelf;
1239
- x2: typeof Schema.BigIntFromSelf;
1240
- x3: typeof Schema.BigIntFromSelf;
1241
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1242
- receiptsRoot: Schema.transform<Schema.Struct<{
1243
- x0: typeof Schema.BigIntFromSelf;
1244
- x1: typeof Schema.BigIntFromSelf;
1245
- x2: typeof Schema.BigIntFromSelf;
1246
- x3: typeof Schema.BigIntFromSelf;
1247
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1248
- logsBloom: Schema.transform<Schema.Struct<{
1249
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1250
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1251
- difficulty: Schema.transform<Schema.Struct<{
1252
- x0: typeof Schema.BigIntFromSelf;
1253
- x1: typeof Schema.BigIntFromSelf;
1254
- x2: typeof Schema.BigIntFromSelf;
1255
- x3: typeof Schema.BigIntFromSelf;
1256
- }>, typeof Schema.BigIntFromSelf>;
1257
- gasLimit: Schema.transform<Schema.Struct<{
1258
- x0: typeof Schema.BigIntFromSelf;
1259
- x1: typeof Schema.BigIntFromSelf;
1260
- }>, typeof Schema.BigIntFromSelf>;
1261
- gasUsed: Schema.transform<Schema.Struct<{
1262
- x0: typeof Schema.BigIntFromSelf;
1263
- x1: typeof Schema.BigIntFromSelf;
1264
- }>, typeof Schema.BigIntFromSelf>;
1265
- timestamp: typeof Schema.DateFromSelf;
1266
- extraData: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1267
- mixHash: Schema.optional<Schema.transform<Schema.Struct<{
1268
- x0: typeof Schema.BigIntFromSelf;
1269
- x1: typeof Schema.BigIntFromSelf;
1270
- x2: typeof Schema.BigIntFromSelf;
1271
- x3: typeof Schema.BigIntFromSelf;
1272
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1273
- nonce: Schema.optional<typeof Schema.BigIntFromSelf>;
1274
- baseFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1275
- x0: typeof Schema.BigIntFromSelf;
1276
- x1: typeof Schema.BigIntFromSelf;
1277
- }>, typeof Schema.BigIntFromSelf>>;
1278
- withdrawalsRoot: Schema.optional<Schema.transform<Schema.Struct<{
1279
- x0: typeof Schema.BigIntFromSelf;
1280
- x1: typeof Schema.BigIntFromSelf;
1281
- x2: typeof Schema.BigIntFromSelf;
1282
- x3: typeof Schema.BigIntFromSelf;
1283
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1284
- totalDifficulty: Schema.optional<Schema.transform<Schema.Struct<{
1285
- x0: typeof Schema.BigIntFromSelf;
1286
- x1: typeof Schema.BigIntFromSelf;
1287
- x2: typeof Schema.BigIntFromSelf;
1288
- x3: typeof Schema.BigIntFromSelf;
1289
- }>, typeof Schema.BigIntFromSelf>>;
1290
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
1291
- x0: typeof Schema.BigIntFromSelf;
1292
- x1: typeof Schema.BigIntFromSelf;
1293
- }>, typeof Schema.BigIntFromSelf>>;
1294
- excessBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
1295
- x0: typeof Schema.BigIntFromSelf;
1296
- x1: typeof Schema.BigIntFromSelf;
1297
- }>, typeof Schema.BigIntFromSelf>>;
1298
- parentBeaconBlockRoot: Schema.optional<Schema.transform<Schema.Struct<{
1299
- x0: typeof Schema.BigIntFromSelf;
1300
- x1: typeof Schema.BigIntFromSelf;
1301
- x2: typeof Schema.BigIntFromSelf;
1302
- x3: typeof Schema.BigIntFromSelf;
1303
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1304
- requestsHash: Schema.optional<Schema.transform<Schema.Struct<{
1305
- x0: typeof Schema.BigIntFromSelf;
1306
- x1: typeof Schema.BigIntFromSelf;
1307
- x2: typeof Schema.BigIntFromSelf;
1308
- x3: typeof Schema.BigIntFromSelf;
1309
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
835
+ declare const Bloom: Codec<`0x${string}` | undefined, {
836
+ value?: Uint8Array | undefined;
1310
837
  }>;
1311
- type BlockHeader = typeof BlockHeader.Type;
1312
- declare const Withdrawal: Schema.Struct<{
1313
- filterIds: Schema.Array$<typeof Schema.Number>;
1314
- withdrawalIndex: typeof Schema.Number;
1315
- index: typeof Schema.BigIntFromSelf;
1316
- validatorIndex: typeof Schema.Number;
1317
- address: Schema.transform<Schema.Struct<{
1318
- x0: typeof Schema.BigIntFromSelf;
1319
- x1: typeof Schema.BigIntFromSelf;
1320
- x2: typeof Schema.Number;
1321
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1322
- amount: typeof Schema.BigIntFromSelf;
838
+ type Bloom = CodecType<typeof Bloom>;
839
+ declare const TransactionStatus: Codec<"unknown" | "succeeded" | "reverted", TransactionStatus$1>;
840
+ type TransactionStatus = CodecType<typeof TransactionStatus>;
841
+ declare const BlockHeader: MessageCodec<{
842
+ blockNumber: Codec<bigint, bigint | undefined>;
843
+ blockHash: Codec<`0x${string}`, B256$1 | undefined>;
844
+ parentBlockHash: Codec<`0x${string}`, B256$1 | undefined>;
845
+ unclesHash: Codec<`0x${string}`, B256$1 | undefined>;
846
+ miner: Codec<`0x${string}`, Address$1 | undefined>;
847
+ stateRoot: Codec<`0x${string}`, B256$1 | undefined>;
848
+ transactionsRoot: Codec<`0x${string}`, B256$1 | undefined>;
849
+ receiptsRoot: Codec<`0x${string}`, B256$1 | undefined>;
850
+ logsBloom: Codec<`0x${string}`, {
851
+ value?: Uint8Array | undefined;
852
+ } | undefined>;
853
+ difficulty: Codec<bigint, U256$1 | undefined>;
854
+ gasLimit: Codec<bigint, U128$1 | undefined>;
855
+ gasUsed: Codec<bigint, U128$1 | undefined>;
856
+ timestamp: Codec<Date, Date | undefined>;
857
+ extraData: Codec<`0x${string}`, Uint8Array | undefined>;
858
+ mixHash: Codec<`0x${string}` | undefined, B256$1 | undefined>;
859
+ nonce: Codec<bigint | undefined, bigint | undefined>;
860
+ baseFeePerGas: Codec<bigint | undefined, U128$1 | undefined>;
861
+ withdrawalsRoot: Codec<`0x${string}` | undefined, B256$1 | undefined>;
862
+ totalDifficulty: Codec<bigint | undefined, U256$1 | undefined>;
863
+ blobGasUsed: Codec<bigint | undefined, U128$1 | undefined>;
864
+ excessBlobGas: Codec<bigint | undefined, U128$1 | undefined>;
865
+ parentBeaconBlockRoot: Codec<`0x${string}` | undefined, B256$1 | undefined>;
866
+ requestsHash: Codec<`0x${string}` | undefined, B256$1 | undefined>;
1323
867
  }>;
1324
- type Withdrawal = typeof Withdrawal.Type;
1325
- declare const AccessListItem: Schema.Struct<{
1326
- address: Schema.transform<Schema.Struct<{
1327
- x0: typeof Schema.BigIntFromSelf;
1328
- x1: typeof Schema.BigIntFromSelf;
1329
- x2: typeof Schema.Number;
1330
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1331
- storageKeys: Schema.Array$<Schema.transform<Schema.Struct<{
1332
- x0: typeof Schema.BigIntFromSelf;
1333
- x1: typeof Schema.BigIntFromSelf;
1334
- x2: typeof Schema.BigIntFromSelf;
1335
- x3: typeof Schema.BigIntFromSelf;
1336
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
868
+ type BlockHeader = CodecType<typeof BlockHeader>;
869
+ declare const Withdrawal: MessageCodec<{
870
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
871
+ withdrawalIndex: Codec<number, number | undefined>;
872
+ index: Codec<bigint, bigint | undefined>;
873
+ validatorIndex: Codec<number, number | undefined>;
874
+ address: Codec<`0x${string}`, Address$1 | undefined>;
875
+ amount: Codec<bigint, bigint | undefined>;
1337
876
  }>;
1338
- type AccessListItem = typeof AccessListItem.Type;
1339
- declare const Signature: Schema.Struct<{
1340
- r: Schema.transform<Schema.Struct<{
1341
- x0: typeof Schema.BigIntFromSelf;
1342
- x1: typeof Schema.BigIntFromSelf;
1343
- x2: typeof Schema.BigIntFromSelf;
1344
- x3: typeof Schema.BigIntFromSelf;
1345
- }>, typeof Schema.BigIntFromSelf>;
1346
- s: Schema.transform<Schema.Struct<{
1347
- x0: typeof Schema.BigIntFromSelf;
1348
- x1: typeof Schema.BigIntFromSelf;
1349
- x2: typeof Schema.BigIntFromSelf;
1350
- x3: typeof Schema.BigIntFromSelf;
1351
- }>, typeof Schema.BigIntFromSelf>;
1352
- v: Schema.optional<Schema.transform<Schema.Struct<{
1353
- x0: typeof Schema.BigIntFromSelf;
1354
- x1: typeof Schema.BigIntFromSelf;
1355
- x2: typeof Schema.BigIntFromSelf;
1356
- x3: typeof Schema.BigIntFromSelf;
1357
- }>, typeof Schema.BigIntFromSelf>>;
1358
- YParity: Schema.optional<typeof Schema.Boolean>;
877
+ type Withdrawal = CodecType<typeof Withdrawal>;
878
+ declare const AccessListItem: MessageCodec<{
879
+ address: Codec<`0x${string}`, Address$1 | undefined>;
880
+ storageKeys: Codec<readonly `0x${string}`[], readonly B256$1[] | undefined>;
1359
881
  }>;
1360
- type Signature = typeof Signature.Type;
1361
- declare const Transaction: Schema.Struct<{
1362
- filterIds: Schema.Array$<typeof Schema.Number>;
1363
- transactionIndex: typeof Schema.Number;
1364
- transactionHash: Schema.transform<Schema.Struct<{
1365
- x0: typeof Schema.BigIntFromSelf;
1366
- x1: typeof Schema.BigIntFromSelf;
1367
- x2: typeof Schema.BigIntFromSelf;
1368
- x3: typeof Schema.BigIntFromSelf;
1369
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1370
- nonce: typeof Schema.BigIntFromSelf;
1371
- from: Schema.transform<Schema.Struct<{
1372
- x0: typeof Schema.BigIntFromSelf;
1373
- x1: typeof Schema.BigIntFromSelf;
1374
- x2: typeof Schema.Number;
1375
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1376
- to: Schema.optional<Schema.transform<Schema.Struct<{
1377
- x0: typeof Schema.BigIntFromSelf;
1378
- x1: typeof Schema.BigIntFromSelf;
1379
- x2: typeof Schema.Number;
1380
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1381
- value: Schema.transform<Schema.Struct<{
1382
- x0: typeof Schema.BigIntFromSelf;
1383
- x1: typeof Schema.BigIntFromSelf;
1384
- x2: typeof Schema.BigIntFromSelf;
1385
- x3: typeof Schema.BigIntFromSelf;
1386
- }>, typeof Schema.BigIntFromSelf>;
1387
- gasPrice: Schema.optional<Schema.transform<Schema.Struct<{
1388
- x0: typeof Schema.BigIntFromSelf;
1389
- x1: typeof Schema.BigIntFromSelf;
1390
- }>, typeof Schema.BigIntFromSelf>>;
1391
- gas: Schema.transform<Schema.Struct<{
1392
- x0: typeof Schema.BigIntFromSelf;
1393
- x1: typeof Schema.BigIntFromSelf;
1394
- }>, typeof Schema.BigIntFromSelf>;
1395
- maxFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1396
- x0: typeof Schema.BigIntFromSelf;
1397
- x1: typeof Schema.BigIntFromSelf;
1398
- }>, typeof Schema.BigIntFromSelf>>;
1399
- maxPriorityFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1400
- x0: typeof Schema.BigIntFromSelf;
1401
- x1: typeof Schema.BigIntFromSelf;
1402
- }>, typeof Schema.BigIntFromSelf>>;
1403
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1404
- signature: Schema.optional<Schema.Struct<{
1405
- r: Schema.transform<Schema.Struct<{
1406
- x0: typeof Schema.BigIntFromSelf;
1407
- x1: typeof Schema.BigIntFromSelf;
1408
- x2: typeof Schema.BigIntFromSelf;
1409
- x3: typeof Schema.BigIntFromSelf;
1410
- }>, typeof Schema.BigIntFromSelf>;
1411
- s: Schema.transform<Schema.Struct<{
1412
- x0: typeof Schema.BigIntFromSelf;
1413
- x1: typeof Schema.BigIntFromSelf;
1414
- x2: typeof Schema.BigIntFromSelf;
1415
- x3: typeof Schema.BigIntFromSelf;
1416
- }>, typeof Schema.BigIntFromSelf>;
1417
- v: Schema.optional<Schema.transform<Schema.Struct<{
1418
- x0: typeof Schema.BigIntFromSelf;
1419
- x1: typeof Schema.BigIntFromSelf;
1420
- x2: typeof Schema.BigIntFromSelf;
1421
- x3: typeof Schema.BigIntFromSelf;
1422
- }>, typeof Schema.BigIntFromSelf>>;
1423
- YParity: Schema.optional<typeof Schema.Boolean>;
1424
- }>>;
1425
- chainId: Schema.optional<typeof Schema.BigIntFromSelf>;
1426
- accessList: Schema.Array$<Schema.Struct<{
1427
- address: Schema.transform<Schema.Struct<{
1428
- x0: typeof Schema.BigIntFromSelf;
1429
- x1: typeof Schema.BigIntFromSelf;
1430
- x2: typeof Schema.Number;
1431
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1432
- storageKeys: Schema.Array$<Schema.transform<Schema.Struct<{
1433
- x0: typeof Schema.BigIntFromSelf;
1434
- x1: typeof Schema.BigIntFromSelf;
1435
- x2: typeof Schema.BigIntFromSelf;
1436
- x3: typeof Schema.BigIntFromSelf;
1437
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1438
- }>>;
1439
- transactionType: typeof Schema.BigIntFromSelf;
1440
- maxFeePerBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
1441
- x0: typeof Schema.BigIntFromSelf;
1442
- x1: typeof Schema.BigIntFromSelf;
1443
- }>, typeof Schema.BigIntFromSelf>>;
1444
- blobVersionedHashes: Schema.Array$<Schema.transform<Schema.Struct<{
1445
- x0: typeof Schema.BigIntFromSelf;
1446
- x1: typeof Schema.BigIntFromSelf;
1447
- x2: typeof Schema.BigIntFromSelf;
1448
- x3: typeof Schema.BigIntFromSelf;
1449
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1450
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
882
+ type AccessListItem = CodecType<typeof AccessListItem>;
883
+ declare const Signature: MessageCodec<{
884
+ r: Codec<bigint, U256$1 | undefined>;
885
+ s: Codec<bigint, U256$1 | undefined>;
886
+ v: Codec<bigint | undefined, U256$1 | undefined>;
887
+ YParity: Codec<boolean | undefined, boolean | undefined>;
1451
888
  }>;
1452
- type Transaction = typeof Transaction.Type;
1453
- declare const TransactionReceipt: Schema.Struct<{
1454
- filterIds: Schema.Array$<typeof Schema.Number>;
1455
- transactionIndex: typeof Schema.Number;
1456
- transactionHash: Schema.transform<Schema.Struct<{
1457
- x0: typeof Schema.BigIntFromSelf;
1458
- x1: typeof Schema.BigIntFromSelf;
1459
- x2: typeof Schema.BigIntFromSelf;
1460
- x3: typeof Schema.BigIntFromSelf;
1461
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1462
- cumulativeGasUsed: Schema.transform<Schema.Struct<{
1463
- x0: typeof Schema.BigIntFromSelf;
1464
- x1: typeof Schema.BigIntFromSelf;
1465
- }>, typeof Schema.BigIntFromSelf>;
1466
- gasUsed: Schema.transform<Schema.Struct<{
1467
- x0: typeof Schema.BigIntFromSelf;
1468
- x1: typeof Schema.BigIntFromSelf;
1469
- }>, typeof Schema.BigIntFromSelf>;
1470
- effectiveGasPrice: Schema.transform<Schema.Struct<{
1471
- x0: typeof Schema.BigIntFromSelf;
1472
- x1: typeof Schema.BigIntFromSelf;
1473
- }>, typeof Schema.BigIntFromSelf>;
1474
- from: Schema.transform<Schema.Struct<{
1475
- x0: typeof Schema.BigIntFromSelf;
1476
- x1: typeof Schema.BigIntFromSelf;
1477
- x2: typeof Schema.Number;
1478
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1479
- to: Schema.optional<Schema.transform<Schema.Struct<{
1480
- x0: typeof Schema.BigIntFromSelf;
1481
- x1: typeof Schema.BigIntFromSelf;
1482
- x2: typeof Schema.Number;
1483
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1484
- contractAddress: Schema.optional<Schema.transform<Schema.Struct<{
1485
- x0: typeof Schema.BigIntFromSelf;
1486
- x1: typeof Schema.BigIntFromSelf;
1487
- x2: typeof Schema.Number;
1488
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1489
- logsBloom: Schema.transform<Schema.Struct<{
1490
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1491
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1492
- transactionType: typeof Schema.BigIntFromSelf;
1493
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
1494
- x0: typeof Schema.BigIntFromSelf;
1495
- x1: typeof Schema.BigIntFromSelf;
1496
- }>, typeof Schema.BigIntFromSelf>>;
1497
- blobGasPrice: Schema.optional<Schema.transform<Schema.Struct<{
1498
- x0: typeof Schema.BigIntFromSelf;
1499
- x1: typeof Schema.BigIntFromSelf;
1500
- }>, typeof Schema.BigIntFromSelf>>;
1501
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
889
+ type Signature = CodecType<typeof Signature>;
890
+ declare const Transaction: MessageCodec<{
891
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
892
+ transactionIndex: Codec<number, number | undefined>;
893
+ transactionHash: Codec<`0x${string}`, B256$1 | undefined>;
894
+ nonce: Codec<bigint, bigint | undefined>;
895
+ from: Codec<`0x${string}`, Address$1 | undefined>;
896
+ to: Codec<`0x${string}` | undefined, Address$1 | undefined>;
897
+ value: Codec<bigint, U256$1 | undefined>;
898
+ gasPrice: Codec<bigint | undefined, U128$1 | undefined>;
899
+ gas: Codec<bigint, U128$1 | undefined>;
900
+ maxFeePerGas: Codec<bigint | undefined, U128$1 | undefined>;
901
+ maxPriorityFeePerGas: Codec<bigint | undefined, U128$1 | undefined>;
902
+ input: Codec<`0x${string}`, Uint8Array | undefined>;
903
+ signature: Codec<{
904
+ r: bigint;
905
+ s: bigint;
906
+ v?: bigint | undefined;
907
+ YParity?: boolean | undefined;
908
+ } | undefined, {
909
+ r?: U256$1 | undefined;
910
+ s?: U256$1 | undefined;
911
+ v?: U256$1 | undefined;
912
+ YParity?: boolean | undefined;
913
+ } | undefined>;
914
+ chainId: Codec<bigint | undefined, bigint | undefined>;
915
+ accessList: Codec<readonly {
916
+ address: `0x${string}`;
917
+ storageKeys: readonly `0x${string}`[];
918
+ }[], readonly {
919
+ address?: Address$1 | undefined;
920
+ storageKeys?: readonly B256$1[] | undefined;
921
+ }[] | undefined>;
922
+ transactionType: Codec<bigint, bigint | undefined>;
923
+ maxFeePerBlobGas: Codec<bigint | undefined, U128$1 | undefined>;
924
+ blobVersionedHashes: Codec<readonly `0x${string}`[], readonly B256$1[] | undefined>;
925
+ transactionStatus: Codec<"unknown", TransactionStatus$1 | undefined> | Codec<"succeeded", TransactionStatus$1 | undefined> | Codec<"reverted", TransactionStatus$1 | undefined>;
1502
926
  }>;
1503
- type TransactionReceipt = typeof TransactionReceipt.Type;
1504
- declare const Log: Schema.Struct<{
1505
- filterIds: Schema.Array$<typeof Schema.Number>;
1506
- address: Schema.transform<Schema.Struct<{
1507
- x0: typeof Schema.BigIntFromSelf;
1508
- x1: typeof Schema.BigIntFromSelf;
1509
- x2: typeof Schema.Number;
1510
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1511
- topics: Schema.Array$<Schema.transform<Schema.Struct<{
1512
- x0: typeof Schema.BigIntFromSelf;
1513
- x1: typeof Schema.BigIntFromSelf;
1514
- x2: typeof Schema.BigIntFromSelf;
1515
- x3: typeof Schema.BigIntFromSelf;
1516
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1517
- data: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1518
- logIndex: typeof Schema.Number;
1519
- logIndexInTransaction: typeof Schema.Number;
1520
- transactionIndex: typeof Schema.Number;
1521
- transactionHash: Schema.transform<Schema.Struct<{
1522
- x0: typeof Schema.BigIntFromSelf;
1523
- x1: typeof Schema.BigIntFromSelf;
1524
- x2: typeof Schema.BigIntFromSelf;
1525
- x3: typeof Schema.BigIntFromSelf;
1526
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1527
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
927
+ type Transaction = CodecType<typeof Transaction>;
928
+ declare const TransactionReceipt: MessageCodec<{
929
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
930
+ transactionIndex: Codec<number, number | undefined>;
931
+ transactionHash: Codec<`0x${string}`, B256$1 | undefined>;
932
+ cumulativeGasUsed: Codec<bigint, U128$1 | undefined>;
933
+ gasUsed: Codec<bigint, U128$1 | undefined>;
934
+ effectiveGasPrice: Codec<bigint, U128$1 | undefined>;
935
+ from: Codec<`0x${string}`, Address$1 | undefined>;
936
+ to: Codec<`0x${string}` | undefined, Address$1 | undefined>;
937
+ contractAddress: Codec<`0x${string}` | undefined, Address$1 | undefined>;
938
+ logsBloom: Codec<`0x${string}`, {
939
+ value?: Uint8Array | undefined;
940
+ } | undefined>;
941
+ transactionType: Codec<bigint, bigint | undefined>;
942
+ blobGasUsed: Codec<bigint | undefined, U128$1 | undefined>;
943
+ blobGasPrice: Codec<bigint | undefined, U128$1 | undefined>;
944
+ transactionStatus: Codec<"unknown", TransactionStatus$1 | undefined> | Codec<"succeeded", TransactionStatus$1 | undefined> | Codec<"reverted", TransactionStatus$1 | undefined>;
1528
945
  }>;
1529
- type Log = typeof Log.Type;
1530
- declare const CallType: Schema.transform<Schema.Enums<typeof CallType$1>, Schema.Literal<["unknown", "call", "delegateCall", "callCode", "delegateCall", "staticCall", "authCall"]>>;
1531
- type CallType = typeof CallType.Type;
1532
- declare const CreationMethod: Schema.transform<Schema.Enums<typeof CreationMethod$1>, Schema.Literal<["unknown", "create", "create2", "eofCreate"]>>;
1533
- type CreationMethod = typeof CreationMethod.Type;
1534
- declare const CallAction: Schema.Struct<{
1535
- _tag: Schema.PropertySignature<":", "call", "$case", ":", "call", false, never>;
1536
- call: Schema.Struct<{
1537
- fromAddress: Schema.transform<Schema.Struct<{
1538
- x0: typeof Schema.BigIntFromSelf;
1539
- x1: typeof Schema.BigIntFromSelf;
1540
- x2: typeof Schema.Number;
1541
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1542
- type: Schema.transform<Schema.Enums<typeof CallType$1>, Schema.Literal<["unknown", "call", "delegateCall", "callCode", "delegateCall", "staticCall", "authCall"]>>;
1543
- gas: typeof Schema.BigIntFromSelf;
1544
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1545
- toAddress: Schema.transform<Schema.Struct<{
1546
- x0: typeof Schema.BigIntFromSelf;
1547
- x1: typeof Schema.BigIntFromSelf;
1548
- x2: typeof Schema.Number;
1549
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1550
- value: Schema.transform<Schema.Struct<{
1551
- x0: typeof Schema.BigIntFromSelf;
1552
- x1: typeof Schema.BigIntFromSelf;
1553
- x2: typeof Schema.BigIntFromSelf;
1554
- x3: typeof Schema.BigIntFromSelf;
1555
- }>, typeof Schema.BigIntFromSelf>;
1556
- }>;
946
+ type TransactionReceipt = CodecType<typeof TransactionReceipt>;
947
+ declare const Log: MessageCodec<{
948
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
949
+ address: Codec<`0x${string}`, Address$1 | undefined>;
950
+ topics: Codec<readonly `0x${string}`[], readonly B256$1[] | undefined>;
951
+ data: Codec<`0x${string}`, Uint8Array | undefined>;
952
+ logIndex: Codec<number, number | undefined>;
953
+ logIndexInTransaction: Codec<number, number | undefined>;
954
+ transactionIndex: Codec<number, number | undefined>;
955
+ transactionHash: Codec<`0x${string}`, B256$1 | undefined>;
956
+ transactionStatus: Codec<"unknown", TransactionStatus$1 | undefined> | Codec<"succeeded", TransactionStatus$1 | undefined> | Codec<"reverted", TransactionStatus$1 | undefined>;
1557
957
  }>;
1558
- type CallAction = typeof CallAction.Type;
1559
- declare const CreateAction: Schema.Struct<{
1560
- _tag: Schema.PropertySignature<":", "create", "$case", ":", "create", false, never>;
1561
- create: Schema.Struct<{
1562
- fromAddress: Schema.transform<Schema.Struct<{
1563
- x0: typeof Schema.BigIntFromSelf;
1564
- x1: typeof Schema.BigIntFromSelf;
1565
- x2: typeof Schema.Number;
1566
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1567
- gas: typeof Schema.BigIntFromSelf;
1568
- init: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1569
- value: Schema.transform<Schema.Struct<{
1570
- x0: typeof Schema.BigIntFromSelf;
1571
- x1: typeof Schema.BigIntFromSelf;
1572
- x2: typeof Schema.BigIntFromSelf;
1573
- x3: typeof Schema.BigIntFromSelf;
1574
- }>, typeof Schema.BigIntFromSelf>;
1575
- creationMethod: Schema.transform<Schema.Enums<typeof CreationMethod$1>, Schema.Literal<["unknown", "create", "create2", "eofCreate"]>>;
1576
- }>;
958
+ type Log = CodecType<typeof Log>;
959
+ declare const CallType: Codec<"unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall", CallType$1>;
960
+ type CallType = CodecType<typeof CallType>;
961
+ declare const CreationMethod: Codec<"unknown" | "create" | "create2" | "eofCreate", CreationMethod$1>;
962
+ type CreationMethod = CodecType<typeof CreationMethod>;
963
+ declare const CallAction: MessageCodec<{
964
+ fromAddress: Codec<`0x${string}`, Address$1 | undefined>;
965
+ type: Codec<"unknown", CallType$1 | undefined> | Codec<"call", CallType$1 | undefined> | Codec<"delegateCall", CallType$1 | undefined> | Codec<"callCode", CallType$1 | undefined> | Codec<"staticCall", CallType$1 | undefined> | Codec<"authCall", CallType$1 | undefined>;
966
+ gas: Codec<bigint, bigint | undefined>;
967
+ input: Codec<`0x${string}`, Uint8Array | undefined>;
968
+ toAddress: Codec<`0x${string}`, Address$1 | undefined>;
969
+ value: Codec<bigint, U256$1 | undefined>;
1577
970
  }>;
1578
- type CreateAction = typeof CreateAction.Type;
1579
- declare const SelfDestructAction: Schema.Struct<{
1580
- _tag: Schema.PropertySignature<":", "selfDestruct", "$case", ":", "selfDestruct", false, never>;
1581
- selfDestruct: Schema.Struct<{
1582
- address: Schema.transform<Schema.Struct<{
1583
- x0: typeof Schema.BigIntFromSelf;
1584
- x1: typeof Schema.BigIntFromSelf;
1585
- x2: typeof Schema.Number;
1586
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1587
- balance: Schema.transform<Schema.Struct<{
1588
- x0: typeof Schema.BigIntFromSelf;
1589
- x1: typeof Schema.BigIntFromSelf;
1590
- x2: typeof Schema.BigIntFromSelf;
1591
- x3: typeof Schema.BigIntFromSelf;
1592
- }>, typeof Schema.BigIntFromSelf>;
1593
- refundAddress: Schema.transform<Schema.Struct<{
1594
- x0: typeof Schema.BigIntFromSelf;
1595
- x1: typeof Schema.BigIntFromSelf;
1596
- x2: typeof Schema.Number;
1597
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1598
- }>;
971
+ type CallAction = CodecType<typeof CallAction>;
972
+ declare const CreateAction: MessageCodec<{
973
+ fromAddress: Codec<`0x${string}`, Address$1 | undefined>;
974
+ gas: Codec<bigint, bigint | undefined>;
975
+ init: Codec<`0x${string}`, Uint8Array | undefined>;
976
+ value: Codec<bigint, U256$1 | undefined>;
977
+ creationMethod: Codec<"unknown", CreationMethod$1 | undefined> | Codec<"create", CreationMethod$1 | undefined> | Codec<"create2", CreationMethod$1 | undefined> | Codec<"eofCreate", CreationMethod$1 | undefined>;
1599
978
  }>;
1600
- type SelfDestructAction = typeof SelfDestructAction.Type;
1601
- declare const RewardType: Schema.transform<Schema.Enums<typeof RewardType$1>, Schema.Literal<["unknown", "block", "uncle"]>>;
1602
- type RewardType = typeof RewardType.Type;
1603
- declare const RewardAction: Schema.Struct<{
1604
- _tag: Schema.PropertySignature<":", "reward", "$case", ":", "reward", false, never>;
1605
- reward: Schema.Struct<{
1606
- author: Schema.transform<Schema.Struct<{
1607
- x0: typeof Schema.BigIntFromSelf;
1608
- x1: typeof Schema.BigIntFromSelf;
1609
- x2: typeof Schema.Number;
1610
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1611
- type: Schema.transform<Schema.Enums<typeof RewardType$1>, Schema.Literal<["unknown", "block", "uncle"]>>;
1612
- value: Schema.transform<Schema.Struct<{
1613
- x0: typeof Schema.BigIntFromSelf;
1614
- x1: typeof Schema.BigIntFromSelf;
1615
- x2: typeof Schema.BigIntFromSelf;
1616
- x3: typeof Schema.BigIntFromSelf;
1617
- }>, typeof Schema.BigIntFromSelf>;
1618
- }>;
979
+ type CreateAction = CodecType<typeof CreateAction>;
980
+ declare const SelfDestructAction: MessageCodec<{
981
+ address: Codec<`0x${string}`, Address$1 | undefined>;
982
+ balance: Codec<bigint, U256$1 | undefined>;
983
+ refundAddress: Codec<`0x${string}`, Address$1 | undefined>;
1619
984
  }>;
1620
- type RewardAction = typeof RewardAction.Type;
1621
- declare const CallOutput: Schema.Struct<{
1622
- _tag: Schema.PropertySignature<":", "callOutput", "$case", ":", "callOutput", false, never>;
1623
- callOutput: Schema.Struct<{
1624
- gasUsed: typeof Schema.BigIntFromSelf;
1625
- output: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1626
- }>;
985
+ type SelfDestructAction = CodecType<typeof SelfDestructAction>;
986
+ declare const RewardType: Codec<"unknown" | "block" | "uncle", RewardType$1>;
987
+ type RewardType = CodecType<typeof RewardType>;
988
+ declare const RewardAction: MessageCodec<{
989
+ author: Codec<`0x${string}`, Address$1 | undefined>;
990
+ type: Codec<"unknown", RewardType$1 | undefined> | Codec<"block", RewardType$1 | undefined> | Codec<"uncle", RewardType$1 | undefined>;
991
+ value: Codec<bigint, U256$1 | undefined>;
1627
992
  }>;
1628
- type CallOutput = typeof CallOutput.Type;
1629
- declare const CreateOutput: Schema.Struct<{
1630
- _tag: Schema.PropertySignature<":", "createOutput", "$case", ":", "createOutput", false, never>;
1631
- createOutput: Schema.Struct<{
1632
- address: Schema.transform<Schema.Struct<{
1633
- x0: typeof Schema.BigIntFromSelf;
1634
- x1: typeof Schema.BigIntFromSelf;
1635
- x2: typeof Schema.Number;
1636
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1637
- code: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1638
- gasUsed: typeof Schema.BigIntFromSelf;
1639
- }>;
993
+ type RewardAction = CodecType<typeof RewardAction>;
994
+ declare const CallOutput: MessageCodec<{
995
+ gasUsed: Codec<bigint, bigint | undefined>;
996
+ output: Codec<`0x${string}`, Uint8Array | undefined>;
1640
997
  }>;
1641
- type CreateOutput = typeof CreateOutput.Type;
1642
- declare const Trace: Schema.Struct<{
1643
- action: Schema.Union<[Schema.Struct<{
1644
- _tag: Schema.PropertySignature<":", "call", "$case", ":", "call", false, never>;
1645
- call: Schema.Struct<{
1646
- fromAddress: Schema.transform<Schema.Struct<{
1647
- x0: typeof Schema.BigIntFromSelf;
1648
- x1: typeof Schema.BigIntFromSelf;
1649
- x2: typeof Schema.Number;
1650
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1651
- type: Schema.transform<Schema.Enums<typeof CallType$1>, Schema.Literal<["unknown", "call", "delegateCall", "callCode", "delegateCall", "staticCall", "authCall"]>>;
1652
- gas: typeof Schema.BigIntFromSelf;
1653
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1654
- toAddress: Schema.transform<Schema.Struct<{
1655
- x0: typeof Schema.BigIntFromSelf;
1656
- x1: typeof Schema.BigIntFromSelf;
1657
- x2: typeof Schema.Number;
1658
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1659
- value: Schema.transform<Schema.Struct<{
1660
- x0: typeof Schema.BigIntFromSelf;
1661
- x1: typeof Schema.BigIntFromSelf;
1662
- x2: typeof Schema.BigIntFromSelf;
1663
- x3: typeof Schema.BigIntFromSelf;
1664
- }>, typeof Schema.BigIntFromSelf>;
1665
- }>;
1666
- }>, Schema.Struct<{
1667
- _tag: Schema.PropertySignature<":", "create", "$case", ":", "create", false, never>;
1668
- create: Schema.Struct<{
1669
- fromAddress: Schema.transform<Schema.Struct<{
1670
- x0: typeof Schema.BigIntFromSelf;
1671
- x1: typeof Schema.BigIntFromSelf;
1672
- x2: typeof Schema.Number;
1673
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1674
- gas: typeof Schema.BigIntFromSelf;
1675
- init: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1676
- value: Schema.transform<Schema.Struct<{
1677
- x0: typeof Schema.BigIntFromSelf;
1678
- x1: typeof Schema.BigIntFromSelf;
1679
- x2: typeof Schema.BigIntFromSelf;
1680
- x3: typeof Schema.BigIntFromSelf;
1681
- }>, typeof Schema.BigIntFromSelf>;
1682
- creationMethod: Schema.transform<Schema.Enums<typeof CreationMethod$1>, Schema.Literal<["unknown", "create", "create2", "eofCreate"]>>;
1683
- }>;
1684
- }>, Schema.Struct<{
1685
- _tag: Schema.PropertySignature<":", "selfDestruct", "$case", ":", "selfDestruct", false, never>;
1686
- selfDestruct: Schema.Struct<{
1687
- address: Schema.transform<Schema.Struct<{
1688
- x0: typeof Schema.BigIntFromSelf;
1689
- x1: typeof Schema.BigIntFromSelf;
1690
- x2: typeof Schema.Number;
1691
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1692
- balance: Schema.transform<Schema.Struct<{
1693
- x0: typeof Schema.BigIntFromSelf;
1694
- x1: typeof Schema.BigIntFromSelf;
1695
- x2: typeof Schema.BigIntFromSelf;
1696
- x3: typeof Schema.BigIntFromSelf;
1697
- }>, typeof Schema.BigIntFromSelf>;
1698
- refundAddress: Schema.transform<Schema.Struct<{
1699
- x0: typeof Schema.BigIntFromSelf;
1700
- x1: typeof Schema.BigIntFromSelf;
1701
- x2: typeof Schema.Number;
1702
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1703
- }>;
1704
- }>, Schema.Struct<{
1705
- _tag: Schema.PropertySignature<":", "reward", "$case", ":", "reward", false, never>;
1706
- reward: Schema.Struct<{
1707
- author: Schema.transform<Schema.Struct<{
1708
- x0: typeof Schema.BigIntFromSelf;
1709
- x1: typeof Schema.BigIntFromSelf;
1710
- x2: typeof Schema.Number;
1711
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1712
- type: Schema.transform<Schema.Enums<typeof RewardType$1>, Schema.Literal<["unknown", "block", "uncle"]>>;
1713
- value: Schema.transform<Schema.Struct<{
1714
- x0: typeof Schema.BigIntFromSelf;
1715
- x1: typeof Schema.BigIntFromSelf;
1716
- x2: typeof Schema.BigIntFromSelf;
1717
- x3: typeof Schema.BigIntFromSelf;
1718
- }>, typeof Schema.BigIntFromSelf>;
1719
- }>;
1720
- }>]>;
1721
- error: Schema.optional<typeof Schema.String>;
1722
- output: Schema.optional<Schema.Union<[Schema.Struct<{
1723
- _tag: Schema.PropertySignature<":", "callOutput", "$case", ":", "callOutput", false, never>;
1724
- callOutput: Schema.Struct<{
1725
- gasUsed: typeof Schema.BigIntFromSelf;
1726
- output: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1727
- }>;
1728
- }>, Schema.Struct<{
1729
- _tag: Schema.PropertySignature<":", "createOutput", "$case", ":", "createOutput", false, never>;
1730
- createOutput: Schema.Struct<{
1731
- address: Schema.transform<Schema.Struct<{
1732
- x0: typeof Schema.BigIntFromSelf;
1733
- x1: typeof Schema.BigIntFromSelf;
1734
- x2: typeof Schema.Number;
1735
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1736
- code: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1737
- gasUsed: typeof Schema.BigIntFromSelf;
1738
- }>;
1739
- }>]>>;
1740
- subtraces: typeof Schema.Number;
1741
- traceAddress: Schema.Array$<typeof Schema.Number>;
998
+ type CallOutput = CodecType<typeof CallOutput>;
999
+ declare const CreateOutput: MessageCodec<{
1000
+ address: Codec<`0x${string}`, Address$1 | undefined>;
1001
+ code: Codec<`0x${string}`, Uint8Array | undefined>;
1002
+ gasUsed: Codec<bigint, bigint | undefined>;
1742
1003
  }>;
1743
- type Trace = typeof Trace.Type;
1744
- declare const TransactionTrace: Schema.Struct<{
1745
- filterIds: Schema.Array$<typeof Schema.Number>;
1746
- transactionIndex: typeof Schema.Number;
1747
- transactionHash: Schema.transform<Schema.Struct<{
1748
- x0: typeof Schema.BigIntFromSelf;
1749
- x1: typeof Schema.BigIntFromSelf;
1750
- x2: typeof Schema.BigIntFromSelf;
1751
- x3: typeof Schema.BigIntFromSelf;
1752
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1753
- traces: Schema.Array$<Schema.Struct<{
1754
- action: Schema.Union<[Schema.Struct<{
1755
- _tag: Schema.PropertySignature<":", "call", "$case", ":", "call", false, never>;
1756
- call: Schema.Struct<{
1757
- fromAddress: Schema.transform<Schema.Struct<{
1758
- x0: typeof Schema.BigIntFromSelf;
1759
- x1: typeof Schema.BigIntFromSelf;
1760
- x2: typeof Schema.Number;
1761
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1762
- type: Schema.transform<Schema.Enums<typeof CallType$1>, Schema.Literal<["unknown", "call", "delegateCall", "callCode", "delegateCall", "staticCall", "authCall"]>>;
1763
- gas: typeof Schema.BigIntFromSelf;
1764
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1765
- toAddress: Schema.transform<Schema.Struct<{
1766
- x0: typeof Schema.BigIntFromSelf;
1767
- x1: typeof Schema.BigIntFromSelf;
1768
- x2: typeof Schema.Number;
1769
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1770
- value: Schema.transform<Schema.Struct<{
1771
- x0: typeof Schema.BigIntFromSelf;
1772
- x1: typeof Schema.BigIntFromSelf;
1773
- x2: typeof Schema.BigIntFromSelf;
1774
- x3: typeof Schema.BigIntFromSelf;
1775
- }>, typeof Schema.BigIntFromSelf>;
1776
- }>;
1777
- }>, Schema.Struct<{
1778
- _tag: Schema.PropertySignature<":", "create", "$case", ":", "create", false, never>;
1779
- create: Schema.Struct<{
1780
- fromAddress: Schema.transform<Schema.Struct<{
1781
- x0: typeof Schema.BigIntFromSelf;
1782
- x1: typeof Schema.BigIntFromSelf;
1783
- x2: typeof Schema.Number;
1784
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1785
- gas: typeof Schema.BigIntFromSelf;
1786
- init: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1787
- value: Schema.transform<Schema.Struct<{
1788
- x0: typeof Schema.BigIntFromSelf;
1789
- x1: typeof Schema.BigIntFromSelf;
1790
- x2: typeof Schema.BigIntFromSelf;
1791
- x3: typeof Schema.BigIntFromSelf;
1792
- }>, typeof Schema.BigIntFromSelf>;
1793
- creationMethod: Schema.transform<Schema.Enums<typeof CreationMethod$1>, Schema.Literal<["unknown", "create", "create2", "eofCreate"]>>;
1794
- }>;
1795
- }>, Schema.Struct<{
1796
- _tag: Schema.PropertySignature<":", "selfDestruct", "$case", ":", "selfDestruct", false, never>;
1797
- selfDestruct: Schema.Struct<{
1798
- address: Schema.transform<Schema.Struct<{
1799
- x0: typeof Schema.BigIntFromSelf;
1800
- x1: typeof Schema.BigIntFromSelf;
1801
- x2: typeof Schema.Number;
1802
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1803
- balance: Schema.transform<Schema.Struct<{
1804
- x0: typeof Schema.BigIntFromSelf;
1805
- x1: typeof Schema.BigIntFromSelf;
1806
- x2: typeof Schema.BigIntFromSelf;
1807
- x3: typeof Schema.BigIntFromSelf;
1808
- }>, typeof Schema.BigIntFromSelf>;
1809
- refundAddress: Schema.transform<Schema.Struct<{
1810
- x0: typeof Schema.BigIntFromSelf;
1811
- x1: typeof Schema.BigIntFromSelf;
1812
- x2: typeof Schema.Number;
1813
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1814
- }>;
1815
- }>, Schema.Struct<{
1816
- _tag: Schema.PropertySignature<":", "reward", "$case", ":", "reward", false, never>;
1817
- reward: Schema.Struct<{
1818
- author: Schema.transform<Schema.Struct<{
1819
- x0: typeof Schema.BigIntFromSelf;
1820
- x1: typeof Schema.BigIntFromSelf;
1821
- x2: typeof Schema.Number;
1822
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1823
- type: Schema.transform<Schema.Enums<typeof RewardType$1>, Schema.Literal<["unknown", "block", "uncle"]>>;
1824
- value: Schema.transform<Schema.Struct<{
1825
- x0: typeof Schema.BigIntFromSelf;
1826
- x1: typeof Schema.BigIntFromSelf;
1827
- x2: typeof Schema.BigIntFromSelf;
1828
- x3: typeof Schema.BigIntFromSelf;
1829
- }>, typeof Schema.BigIntFromSelf>;
1830
- }>;
1831
- }>]>;
1832
- error: Schema.optional<typeof Schema.String>;
1833
- output: Schema.optional<Schema.Union<[Schema.Struct<{
1834
- _tag: Schema.PropertySignature<":", "callOutput", "$case", ":", "callOutput", false, never>;
1835
- callOutput: Schema.Struct<{
1836
- gasUsed: typeof Schema.BigIntFromSelf;
1837
- output: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1838
- }>;
1839
- }>, Schema.Struct<{
1840
- _tag: Schema.PropertySignature<":", "createOutput", "$case", ":", "createOutput", false, never>;
1841
- createOutput: Schema.Struct<{
1842
- address: Schema.transform<Schema.Struct<{
1843
- x0: typeof Schema.BigIntFromSelf;
1844
- x1: typeof Schema.BigIntFromSelf;
1845
- x2: typeof Schema.Number;
1846
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1847
- code: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1848
- gasUsed: typeof Schema.BigIntFromSelf;
1849
- }>;
1850
- }>]>>;
1851
- subtraces: typeof Schema.Number;
1852
- traceAddress: Schema.Array$<typeof Schema.Number>;
1853
- }>>;
1004
+ type CreateOutput = CodecType<typeof CreateOutput>;
1005
+ declare const Trace: MessageCodec<{
1006
+ action: Codec<{
1007
+ _tag: "create";
1008
+ } & {
1009
+ create: {
1010
+ fromAddress: `0x${string}`;
1011
+ gas: bigint;
1012
+ init: `0x${string}`;
1013
+ value: bigint;
1014
+ creationMethod: "unknown" | "create" | "create2" | "eofCreate";
1015
+ };
1016
+ }, (({
1017
+ $case: "create";
1018
+ } & {
1019
+ create: {
1020
+ fromAddress?: Address$1 | undefined;
1021
+ gas?: bigint | undefined;
1022
+ init?: Uint8Array | undefined;
1023
+ value?: U256$1 | undefined;
1024
+ creationMethod?: CreationMethod$1 | undefined;
1025
+ };
1026
+ }) | ({
1027
+ $case: "call";
1028
+ } & {
1029
+ call: {
1030
+ fromAddress?: Address$1 | undefined;
1031
+ type?: CallType$1 | undefined;
1032
+ gas?: bigint | undefined;
1033
+ input?: Uint8Array | undefined;
1034
+ toAddress?: Address$1 | undefined;
1035
+ value?: U256$1 | undefined;
1036
+ };
1037
+ }) | ({
1038
+ $case: "selfDestruct";
1039
+ } & {
1040
+ selfDestruct: {
1041
+ address?: Address$1 | undefined;
1042
+ balance?: U256$1 | undefined;
1043
+ refundAddress?: Address$1 | undefined;
1044
+ };
1045
+ }) | ({
1046
+ $case: "reward";
1047
+ } & {
1048
+ reward: {
1049
+ author?: Address$1 | undefined;
1050
+ type?: RewardType$1 | undefined;
1051
+ value?: U256$1 | undefined;
1052
+ };
1053
+ })) | undefined> | Codec<{
1054
+ _tag: "call";
1055
+ } & {
1056
+ call: {
1057
+ fromAddress: `0x${string}`;
1058
+ type: "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall";
1059
+ gas: bigint;
1060
+ input: `0x${string}`;
1061
+ toAddress: `0x${string}`;
1062
+ value: bigint;
1063
+ };
1064
+ }, (({
1065
+ $case: "create";
1066
+ } & {
1067
+ create: {
1068
+ fromAddress?: Address$1 | undefined;
1069
+ gas?: bigint | undefined;
1070
+ init?: Uint8Array | undefined;
1071
+ value?: U256$1 | undefined;
1072
+ creationMethod?: CreationMethod$1 | undefined;
1073
+ };
1074
+ }) | ({
1075
+ $case: "call";
1076
+ } & {
1077
+ call: {
1078
+ fromAddress?: Address$1 | undefined;
1079
+ type?: CallType$1 | undefined;
1080
+ gas?: bigint | undefined;
1081
+ input?: Uint8Array | undefined;
1082
+ toAddress?: Address$1 | undefined;
1083
+ value?: U256$1 | undefined;
1084
+ };
1085
+ }) | ({
1086
+ $case: "selfDestruct";
1087
+ } & {
1088
+ selfDestruct: {
1089
+ address?: Address$1 | undefined;
1090
+ balance?: U256$1 | undefined;
1091
+ refundAddress?: Address$1 | undefined;
1092
+ };
1093
+ }) | ({
1094
+ $case: "reward";
1095
+ } & {
1096
+ reward: {
1097
+ author?: Address$1 | undefined;
1098
+ type?: RewardType$1 | undefined;
1099
+ value?: U256$1 | undefined;
1100
+ };
1101
+ })) | undefined> | Codec<{
1102
+ _tag: "selfDestruct";
1103
+ } & {
1104
+ selfDestruct: {
1105
+ address: `0x${string}`;
1106
+ balance: bigint;
1107
+ refundAddress: `0x${string}`;
1108
+ };
1109
+ }, (({
1110
+ $case: "create";
1111
+ } & {
1112
+ create: {
1113
+ fromAddress?: Address$1 | undefined;
1114
+ gas?: bigint | undefined;
1115
+ init?: Uint8Array | undefined;
1116
+ value?: U256$1 | undefined;
1117
+ creationMethod?: CreationMethod$1 | undefined;
1118
+ };
1119
+ }) | ({
1120
+ $case: "call";
1121
+ } & {
1122
+ call: {
1123
+ fromAddress?: Address$1 | undefined;
1124
+ type?: CallType$1 | undefined;
1125
+ gas?: bigint | undefined;
1126
+ input?: Uint8Array | undefined;
1127
+ toAddress?: Address$1 | undefined;
1128
+ value?: U256$1 | undefined;
1129
+ };
1130
+ }) | ({
1131
+ $case: "selfDestruct";
1132
+ } & {
1133
+ selfDestruct: {
1134
+ address?: Address$1 | undefined;
1135
+ balance?: U256$1 | undefined;
1136
+ refundAddress?: Address$1 | undefined;
1137
+ };
1138
+ }) | ({
1139
+ $case: "reward";
1140
+ } & {
1141
+ reward: {
1142
+ author?: Address$1 | undefined;
1143
+ type?: RewardType$1 | undefined;
1144
+ value?: U256$1 | undefined;
1145
+ };
1146
+ })) | undefined> | Codec<{
1147
+ _tag: "reward";
1148
+ } & {
1149
+ reward: {
1150
+ author: `0x${string}`;
1151
+ type: "unknown" | "block" | "uncle";
1152
+ value: bigint;
1153
+ };
1154
+ }, (({
1155
+ $case: "create";
1156
+ } & {
1157
+ create: {
1158
+ fromAddress?: Address$1 | undefined;
1159
+ gas?: bigint | undefined;
1160
+ init?: Uint8Array | undefined;
1161
+ value?: U256$1 | undefined;
1162
+ creationMethod?: CreationMethod$1 | undefined;
1163
+ };
1164
+ }) | ({
1165
+ $case: "call";
1166
+ } & {
1167
+ call: {
1168
+ fromAddress?: Address$1 | undefined;
1169
+ type?: CallType$1 | undefined;
1170
+ gas?: bigint | undefined;
1171
+ input?: Uint8Array | undefined;
1172
+ toAddress?: Address$1 | undefined;
1173
+ value?: U256$1 | undefined;
1174
+ };
1175
+ }) | ({
1176
+ $case: "selfDestruct";
1177
+ } & {
1178
+ selfDestruct: {
1179
+ address?: Address$1 | undefined;
1180
+ balance?: U256$1 | undefined;
1181
+ refundAddress?: Address$1 | undefined;
1182
+ };
1183
+ }) | ({
1184
+ $case: "reward";
1185
+ } & {
1186
+ reward: {
1187
+ author?: Address$1 | undefined;
1188
+ type?: RewardType$1 | undefined;
1189
+ value?: U256$1 | undefined;
1190
+ };
1191
+ })) | undefined>;
1192
+ error: Codec<string | undefined, string | undefined>;
1193
+ output: Codec<(({
1194
+ _tag: "callOutput";
1195
+ } & {
1196
+ callOutput: {
1197
+ gasUsed: bigint;
1198
+ output: `0x${string}`;
1199
+ };
1200
+ }) | ({
1201
+ _tag: "createOutput";
1202
+ } & {
1203
+ createOutput: {
1204
+ address: `0x${string}`;
1205
+ code: `0x${string}`;
1206
+ gasUsed: bigint;
1207
+ };
1208
+ })) | undefined, (({
1209
+ $case: "callOutput";
1210
+ } & {
1211
+ callOutput: {
1212
+ gasUsed?: bigint | undefined;
1213
+ output?: Uint8Array | undefined;
1214
+ };
1215
+ }) | ({
1216
+ $case: "createOutput";
1217
+ } & {
1218
+ createOutput: {
1219
+ address?: Address$1 | undefined;
1220
+ code?: Uint8Array | undefined;
1221
+ gasUsed?: bigint | undefined;
1222
+ };
1223
+ })) | undefined>;
1224
+ subtraces: Codec<number, number | undefined>;
1225
+ traceAddress: Codec<readonly number[], readonly number[] | undefined>;
1854
1226
  }>;
1855
- type TransactionTrace = typeof TransactionTrace.Type;
1856
- declare const Block: Schema.Struct<{
1857
- header: Schema.Struct<{
1858
- blockNumber: typeof Schema.BigIntFromSelf;
1859
- blockHash: Schema.transform<Schema.Struct<{
1860
- x0: typeof Schema.BigIntFromSelf;
1861
- x1: typeof Schema.BigIntFromSelf;
1862
- x2: typeof Schema.BigIntFromSelf;
1863
- x3: typeof Schema.BigIntFromSelf;
1864
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1865
- parentBlockHash: Schema.transform<Schema.Struct<{
1866
- x0: typeof Schema.BigIntFromSelf;
1867
- x1: typeof Schema.BigIntFromSelf;
1868
- x2: typeof Schema.BigIntFromSelf;
1869
- x3: typeof Schema.BigIntFromSelf;
1870
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1871
- unclesHash: Schema.transform<Schema.Struct<{
1872
- x0: typeof Schema.BigIntFromSelf;
1873
- x1: typeof Schema.BigIntFromSelf;
1874
- x2: typeof Schema.BigIntFromSelf;
1875
- x3: typeof Schema.BigIntFromSelf;
1876
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1877
- miner: Schema.transform<Schema.Struct<{
1878
- x0: typeof Schema.BigIntFromSelf;
1879
- x1: typeof Schema.BigIntFromSelf;
1880
- x2: typeof Schema.Number;
1881
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1882
- stateRoot: Schema.transform<Schema.Struct<{
1883
- x0: typeof Schema.BigIntFromSelf;
1884
- x1: typeof Schema.BigIntFromSelf;
1885
- x2: typeof Schema.BigIntFromSelf;
1886
- x3: typeof Schema.BigIntFromSelf;
1887
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1888
- transactionsRoot: Schema.transform<Schema.Struct<{
1889
- x0: typeof Schema.BigIntFromSelf;
1890
- x1: typeof Schema.BigIntFromSelf;
1891
- x2: typeof Schema.BigIntFromSelf;
1892
- x3: typeof Schema.BigIntFromSelf;
1893
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1894
- receiptsRoot: Schema.transform<Schema.Struct<{
1895
- x0: typeof Schema.BigIntFromSelf;
1896
- x1: typeof Schema.BigIntFromSelf;
1897
- x2: typeof Schema.BigIntFromSelf;
1898
- x3: typeof Schema.BigIntFromSelf;
1899
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1900
- logsBloom: Schema.transform<Schema.Struct<{
1901
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1902
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1903
- difficulty: Schema.transform<Schema.Struct<{
1904
- x0: typeof Schema.BigIntFromSelf;
1905
- x1: typeof Schema.BigIntFromSelf;
1906
- x2: typeof Schema.BigIntFromSelf;
1907
- x3: typeof Schema.BigIntFromSelf;
1908
- }>, typeof Schema.BigIntFromSelf>;
1909
- gasLimit: Schema.transform<Schema.Struct<{
1910
- x0: typeof Schema.BigIntFromSelf;
1911
- x1: typeof Schema.BigIntFromSelf;
1912
- }>, typeof Schema.BigIntFromSelf>;
1913
- gasUsed: Schema.transform<Schema.Struct<{
1914
- x0: typeof Schema.BigIntFromSelf;
1915
- x1: typeof Schema.BigIntFromSelf;
1916
- }>, typeof Schema.BigIntFromSelf>;
1917
- timestamp: typeof Schema.DateFromSelf;
1918
- extraData: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1919
- mixHash: Schema.optional<Schema.transform<Schema.Struct<{
1920
- x0: typeof Schema.BigIntFromSelf;
1921
- x1: typeof Schema.BigIntFromSelf;
1922
- x2: typeof Schema.BigIntFromSelf;
1923
- x3: typeof Schema.BigIntFromSelf;
1924
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1925
- nonce: Schema.optional<typeof Schema.BigIntFromSelf>;
1926
- baseFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1927
- x0: typeof Schema.BigIntFromSelf;
1928
- x1: typeof Schema.BigIntFromSelf;
1929
- }>, typeof Schema.BigIntFromSelf>>;
1930
- withdrawalsRoot: Schema.optional<Schema.transform<Schema.Struct<{
1931
- x0: typeof Schema.BigIntFromSelf;
1932
- x1: typeof Schema.BigIntFromSelf;
1933
- x2: typeof Schema.BigIntFromSelf;
1934
- x3: typeof Schema.BigIntFromSelf;
1935
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1936
- totalDifficulty: Schema.optional<Schema.transform<Schema.Struct<{
1937
- x0: typeof Schema.BigIntFromSelf;
1938
- x1: typeof Schema.BigIntFromSelf;
1939
- x2: typeof Schema.BigIntFromSelf;
1940
- x3: typeof Schema.BigIntFromSelf;
1941
- }>, typeof Schema.BigIntFromSelf>>;
1942
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
1943
- x0: typeof Schema.BigIntFromSelf;
1944
- x1: typeof Schema.BigIntFromSelf;
1945
- }>, typeof Schema.BigIntFromSelf>>;
1946
- excessBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
1947
- x0: typeof Schema.BigIntFromSelf;
1948
- x1: typeof Schema.BigIntFromSelf;
1949
- }>, typeof Schema.BigIntFromSelf>>;
1950
- parentBeaconBlockRoot: Schema.optional<Schema.transform<Schema.Struct<{
1951
- x0: typeof Schema.BigIntFromSelf;
1952
- x1: typeof Schema.BigIntFromSelf;
1953
- x2: typeof Schema.BigIntFromSelf;
1954
- x3: typeof Schema.BigIntFromSelf;
1955
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1956
- requestsHash: Schema.optional<Schema.transform<Schema.Struct<{
1957
- x0: typeof Schema.BigIntFromSelf;
1958
- x1: typeof Schema.BigIntFromSelf;
1959
- x2: typeof Schema.BigIntFromSelf;
1960
- x3: typeof Schema.BigIntFromSelf;
1961
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1962
- }>;
1963
- withdrawals: Schema.Array$<Schema.Struct<{
1964
- filterIds: Schema.Array$<typeof Schema.Number>;
1965
- withdrawalIndex: typeof Schema.Number;
1966
- index: typeof Schema.BigIntFromSelf;
1967
- validatorIndex: typeof Schema.Number;
1968
- address: Schema.transform<Schema.Struct<{
1969
- x0: typeof Schema.BigIntFromSelf;
1970
- x1: typeof Schema.BigIntFromSelf;
1971
- x2: typeof Schema.Number;
1972
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1973
- amount: typeof Schema.BigIntFromSelf;
1974
- }>>;
1975
- transactions: Schema.Array$<Schema.Struct<{
1976
- filterIds: Schema.Array$<typeof Schema.Number>;
1977
- transactionIndex: typeof Schema.Number;
1978
- transactionHash: Schema.transform<Schema.Struct<{
1979
- x0: typeof Schema.BigIntFromSelf;
1980
- x1: typeof Schema.BigIntFromSelf;
1981
- x2: typeof Schema.BigIntFromSelf;
1982
- x3: typeof Schema.BigIntFromSelf;
1983
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1984
- nonce: typeof Schema.BigIntFromSelf;
1985
- from: Schema.transform<Schema.Struct<{
1986
- x0: typeof Schema.BigIntFromSelf;
1987
- x1: typeof Schema.BigIntFromSelf;
1988
- x2: typeof Schema.Number;
1989
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1990
- to: Schema.optional<Schema.transform<Schema.Struct<{
1991
- x0: typeof Schema.BigIntFromSelf;
1992
- x1: typeof Schema.BigIntFromSelf;
1993
- x2: typeof Schema.Number;
1994
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1995
- value: Schema.transform<Schema.Struct<{
1996
- x0: typeof Schema.BigIntFromSelf;
1997
- x1: typeof Schema.BigIntFromSelf;
1998
- x2: typeof Schema.BigIntFromSelf;
1999
- x3: typeof Schema.BigIntFromSelf;
2000
- }>, typeof Schema.BigIntFromSelf>;
2001
- gasPrice: Schema.optional<Schema.transform<Schema.Struct<{
2002
- x0: typeof Schema.BigIntFromSelf;
2003
- x1: typeof Schema.BigIntFromSelf;
2004
- }>, typeof Schema.BigIntFromSelf>>;
2005
- gas: Schema.transform<Schema.Struct<{
2006
- x0: typeof Schema.BigIntFromSelf;
2007
- x1: typeof Schema.BigIntFromSelf;
2008
- }>, typeof Schema.BigIntFromSelf>;
2009
- maxFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
2010
- x0: typeof Schema.BigIntFromSelf;
2011
- x1: typeof Schema.BigIntFromSelf;
2012
- }>, typeof Schema.BigIntFromSelf>>;
2013
- maxPriorityFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
2014
- x0: typeof Schema.BigIntFromSelf;
2015
- x1: typeof Schema.BigIntFromSelf;
2016
- }>, typeof Schema.BigIntFromSelf>>;
2017
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2018
- signature: Schema.optional<Schema.Struct<{
2019
- r: Schema.transform<Schema.Struct<{
2020
- x0: typeof Schema.BigIntFromSelf;
2021
- x1: typeof Schema.BigIntFromSelf;
2022
- x2: typeof Schema.BigIntFromSelf;
2023
- x3: typeof Schema.BigIntFromSelf;
2024
- }>, typeof Schema.BigIntFromSelf>;
2025
- s: Schema.transform<Schema.Struct<{
2026
- x0: typeof Schema.BigIntFromSelf;
2027
- x1: typeof Schema.BigIntFromSelf;
2028
- x2: typeof Schema.BigIntFromSelf;
2029
- x3: typeof Schema.BigIntFromSelf;
2030
- }>, typeof Schema.BigIntFromSelf>;
2031
- v: Schema.optional<Schema.transform<Schema.Struct<{
2032
- x0: typeof Schema.BigIntFromSelf;
2033
- x1: typeof Schema.BigIntFromSelf;
2034
- x2: typeof Schema.BigIntFromSelf;
2035
- x3: typeof Schema.BigIntFromSelf;
2036
- }>, typeof Schema.BigIntFromSelf>>;
2037
- YParity: Schema.optional<typeof Schema.Boolean>;
2038
- }>>;
2039
- chainId: Schema.optional<typeof Schema.BigIntFromSelf>;
2040
- accessList: Schema.Array$<Schema.Struct<{
2041
- address: Schema.transform<Schema.Struct<{
2042
- x0: typeof Schema.BigIntFromSelf;
2043
- x1: typeof Schema.BigIntFromSelf;
2044
- x2: typeof Schema.Number;
2045
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2046
- storageKeys: Schema.Array$<Schema.transform<Schema.Struct<{
2047
- x0: typeof Schema.BigIntFromSelf;
2048
- x1: typeof Schema.BigIntFromSelf;
2049
- x2: typeof Schema.BigIntFromSelf;
2050
- x3: typeof Schema.BigIntFromSelf;
2051
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2052
- }>>;
2053
- transactionType: typeof Schema.BigIntFromSelf;
2054
- maxFeePerBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
2055
- x0: typeof Schema.BigIntFromSelf;
2056
- x1: typeof Schema.BigIntFromSelf;
2057
- }>, typeof Schema.BigIntFromSelf>>;
2058
- blobVersionedHashes: Schema.Array$<Schema.transform<Schema.Struct<{
2059
- x0: typeof Schema.BigIntFromSelf;
2060
- x1: typeof Schema.BigIntFromSelf;
2061
- x2: typeof Schema.BigIntFromSelf;
2062
- x3: typeof Schema.BigIntFromSelf;
2063
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2064
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
2065
- }>>;
2066
- receipts: Schema.Array$<Schema.Struct<{
2067
- filterIds: Schema.Array$<typeof Schema.Number>;
2068
- transactionIndex: typeof Schema.Number;
2069
- transactionHash: Schema.transform<Schema.Struct<{
2070
- x0: typeof Schema.BigIntFromSelf;
2071
- x1: typeof Schema.BigIntFromSelf;
2072
- x2: typeof Schema.BigIntFromSelf;
2073
- x3: typeof Schema.BigIntFromSelf;
2074
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2075
- cumulativeGasUsed: Schema.transform<Schema.Struct<{
2076
- x0: typeof Schema.BigIntFromSelf;
2077
- x1: typeof Schema.BigIntFromSelf;
2078
- }>, typeof Schema.BigIntFromSelf>;
2079
- gasUsed: Schema.transform<Schema.Struct<{
2080
- x0: typeof Schema.BigIntFromSelf;
2081
- x1: typeof Schema.BigIntFromSelf;
2082
- }>, typeof Schema.BigIntFromSelf>;
2083
- effectiveGasPrice: Schema.transform<Schema.Struct<{
2084
- x0: typeof Schema.BigIntFromSelf;
2085
- x1: typeof Schema.BigIntFromSelf;
2086
- }>, typeof Schema.BigIntFromSelf>;
2087
- from: Schema.transform<Schema.Struct<{
2088
- x0: typeof Schema.BigIntFromSelf;
2089
- x1: typeof Schema.BigIntFromSelf;
2090
- x2: typeof Schema.Number;
2091
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2092
- to: Schema.optional<Schema.transform<Schema.Struct<{
2093
- x0: typeof Schema.BigIntFromSelf;
2094
- x1: typeof Schema.BigIntFromSelf;
2095
- x2: typeof Schema.Number;
2096
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2097
- contractAddress: Schema.optional<Schema.transform<Schema.Struct<{
2098
- x0: typeof Schema.BigIntFromSelf;
2099
- x1: typeof Schema.BigIntFromSelf;
2100
- x2: typeof Schema.Number;
2101
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2102
- logsBloom: Schema.transform<Schema.Struct<{
2103
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2104
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2105
- transactionType: typeof Schema.BigIntFromSelf;
2106
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
2107
- x0: typeof Schema.BigIntFromSelf;
2108
- x1: typeof Schema.BigIntFromSelf;
2109
- }>, typeof Schema.BigIntFromSelf>>;
2110
- blobGasPrice: Schema.optional<Schema.transform<Schema.Struct<{
2111
- x0: typeof Schema.BigIntFromSelf;
2112
- x1: typeof Schema.BigIntFromSelf;
2113
- }>, typeof Schema.BigIntFromSelf>>;
2114
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
2115
- }>>;
2116
- logs: Schema.Array$<Schema.Struct<{
2117
- filterIds: Schema.Array$<typeof Schema.Number>;
2118
- address: Schema.transform<Schema.Struct<{
2119
- x0: typeof Schema.BigIntFromSelf;
2120
- x1: typeof Schema.BigIntFromSelf;
2121
- x2: typeof Schema.Number;
2122
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2123
- topics: Schema.Array$<Schema.transform<Schema.Struct<{
2124
- x0: typeof Schema.BigIntFromSelf;
2125
- x1: typeof Schema.BigIntFromSelf;
2126
- x2: typeof Schema.BigIntFromSelf;
2127
- x3: typeof Schema.BigIntFromSelf;
2128
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2129
- data: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2130
- logIndex: typeof Schema.Number;
2131
- logIndexInTransaction: typeof Schema.Number;
2132
- transactionIndex: typeof Schema.Number;
2133
- transactionHash: Schema.transform<Schema.Struct<{
2134
- x0: typeof Schema.BigIntFromSelf;
2135
- x1: typeof Schema.BigIntFromSelf;
2136
- x2: typeof Schema.BigIntFromSelf;
2137
- x3: typeof Schema.BigIntFromSelf;
2138
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2139
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
2140
- }>>;
2141
- traces: Schema.Array$<Schema.Struct<{
2142
- filterIds: Schema.Array$<typeof Schema.Number>;
2143
- transactionIndex: typeof Schema.Number;
2144
- transactionHash: Schema.transform<Schema.Struct<{
2145
- x0: typeof Schema.BigIntFromSelf;
2146
- x1: typeof Schema.BigIntFromSelf;
2147
- x2: typeof Schema.BigIntFromSelf;
2148
- x3: typeof Schema.BigIntFromSelf;
2149
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2150
- traces: Schema.Array$<Schema.Struct<{
2151
- action: Schema.Union<[Schema.Struct<{
2152
- _tag: Schema.PropertySignature<":", "call", "$case", ":", "call", false, never>;
2153
- call: Schema.Struct<{
2154
- fromAddress: Schema.transform<Schema.Struct<{
2155
- x0: typeof Schema.BigIntFromSelf;
2156
- x1: typeof Schema.BigIntFromSelf;
2157
- x2: typeof Schema.Number;
2158
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2159
- type: Schema.transform<Schema.Enums<typeof CallType$1>, Schema.Literal<["unknown", "call", "delegateCall", "callCode", "delegateCall", "staticCall", "authCall"]>>;
2160
- gas: typeof Schema.BigIntFromSelf;
2161
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2162
- toAddress: Schema.transform<Schema.Struct<{
2163
- x0: typeof Schema.BigIntFromSelf;
2164
- x1: typeof Schema.BigIntFromSelf;
2165
- x2: typeof Schema.Number;
2166
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2167
- value: Schema.transform<Schema.Struct<{
2168
- x0: typeof Schema.BigIntFromSelf;
2169
- x1: typeof Schema.BigIntFromSelf;
2170
- x2: typeof Schema.BigIntFromSelf;
2171
- x3: typeof Schema.BigIntFromSelf;
2172
- }>, typeof Schema.BigIntFromSelf>;
2173
- }>;
2174
- }>, Schema.Struct<{
2175
- _tag: Schema.PropertySignature<":", "create", "$case", ":", "create", false, never>;
2176
- create: Schema.Struct<{
2177
- fromAddress: Schema.transform<Schema.Struct<{
2178
- x0: typeof Schema.BigIntFromSelf;
2179
- x1: typeof Schema.BigIntFromSelf;
2180
- x2: typeof Schema.Number;
2181
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2182
- gas: typeof Schema.BigIntFromSelf;
2183
- init: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2184
- value: Schema.transform<Schema.Struct<{
2185
- x0: typeof Schema.BigIntFromSelf;
2186
- x1: typeof Schema.BigIntFromSelf;
2187
- x2: typeof Schema.BigIntFromSelf;
2188
- x3: typeof Schema.BigIntFromSelf;
2189
- }>, typeof Schema.BigIntFromSelf>;
2190
- creationMethod: Schema.transform<Schema.Enums<typeof CreationMethod$1>, Schema.Literal<["unknown", "create", "create2", "eofCreate"]>>;
2191
- }>;
2192
- }>, Schema.Struct<{
2193
- _tag: Schema.PropertySignature<":", "selfDestruct", "$case", ":", "selfDestruct", false, never>;
2194
- selfDestruct: Schema.Struct<{
2195
- address: Schema.transform<Schema.Struct<{
2196
- x0: typeof Schema.BigIntFromSelf;
2197
- x1: typeof Schema.BigIntFromSelf;
2198
- x2: typeof Schema.Number;
2199
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2200
- balance: Schema.transform<Schema.Struct<{
2201
- x0: typeof Schema.BigIntFromSelf;
2202
- x1: typeof Schema.BigIntFromSelf;
2203
- x2: typeof Schema.BigIntFromSelf;
2204
- x3: typeof Schema.BigIntFromSelf;
2205
- }>, typeof Schema.BigIntFromSelf>;
2206
- refundAddress: Schema.transform<Schema.Struct<{
2207
- x0: typeof Schema.BigIntFromSelf;
2208
- x1: typeof Schema.BigIntFromSelf;
2209
- x2: typeof Schema.Number;
2210
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2211
- }>;
2212
- }>, Schema.Struct<{
2213
- _tag: Schema.PropertySignature<":", "reward", "$case", ":", "reward", false, never>;
2214
- reward: Schema.Struct<{
2215
- author: Schema.transform<Schema.Struct<{
2216
- x0: typeof Schema.BigIntFromSelf;
2217
- x1: typeof Schema.BigIntFromSelf;
2218
- x2: typeof Schema.Number;
2219
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2220
- type: Schema.transform<Schema.Enums<typeof RewardType$1>, Schema.Literal<["unknown", "block", "uncle"]>>;
2221
- value: Schema.transform<Schema.Struct<{
2222
- x0: typeof Schema.BigIntFromSelf;
2223
- x1: typeof Schema.BigIntFromSelf;
2224
- x2: typeof Schema.BigIntFromSelf;
2225
- x3: typeof Schema.BigIntFromSelf;
2226
- }>, typeof Schema.BigIntFromSelf>;
2227
- }>;
2228
- }>]>;
2229
- error: Schema.optional<typeof Schema.String>;
2230
- output: Schema.optional<Schema.Union<[Schema.Struct<{
2231
- _tag: Schema.PropertySignature<":", "callOutput", "$case", ":", "callOutput", false, never>;
2232
- callOutput: Schema.Struct<{
2233
- gasUsed: typeof Schema.BigIntFromSelf;
2234
- output: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2235
- }>;
2236
- }>, Schema.Struct<{
2237
- _tag: Schema.PropertySignature<":", "createOutput", "$case", ":", "createOutput", false, never>;
2238
- createOutput: Schema.Struct<{
2239
- address: Schema.transform<Schema.Struct<{
2240
- x0: typeof Schema.BigIntFromSelf;
2241
- x1: typeof Schema.BigIntFromSelf;
2242
- x2: typeof Schema.Number;
2243
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2244
- code: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2245
- gasUsed: typeof Schema.BigIntFromSelf;
2246
- }>;
2247
- }>]>>;
2248
- subtraces: typeof Schema.Number;
2249
- traceAddress: Schema.Array$<typeof Schema.Number>;
2250
- }>>;
2251
- }>>;
1227
+ type Trace = CodecType<typeof Trace>;
1228
+ declare const TransactionTrace: MessageCodec<{
1229
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
1230
+ transactionIndex: Codec<number, number | undefined>;
1231
+ transactionHash: Codec<`0x${string}`, B256$1 | undefined>;
1232
+ traces: Codec<readonly {
1233
+ action: ({
1234
+ _tag: "create";
1235
+ } & {
1236
+ create: {
1237
+ fromAddress: `0x${string}`;
1238
+ gas: bigint;
1239
+ init: `0x${string}`;
1240
+ value: bigint;
1241
+ creationMethod: "unknown" | "create" | "create2" | "eofCreate";
1242
+ };
1243
+ }) | ({
1244
+ _tag: "call";
1245
+ } & {
1246
+ call: {
1247
+ fromAddress: `0x${string}`;
1248
+ type: "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall";
1249
+ gas: bigint;
1250
+ input: `0x${string}`;
1251
+ toAddress: `0x${string}`;
1252
+ value: bigint;
1253
+ };
1254
+ }) | ({
1255
+ _tag: "selfDestruct";
1256
+ } & {
1257
+ selfDestruct: {
1258
+ address: `0x${string}`;
1259
+ balance: bigint;
1260
+ refundAddress: `0x${string}`;
1261
+ };
1262
+ }) | ({
1263
+ _tag: "reward";
1264
+ } & {
1265
+ reward: {
1266
+ author: `0x${string}`;
1267
+ type: "unknown" | "block" | "uncle";
1268
+ value: bigint;
1269
+ };
1270
+ });
1271
+ error?: string | undefined;
1272
+ output?: (({
1273
+ _tag: "callOutput";
1274
+ } & {
1275
+ callOutput: {
1276
+ gasUsed: bigint;
1277
+ output: `0x${string}`;
1278
+ };
1279
+ }) | ({
1280
+ _tag: "createOutput";
1281
+ } & {
1282
+ createOutput: {
1283
+ address: `0x${string}`;
1284
+ code: `0x${string}`;
1285
+ gasUsed: bigint;
1286
+ };
1287
+ })) | undefined;
1288
+ subtraces: number;
1289
+ traceAddress: readonly number[];
1290
+ }[], readonly {
1291
+ action?: (({
1292
+ $case: "create";
1293
+ } & {
1294
+ create: {
1295
+ fromAddress?: Address$1 | undefined;
1296
+ gas?: bigint | undefined;
1297
+ init?: Uint8Array | undefined;
1298
+ value?: U256$1 | undefined;
1299
+ creationMethod?: CreationMethod$1 | undefined;
1300
+ };
1301
+ }) | ({
1302
+ $case: "call";
1303
+ } & {
1304
+ call: {
1305
+ fromAddress?: Address$1 | undefined;
1306
+ type?: CallType$1 | undefined;
1307
+ gas?: bigint | undefined;
1308
+ input?: Uint8Array | undefined;
1309
+ toAddress?: Address$1 | undefined;
1310
+ value?: U256$1 | undefined;
1311
+ };
1312
+ }) | ({
1313
+ $case: "selfDestruct";
1314
+ } & {
1315
+ selfDestruct: {
1316
+ address?: Address$1 | undefined;
1317
+ balance?: U256$1 | undefined;
1318
+ refundAddress?: Address$1 | undefined;
1319
+ };
1320
+ }) | ({
1321
+ $case: "reward";
1322
+ } & {
1323
+ reward: {
1324
+ author?: Address$1 | undefined;
1325
+ type?: RewardType$1 | undefined;
1326
+ value?: U256$1 | undefined;
1327
+ };
1328
+ })) | undefined;
1329
+ error?: string | undefined;
1330
+ output?: (({
1331
+ $case: "callOutput";
1332
+ } & {
1333
+ callOutput: {
1334
+ gasUsed?: bigint | undefined;
1335
+ output?: Uint8Array | undefined;
1336
+ };
1337
+ }) | ({
1338
+ $case: "createOutput";
1339
+ } & {
1340
+ createOutput: {
1341
+ address?: Address$1 | undefined;
1342
+ code?: Uint8Array | undefined;
1343
+ gasUsed?: bigint | undefined;
1344
+ };
1345
+ })) | undefined;
1346
+ subtraces?: number | undefined;
1347
+ traceAddress?: readonly number[] | undefined;
1348
+ }[] | undefined>;
2252
1349
  }>;
2253
- type Block = typeof Block.Type;
2254
- declare const BlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
2255
- header: Schema.Struct<{
2256
- blockNumber: typeof Schema.BigIntFromSelf;
2257
- blockHash: Schema.transform<Schema.Struct<{
2258
- x0: typeof Schema.BigIntFromSelf;
2259
- x1: typeof Schema.BigIntFromSelf;
2260
- x2: typeof Schema.BigIntFromSelf;
2261
- x3: typeof Schema.BigIntFromSelf;
2262
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2263
- parentBlockHash: Schema.transform<Schema.Struct<{
2264
- x0: typeof Schema.BigIntFromSelf;
2265
- x1: typeof Schema.BigIntFromSelf;
2266
- x2: typeof Schema.BigIntFromSelf;
2267
- x3: typeof Schema.BigIntFromSelf;
2268
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2269
- unclesHash: Schema.transform<Schema.Struct<{
2270
- x0: typeof Schema.BigIntFromSelf;
2271
- x1: typeof Schema.BigIntFromSelf;
2272
- x2: typeof Schema.BigIntFromSelf;
2273
- x3: typeof Schema.BigIntFromSelf;
2274
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2275
- miner: Schema.transform<Schema.Struct<{
2276
- x0: typeof Schema.BigIntFromSelf;
2277
- x1: typeof Schema.BigIntFromSelf;
2278
- x2: typeof Schema.Number;
2279
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2280
- stateRoot: Schema.transform<Schema.Struct<{
2281
- x0: typeof Schema.BigIntFromSelf;
2282
- x1: typeof Schema.BigIntFromSelf;
2283
- x2: typeof Schema.BigIntFromSelf;
2284
- x3: typeof Schema.BigIntFromSelf;
2285
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2286
- transactionsRoot: Schema.transform<Schema.Struct<{
2287
- x0: typeof Schema.BigIntFromSelf;
2288
- x1: typeof Schema.BigIntFromSelf;
2289
- x2: typeof Schema.BigIntFromSelf;
2290
- x3: typeof Schema.BigIntFromSelf;
2291
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2292
- receiptsRoot: Schema.transform<Schema.Struct<{
2293
- x0: typeof Schema.BigIntFromSelf;
2294
- x1: typeof Schema.BigIntFromSelf;
2295
- x2: typeof Schema.BigIntFromSelf;
2296
- x3: typeof Schema.BigIntFromSelf;
2297
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2298
- logsBloom: Schema.transform<Schema.Struct<{
2299
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2300
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2301
- difficulty: Schema.transform<Schema.Struct<{
2302
- x0: typeof Schema.BigIntFromSelf;
2303
- x1: typeof Schema.BigIntFromSelf;
2304
- x2: typeof Schema.BigIntFromSelf;
2305
- x3: typeof Schema.BigIntFromSelf;
2306
- }>, typeof Schema.BigIntFromSelf>;
2307
- gasLimit: Schema.transform<Schema.Struct<{
2308
- x0: typeof Schema.BigIntFromSelf;
2309
- x1: typeof Schema.BigIntFromSelf;
2310
- }>, typeof Schema.BigIntFromSelf>;
2311
- gasUsed: Schema.transform<Schema.Struct<{
2312
- x0: typeof Schema.BigIntFromSelf;
2313
- x1: typeof Schema.BigIntFromSelf;
2314
- }>, typeof Schema.BigIntFromSelf>;
2315
- timestamp: typeof Schema.DateFromSelf;
2316
- extraData: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2317
- mixHash: Schema.optional<Schema.transform<Schema.Struct<{
2318
- x0: typeof Schema.BigIntFromSelf;
2319
- x1: typeof Schema.BigIntFromSelf;
2320
- x2: typeof Schema.BigIntFromSelf;
2321
- x3: typeof Schema.BigIntFromSelf;
2322
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2323
- nonce: Schema.optional<typeof Schema.BigIntFromSelf>;
2324
- baseFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
2325
- x0: typeof Schema.BigIntFromSelf;
2326
- x1: typeof Schema.BigIntFromSelf;
2327
- }>, typeof Schema.BigIntFromSelf>>;
2328
- withdrawalsRoot: Schema.optional<Schema.transform<Schema.Struct<{
2329
- x0: typeof Schema.BigIntFromSelf;
2330
- x1: typeof Schema.BigIntFromSelf;
2331
- x2: typeof Schema.BigIntFromSelf;
2332
- x3: typeof Schema.BigIntFromSelf;
2333
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2334
- totalDifficulty: Schema.optional<Schema.transform<Schema.Struct<{
2335
- x0: typeof Schema.BigIntFromSelf;
2336
- x1: typeof Schema.BigIntFromSelf;
2337
- x2: typeof Schema.BigIntFromSelf;
2338
- x3: typeof Schema.BigIntFromSelf;
2339
- }>, typeof Schema.BigIntFromSelf>>;
2340
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
2341
- x0: typeof Schema.BigIntFromSelf;
2342
- x1: typeof Schema.BigIntFromSelf;
2343
- }>, typeof Schema.BigIntFromSelf>>;
2344
- excessBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
2345
- x0: typeof Schema.BigIntFromSelf;
2346
- x1: typeof Schema.BigIntFromSelf;
2347
- }>, typeof Schema.BigIntFromSelf>>;
2348
- parentBeaconBlockRoot: Schema.optional<Schema.transform<Schema.Struct<{
2349
- x0: typeof Schema.BigIntFromSelf;
2350
- x1: typeof Schema.BigIntFromSelf;
2351
- x2: typeof Schema.BigIntFromSelf;
2352
- x3: typeof Schema.BigIntFromSelf;
2353
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2354
- requestsHash: Schema.optional<Schema.transform<Schema.Struct<{
2355
- x0: typeof Schema.BigIntFromSelf;
2356
- x1: typeof Schema.BigIntFromSelf;
2357
- x2: typeof Schema.BigIntFromSelf;
2358
- x3: typeof Schema.BigIntFromSelf;
2359
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2360
- }>;
2361
- withdrawals: Schema.Array$<Schema.Struct<{
2362
- filterIds: Schema.Array$<typeof Schema.Number>;
2363
- withdrawalIndex: typeof Schema.Number;
2364
- index: typeof Schema.BigIntFromSelf;
2365
- validatorIndex: typeof Schema.Number;
2366
- address: Schema.transform<Schema.Struct<{
2367
- x0: typeof Schema.BigIntFromSelf;
2368
- x1: typeof Schema.BigIntFromSelf;
2369
- x2: typeof Schema.Number;
2370
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2371
- amount: typeof Schema.BigIntFromSelf;
2372
- }>>;
2373
- transactions: Schema.Array$<Schema.Struct<{
2374
- filterIds: Schema.Array$<typeof Schema.Number>;
2375
- transactionIndex: typeof Schema.Number;
2376
- transactionHash: Schema.transform<Schema.Struct<{
2377
- x0: typeof Schema.BigIntFromSelf;
2378
- x1: typeof Schema.BigIntFromSelf;
2379
- x2: typeof Schema.BigIntFromSelf;
2380
- x3: typeof Schema.BigIntFromSelf;
2381
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2382
- nonce: typeof Schema.BigIntFromSelf;
2383
- from: Schema.transform<Schema.Struct<{
2384
- x0: typeof Schema.BigIntFromSelf;
2385
- x1: typeof Schema.BigIntFromSelf;
2386
- x2: typeof Schema.Number;
2387
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2388
- to: Schema.optional<Schema.transform<Schema.Struct<{
2389
- x0: typeof Schema.BigIntFromSelf;
2390
- x1: typeof Schema.BigIntFromSelf;
2391
- x2: typeof Schema.Number;
2392
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2393
- value: Schema.transform<Schema.Struct<{
2394
- x0: typeof Schema.BigIntFromSelf;
2395
- x1: typeof Schema.BigIntFromSelf;
2396
- x2: typeof Schema.BigIntFromSelf;
2397
- x3: typeof Schema.BigIntFromSelf;
2398
- }>, typeof Schema.BigIntFromSelf>;
2399
- gasPrice: Schema.optional<Schema.transform<Schema.Struct<{
2400
- x0: typeof Schema.BigIntFromSelf;
2401
- x1: typeof Schema.BigIntFromSelf;
2402
- }>, typeof Schema.BigIntFromSelf>>;
2403
- gas: Schema.transform<Schema.Struct<{
2404
- x0: typeof Schema.BigIntFromSelf;
2405
- x1: typeof Schema.BigIntFromSelf;
2406
- }>, typeof Schema.BigIntFromSelf>;
2407
- maxFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
2408
- x0: typeof Schema.BigIntFromSelf;
2409
- x1: typeof Schema.BigIntFromSelf;
2410
- }>, typeof Schema.BigIntFromSelf>>;
2411
- maxPriorityFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
2412
- x0: typeof Schema.BigIntFromSelf;
2413
- x1: typeof Schema.BigIntFromSelf;
2414
- }>, typeof Schema.BigIntFromSelf>>;
2415
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2416
- signature: Schema.optional<Schema.Struct<{
2417
- r: Schema.transform<Schema.Struct<{
2418
- x0: typeof Schema.BigIntFromSelf;
2419
- x1: typeof Schema.BigIntFromSelf;
2420
- x2: typeof Schema.BigIntFromSelf;
2421
- x3: typeof Schema.BigIntFromSelf;
2422
- }>, typeof Schema.BigIntFromSelf>;
2423
- s: Schema.transform<Schema.Struct<{
2424
- x0: typeof Schema.BigIntFromSelf;
2425
- x1: typeof Schema.BigIntFromSelf;
2426
- x2: typeof Schema.BigIntFromSelf;
2427
- x3: typeof Schema.BigIntFromSelf;
2428
- }>, typeof Schema.BigIntFromSelf>;
2429
- v: Schema.optional<Schema.transform<Schema.Struct<{
2430
- x0: typeof Schema.BigIntFromSelf;
2431
- x1: typeof Schema.BigIntFromSelf;
2432
- x2: typeof Schema.BigIntFromSelf;
2433
- x3: typeof Schema.BigIntFromSelf;
2434
- }>, typeof Schema.BigIntFromSelf>>;
2435
- YParity: Schema.optional<typeof Schema.Boolean>;
2436
- }>>;
2437
- chainId: Schema.optional<typeof Schema.BigIntFromSelf>;
2438
- accessList: Schema.Array$<Schema.Struct<{
2439
- address: Schema.transform<Schema.Struct<{
2440
- x0: typeof Schema.BigIntFromSelf;
2441
- x1: typeof Schema.BigIntFromSelf;
2442
- x2: typeof Schema.Number;
2443
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2444
- storageKeys: Schema.Array$<Schema.transform<Schema.Struct<{
2445
- x0: typeof Schema.BigIntFromSelf;
2446
- x1: typeof Schema.BigIntFromSelf;
2447
- x2: typeof Schema.BigIntFromSelf;
2448
- x3: typeof Schema.BigIntFromSelf;
2449
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2450
- }>>;
2451
- transactionType: typeof Schema.BigIntFromSelf;
2452
- maxFeePerBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
2453
- x0: typeof Schema.BigIntFromSelf;
2454
- x1: typeof Schema.BigIntFromSelf;
2455
- }>, typeof Schema.BigIntFromSelf>>;
2456
- blobVersionedHashes: Schema.Array$<Schema.transform<Schema.Struct<{
2457
- x0: typeof Schema.BigIntFromSelf;
2458
- x1: typeof Schema.BigIntFromSelf;
2459
- x2: typeof Schema.BigIntFromSelf;
2460
- x3: typeof Schema.BigIntFromSelf;
2461
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2462
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
2463
- }>>;
2464
- receipts: Schema.Array$<Schema.Struct<{
2465
- filterIds: Schema.Array$<typeof Schema.Number>;
2466
- transactionIndex: typeof Schema.Number;
2467
- transactionHash: Schema.transform<Schema.Struct<{
2468
- x0: typeof Schema.BigIntFromSelf;
2469
- x1: typeof Schema.BigIntFromSelf;
2470
- x2: typeof Schema.BigIntFromSelf;
2471
- x3: typeof Schema.BigIntFromSelf;
2472
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2473
- cumulativeGasUsed: Schema.transform<Schema.Struct<{
2474
- x0: typeof Schema.BigIntFromSelf;
2475
- x1: typeof Schema.BigIntFromSelf;
2476
- }>, typeof Schema.BigIntFromSelf>;
2477
- gasUsed: Schema.transform<Schema.Struct<{
2478
- x0: typeof Schema.BigIntFromSelf;
2479
- x1: typeof Schema.BigIntFromSelf;
2480
- }>, typeof Schema.BigIntFromSelf>;
2481
- effectiveGasPrice: Schema.transform<Schema.Struct<{
2482
- x0: typeof Schema.BigIntFromSelf;
2483
- x1: typeof Schema.BigIntFromSelf;
2484
- }>, typeof Schema.BigIntFromSelf>;
2485
- from: Schema.transform<Schema.Struct<{
2486
- x0: typeof Schema.BigIntFromSelf;
2487
- x1: typeof Schema.BigIntFromSelf;
2488
- x2: typeof Schema.Number;
2489
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2490
- to: Schema.optional<Schema.transform<Schema.Struct<{
2491
- x0: typeof Schema.BigIntFromSelf;
2492
- x1: typeof Schema.BigIntFromSelf;
2493
- x2: typeof Schema.Number;
2494
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2495
- contractAddress: Schema.optional<Schema.transform<Schema.Struct<{
2496
- x0: typeof Schema.BigIntFromSelf;
2497
- x1: typeof Schema.BigIntFromSelf;
2498
- x2: typeof Schema.Number;
2499
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2500
- logsBloom: Schema.transform<Schema.Struct<{
2501
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2502
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2503
- transactionType: typeof Schema.BigIntFromSelf;
2504
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
2505
- x0: typeof Schema.BigIntFromSelf;
2506
- x1: typeof Schema.BigIntFromSelf;
2507
- }>, typeof Schema.BigIntFromSelf>>;
2508
- blobGasPrice: Schema.optional<Schema.transform<Schema.Struct<{
2509
- x0: typeof Schema.BigIntFromSelf;
2510
- x1: typeof Schema.BigIntFromSelf;
2511
- }>, typeof Schema.BigIntFromSelf>>;
2512
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
2513
- }>>;
2514
- logs: Schema.Array$<Schema.Struct<{
2515
- filterIds: Schema.Array$<typeof Schema.Number>;
2516
- address: Schema.transform<Schema.Struct<{
2517
- x0: typeof Schema.BigIntFromSelf;
2518
- x1: typeof Schema.BigIntFromSelf;
2519
- x2: typeof Schema.Number;
2520
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2521
- topics: Schema.Array$<Schema.transform<Schema.Struct<{
2522
- x0: typeof Schema.BigIntFromSelf;
2523
- x1: typeof Schema.BigIntFromSelf;
2524
- x2: typeof Schema.BigIntFromSelf;
2525
- x3: typeof Schema.BigIntFromSelf;
2526
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
2527
- data: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2528
- logIndex: typeof Schema.Number;
2529
- logIndexInTransaction: typeof Schema.Number;
2530
- transactionIndex: typeof Schema.Number;
2531
- transactionHash: Schema.transform<Schema.Struct<{
2532
- x0: typeof Schema.BigIntFromSelf;
2533
- x1: typeof Schema.BigIntFromSelf;
2534
- x2: typeof Schema.BigIntFromSelf;
2535
- x3: typeof Schema.BigIntFromSelf;
2536
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2537
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
2538
- }>>;
2539
- traces: Schema.Array$<Schema.Struct<{
2540
- filterIds: Schema.Array$<typeof Schema.Number>;
2541
- transactionIndex: typeof Schema.Number;
2542
- transactionHash: Schema.transform<Schema.Struct<{
2543
- x0: typeof Schema.BigIntFromSelf;
2544
- x1: typeof Schema.BigIntFromSelf;
2545
- x2: typeof Schema.BigIntFromSelf;
2546
- x3: typeof Schema.BigIntFromSelf;
2547
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2548
- traces: Schema.Array$<Schema.Struct<{
2549
- action: Schema.Union<[Schema.Struct<{
2550
- _tag: Schema.PropertySignature<":", "call", "$case", ":", "call", false, never>;
2551
- call: Schema.Struct<{
2552
- fromAddress: Schema.transform<Schema.Struct<{
2553
- x0: typeof Schema.BigIntFromSelf;
2554
- x1: typeof Schema.BigIntFromSelf;
2555
- x2: typeof Schema.Number;
2556
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2557
- type: Schema.transform<Schema.Enums<typeof CallType$1>, Schema.Literal<["unknown", "call", "delegateCall", "callCode", "delegateCall", "staticCall", "authCall"]>>;
2558
- gas: typeof Schema.BigIntFromSelf;
2559
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2560
- toAddress: Schema.transform<Schema.Struct<{
2561
- x0: typeof Schema.BigIntFromSelf;
2562
- x1: typeof Schema.BigIntFromSelf;
2563
- x2: typeof Schema.Number;
2564
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2565
- value: Schema.transform<Schema.Struct<{
2566
- x0: typeof Schema.BigIntFromSelf;
2567
- x1: typeof Schema.BigIntFromSelf;
2568
- x2: typeof Schema.BigIntFromSelf;
2569
- x3: typeof Schema.BigIntFromSelf;
2570
- }>, typeof Schema.BigIntFromSelf>;
2571
- }>;
2572
- }>, Schema.Struct<{
2573
- _tag: Schema.PropertySignature<":", "create", "$case", ":", "create", false, never>;
2574
- create: Schema.Struct<{
2575
- fromAddress: Schema.transform<Schema.Struct<{
2576
- x0: typeof Schema.BigIntFromSelf;
2577
- x1: typeof Schema.BigIntFromSelf;
2578
- x2: typeof Schema.Number;
2579
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2580
- gas: typeof Schema.BigIntFromSelf;
2581
- init: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2582
- value: Schema.transform<Schema.Struct<{
2583
- x0: typeof Schema.BigIntFromSelf;
2584
- x1: typeof Schema.BigIntFromSelf;
2585
- x2: typeof Schema.BigIntFromSelf;
2586
- x3: typeof Schema.BigIntFromSelf;
2587
- }>, typeof Schema.BigIntFromSelf>;
2588
- creationMethod: Schema.transform<Schema.Enums<typeof CreationMethod$1>, Schema.Literal<["unknown", "create", "create2", "eofCreate"]>>;
2589
- }>;
2590
- }>, Schema.Struct<{
2591
- _tag: Schema.PropertySignature<":", "selfDestruct", "$case", ":", "selfDestruct", false, never>;
2592
- selfDestruct: Schema.Struct<{
2593
- address: Schema.transform<Schema.Struct<{
2594
- x0: typeof Schema.BigIntFromSelf;
2595
- x1: typeof Schema.BigIntFromSelf;
2596
- x2: typeof Schema.Number;
2597
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2598
- balance: Schema.transform<Schema.Struct<{
2599
- x0: typeof Schema.BigIntFromSelf;
2600
- x1: typeof Schema.BigIntFromSelf;
2601
- x2: typeof Schema.BigIntFromSelf;
2602
- x3: typeof Schema.BigIntFromSelf;
2603
- }>, typeof Schema.BigIntFromSelf>;
2604
- refundAddress: Schema.transform<Schema.Struct<{
2605
- x0: typeof Schema.BigIntFromSelf;
2606
- x1: typeof Schema.BigIntFromSelf;
2607
- x2: typeof Schema.Number;
2608
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2609
- }>;
2610
- }>, Schema.Struct<{
2611
- _tag: Schema.PropertySignature<":", "reward", "$case", ":", "reward", false, never>;
2612
- reward: Schema.Struct<{
2613
- author: Schema.transform<Schema.Struct<{
2614
- x0: typeof Schema.BigIntFromSelf;
2615
- x1: typeof Schema.BigIntFromSelf;
2616
- x2: typeof Schema.Number;
2617
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2618
- type: Schema.transform<Schema.Enums<typeof RewardType$1>, Schema.Literal<["unknown", "block", "uncle"]>>;
2619
- value: Schema.transform<Schema.Struct<{
2620
- x0: typeof Schema.BigIntFromSelf;
2621
- x1: typeof Schema.BigIntFromSelf;
2622
- x2: typeof Schema.BigIntFromSelf;
2623
- x3: typeof Schema.BigIntFromSelf;
2624
- }>, typeof Schema.BigIntFromSelf>;
2625
- }>;
2626
- }>]>;
2627
- error: Schema.optional<typeof Schema.String>;
2628
- output: Schema.optional<Schema.Union<[Schema.Struct<{
2629
- _tag: Schema.PropertySignature<":", "callOutput", "$case", ":", "callOutput", false, never>;
2630
- callOutput: Schema.Struct<{
2631
- gasUsed: typeof Schema.BigIntFromSelf;
2632
- output: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2633
- }>;
2634
- }>, Schema.Struct<{
2635
- _tag: Schema.PropertySignature<":", "createOutput", "$case", ":", "createOutput", false, never>;
2636
- createOutput: Schema.Struct<{
2637
- address: Schema.transform<Schema.Struct<{
2638
- x0: typeof Schema.BigIntFromSelf;
2639
- x1: typeof Schema.BigIntFromSelf;
2640
- x2: typeof Schema.Number;
2641
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
2642
- code: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
2643
- gasUsed: typeof Schema.BigIntFromSelf;
2644
- }>;
2645
- }>]>>;
2646
- subtraces: typeof Schema.Number;
2647
- traceAddress: Schema.Array$<typeof Schema.Number>;
2648
- }>>;
2649
- }>>;
2650
- }>>>;
1350
+ type TransactionTrace = CodecType<typeof TransactionTrace>;
1351
+ declare const Block: MessageCodec<{
1352
+ header: Codec<{
1353
+ blockNumber: bigint;
1354
+ blockHash: `0x${string}`;
1355
+ parentBlockHash: `0x${string}`;
1356
+ unclesHash: `0x${string}`;
1357
+ miner: `0x${string}`;
1358
+ stateRoot: `0x${string}`;
1359
+ transactionsRoot: `0x${string}`;
1360
+ receiptsRoot: `0x${string}`;
1361
+ logsBloom: `0x${string}`;
1362
+ difficulty: bigint;
1363
+ gasLimit: bigint;
1364
+ gasUsed: bigint;
1365
+ timestamp: Date;
1366
+ extraData: `0x${string}`;
1367
+ mixHash?: `0x${string}` | undefined;
1368
+ nonce?: bigint | undefined;
1369
+ baseFeePerGas?: bigint | undefined;
1370
+ withdrawalsRoot?: `0x${string}` | undefined;
1371
+ totalDifficulty?: bigint | undefined;
1372
+ blobGasUsed?: bigint | undefined;
1373
+ excessBlobGas?: bigint | undefined;
1374
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
1375
+ requestsHash?: `0x${string}` | undefined;
1376
+ }, {
1377
+ blockNumber?: bigint | undefined;
1378
+ blockHash?: B256$1 | undefined;
1379
+ parentBlockHash?: B256$1 | undefined;
1380
+ unclesHash?: B256$1 | undefined;
1381
+ miner?: Address$1 | undefined;
1382
+ stateRoot?: B256$1 | undefined;
1383
+ transactionsRoot?: B256$1 | undefined;
1384
+ receiptsRoot?: B256$1 | undefined;
1385
+ logsBloom?: {
1386
+ value?: Uint8Array | undefined;
1387
+ } | undefined;
1388
+ difficulty?: U256$1 | undefined;
1389
+ gasLimit?: U128$1 | undefined;
1390
+ gasUsed?: U128$1 | undefined;
1391
+ timestamp?: Date | undefined;
1392
+ extraData?: Uint8Array | undefined;
1393
+ mixHash?: B256$1 | undefined;
1394
+ nonce?: bigint | undefined;
1395
+ baseFeePerGas?: U128$1 | undefined;
1396
+ withdrawalsRoot?: B256$1 | undefined;
1397
+ totalDifficulty?: U256$1 | undefined;
1398
+ blobGasUsed?: U128$1 | undefined;
1399
+ excessBlobGas?: U128$1 | undefined;
1400
+ parentBeaconBlockRoot?: B256$1 | undefined;
1401
+ requestsHash?: B256$1 | undefined;
1402
+ } | undefined>;
1403
+ withdrawals: Codec<readonly {
1404
+ filterIds: readonly number[];
1405
+ withdrawalIndex: number;
1406
+ index: bigint;
1407
+ validatorIndex: number;
1408
+ address: `0x${string}`;
1409
+ amount: bigint;
1410
+ }[], readonly {
1411
+ filterIds?: readonly number[] | undefined;
1412
+ withdrawalIndex?: number | undefined;
1413
+ index?: bigint | undefined;
1414
+ validatorIndex?: number | undefined;
1415
+ address?: Address$1 | undefined;
1416
+ amount?: bigint | undefined;
1417
+ }[] | undefined>;
1418
+ transactions: Codec<readonly {
1419
+ filterIds: readonly number[];
1420
+ transactionIndex: number;
1421
+ transactionHash: `0x${string}`;
1422
+ nonce: bigint;
1423
+ from: `0x${string}`;
1424
+ to?: `0x${string}` | undefined;
1425
+ value: bigint;
1426
+ gasPrice?: bigint | undefined;
1427
+ gas: bigint;
1428
+ maxFeePerGas?: bigint | undefined;
1429
+ maxPriorityFeePerGas?: bigint | undefined;
1430
+ input: `0x${string}`;
1431
+ signature?: {
1432
+ r: bigint;
1433
+ s: bigint;
1434
+ v?: bigint | undefined;
1435
+ YParity?: boolean | undefined;
1436
+ } | undefined;
1437
+ chainId?: bigint | undefined;
1438
+ accessList: readonly {
1439
+ address: `0x${string}`;
1440
+ storageKeys: readonly `0x${string}`[];
1441
+ }[];
1442
+ transactionType: bigint;
1443
+ maxFeePerBlobGas?: bigint | undefined;
1444
+ blobVersionedHashes: readonly `0x${string}`[];
1445
+ transactionStatus: "unknown" | "succeeded" | "reverted";
1446
+ }[], readonly {
1447
+ filterIds?: readonly number[] | undefined;
1448
+ transactionIndex?: number | undefined;
1449
+ transactionHash?: B256$1 | undefined;
1450
+ nonce?: bigint | undefined;
1451
+ from?: Address$1 | undefined;
1452
+ to?: Address$1 | undefined;
1453
+ value?: U256$1 | undefined;
1454
+ gasPrice?: U128$1 | undefined;
1455
+ gas?: U128$1 | undefined;
1456
+ maxFeePerGas?: U128$1 | undefined;
1457
+ maxPriorityFeePerGas?: U128$1 | undefined;
1458
+ input?: Uint8Array | undefined;
1459
+ signature?: {
1460
+ r?: U256$1 | undefined;
1461
+ s?: U256$1 | undefined;
1462
+ v?: U256$1 | undefined;
1463
+ YParity?: boolean | undefined;
1464
+ } | undefined;
1465
+ chainId?: bigint | undefined;
1466
+ accessList?: readonly {
1467
+ address?: Address$1 | undefined;
1468
+ storageKeys?: readonly B256$1[] | undefined;
1469
+ }[] | undefined;
1470
+ transactionType?: bigint | undefined;
1471
+ maxFeePerBlobGas?: U128$1 | undefined;
1472
+ blobVersionedHashes?: readonly B256$1[] | undefined;
1473
+ transactionStatus?: TransactionStatus$1 | undefined;
1474
+ }[] | undefined>;
1475
+ receipts: Codec<readonly {
1476
+ filterIds: readonly number[];
1477
+ transactionIndex: number;
1478
+ transactionHash: `0x${string}`;
1479
+ cumulativeGasUsed: bigint;
1480
+ gasUsed: bigint;
1481
+ effectiveGasPrice: bigint;
1482
+ from: `0x${string}`;
1483
+ to?: `0x${string}` | undefined;
1484
+ contractAddress?: `0x${string}` | undefined;
1485
+ logsBloom: `0x${string}`;
1486
+ transactionType: bigint;
1487
+ blobGasUsed?: bigint | undefined;
1488
+ blobGasPrice?: bigint | undefined;
1489
+ transactionStatus: "unknown" | "succeeded" | "reverted";
1490
+ }[], readonly {
1491
+ filterIds?: readonly number[] | undefined;
1492
+ transactionIndex?: number | undefined;
1493
+ transactionHash?: B256$1 | undefined;
1494
+ cumulativeGasUsed?: U128$1 | undefined;
1495
+ gasUsed?: U128$1 | undefined;
1496
+ effectiveGasPrice?: U128$1 | undefined;
1497
+ from?: Address$1 | undefined;
1498
+ to?: Address$1 | undefined;
1499
+ contractAddress?: Address$1 | undefined;
1500
+ logsBloom?: {
1501
+ value?: Uint8Array | undefined;
1502
+ } | undefined;
1503
+ transactionType?: bigint | undefined;
1504
+ blobGasUsed?: U128$1 | undefined;
1505
+ blobGasPrice?: U128$1 | undefined;
1506
+ transactionStatus?: TransactionStatus$1 | undefined;
1507
+ }[] | undefined>;
1508
+ logs: Codec<readonly {
1509
+ filterIds: readonly number[];
1510
+ address: `0x${string}`;
1511
+ topics: readonly `0x${string}`[];
1512
+ data: `0x${string}`;
1513
+ logIndex: number;
1514
+ logIndexInTransaction: number;
1515
+ transactionIndex: number;
1516
+ transactionHash: `0x${string}`;
1517
+ transactionStatus: "unknown" | "succeeded" | "reverted";
1518
+ }[], readonly {
1519
+ filterIds?: readonly number[] | undefined;
1520
+ address?: Address$1 | undefined;
1521
+ topics?: readonly B256$1[] | undefined;
1522
+ data?: Uint8Array | undefined;
1523
+ logIndex?: number | undefined;
1524
+ logIndexInTransaction?: number | undefined;
1525
+ transactionIndex?: number | undefined;
1526
+ transactionHash?: B256$1 | undefined;
1527
+ transactionStatus?: TransactionStatus$1 | undefined;
1528
+ }[] | undefined>;
1529
+ traces: Codec<readonly {
1530
+ filterIds: readonly number[];
1531
+ transactionIndex: number;
1532
+ transactionHash: `0x${string}`;
1533
+ traces: readonly {
1534
+ action: ({
1535
+ _tag: "create";
1536
+ } & {
1537
+ create: {
1538
+ fromAddress: `0x${string}`;
1539
+ gas: bigint;
1540
+ init: `0x${string}`;
1541
+ value: bigint;
1542
+ creationMethod: "unknown" | "create" | "create2" | "eofCreate";
1543
+ };
1544
+ }) | ({
1545
+ _tag: "call";
1546
+ } & {
1547
+ call: {
1548
+ fromAddress: `0x${string}`;
1549
+ type: "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall";
1550
+ gas: bigint;
1551
+ input: `0x${string}`;
1552
+ toAddress: `0x${string}`;
1553
+ value: bigint;
1554
+ };
1555
+ }) | ({
1556
+ _tag: "selfDestruct";
1557
+ } & {
1558
+ selfDestruct: {
1559
+ address: `0x${string}`;
1560
+ balance: bigint;
1561
+ refundAddress: `0x${string}`;
1562
+ };
1563
+ }) | ({
1564
+ _tag: "reward";
1565
+ } & {
1566
+ reward: {
1567
+ author: `0x${string}`;
1568
+ type: "unknown" | "block" | "uncle";
1569
+ value: bigint;
1570
+ };
1571
+ });
1572
+ error?: string | undefined;
1573
+ output?: (({
1574
+ _tag: "callOutput";
1575
+ } & {
1576
+ callOutput: {
1577
+ gasUsed: bigint;
1578
+ output: `0x${string}`;
1579
+ };
1580
+ }) | ({
1581
+ _tag: "createOutput";
1582
+ } & {
1583
+ createOutput: {
1584
+ address: `0x${string}`;
1585
+ code: `0x${string}`;
1586
+ gasUsed: bigint;
1587
+ };
1588
+ })) | undefined;
1589
+ subtraces: number;
1590
+ traceAddress: readonly number[];
1591
+ }[];
1592
+ }[], readonly {
1593
+ filterIds?: readonly number[] | undefined;
1594
+ transactionIndex?: number | undefined;
1595
+ transactionHash?: B256$1 | undefined;
1596
+ traces?: readonly {
1597
+ action?: (({
1598
+ $case: "create";
1599
+ } & {
1600
+ create: {
1601
+ fromAddress?: Address$1 | undefined;
1602
+ gas?: bigint | undefined;
1603
+ init?: Uint8Array | undefined;
1604
+ value?: U256$1 | undefined;
1605
+ creationMethod?: CreationMethod$1 | undefined;
1606
+ };
1607
+ }) | ({
1608
+ $case: "call";
1609
+ } & {
1610
+ call: {
1611
+ fromAddress?: Address$1 | undefined;
1612
+ type?: CallType$1 | undefined;
1613
+ gas?: bigint | undefined;
1614
+ input?: Uint8Array | undefined;
1615
+ toAddress?: Address$1 | undefined;
1616
+ value?: U256$1 | undefined;
1617
+ };
1618
+ }) | ({
1619
+ $case: "selfDestruct";
1620
+ } & {
1621
+ selfDestruct: {
1622
+ address?: Address$1 | undefined;
1623
+ balance?: U256$1 | undefined;
1624
+ refundAddress?: Address$1 | undefined;
1625
+ };
1626
+ }) | ({
1627
+ $case: "reward";
1628
+ } & {
1629
+ reward: {
1630
+ author?: Address$1 | undefined;
1631
+ type?: RewardType$1 | undefined;
1632
+ value?: U256$1 | undefined;
1633
+ };
1634
+ })) | undefined;
1635
+ error?: string | undefined;
1636
+ output?: (({
1637
+ $case: "callOutput";
1638
+ } & {
1639
+ callOutput: {
1640
+ gasUsed?: bigint | undefined;
1641
+ output?: Uint8Array | undefined;
1642
+ };
1643
+ }) | ({
1644
+ $case: "createOutput";
1645
+ } & {
1646
+ createOutput: {
1647
+ address?: Address$1 | undefined;
1648
+ code?: Uint8Array | undefined;
1649
+ gasUsed?: bigint | undefined;
1650
+ };
1651
+ })) | undefined;
1652
+ subtraces?: number | undefined;
1653
+ traceAddress?: readonly number[] | undefined;
1654
+ }[] | undefined;
1655
+ }[] | undefined>;
1656
+ }>;
1657
+ type Block = CodecType<typeof Block>;
1658
+ declare const BlockFromBytes: Codec<Block, Uint8Array>;
2651
1659
 
2652
- declare const EvmStream: StreamConfig<{
2653
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
2654
- readonly withdrawals?: readonly {
2655
- readonly id?: number | undefined;
2656
- readonly validatorIndex?: number | undefined;
2657
- readonly address?: `0x${string}` | undefined;
1660
+ declare const EvmStream: StreamConfig<Readonly<{
1661
+ header?: "always" | "on_data" | "on_data_or_on_new_block" | "unknown" | undefined;
1662
+ withdrawals?: readonly {
1663
+ id?: number | undefined;
1664
+ validatorIndex?: number | undefined;
1665
+ address?: `0x${string}` | undefined;
2658
1666
  }[] | undefined;
2659
- readonly transactions?: readonly {
2660
- readonly id?: number | undefined;
2661
- readonly from?: `0x${string}` | undefined;
2662
- readonly to?: `0x${string}` | undefined;
2663
- readonly create?: boolean | undefined;
2664
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
2665
- readonly includeReceipt?: boolean | undefined;
2666
- readonly includeLogs?: boolean | undefined;
2667
- readonly includeTransactionTrace?: boolean | undefined;
1667
+ transactions?: readonly {
1668
+ id?: number | undefined;
1669
+ from?: `0x${string}` | undefined;
1670
+ to?: `0x${string}` | undefined;
1671
+ create?: boolean | undefined;
1672
+ transactionStatus?: "unknown" | "succeeded" | "reverted" | "all" | undefined;
1673
+ includeReceipt?: boolean | undefined;
1674
+ includeLogs?: boolean | undefined;
1675
+ includeTransactionTrace?: boolean | undefined;
2668
1676
  }[] | undefined;
2669
- readonly logs?: readonly {
2670
- readonly id?: number | undefined;
2671
- readonly address?: `0x${string}` | undefined;
2672
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
2673
- readonly includeReceipt?: boolean | undefined;
2674
- readonly includeTransactionTrace?: boolean | undefined;
2675
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
2676
- readonly strict?: boolean | undefined;
2677
- readonly includeTransaction?: boolean | undefined;
1677
+ logs?: readonly {
1678
+ id?: number | undefined;
1679
+ address?: `0x${string}` | undefined;
1680
+ topics?: readonly (`0x${string}` | null)[] | undefined;
1681
+ strict?: boolean | undefined;
1682
+ transactionStatus?: "unknown" | "succeeded" | "reverted" | "all" | undefined;
1683
+ includeTransaction?: boolean | undefined;
1684
+ includeReceipt?: boolean | undefined;
1685
+ includeTransactionTrace?: boolean | undefined;
2678
1686
  }[] | undefined;
2679
- }, {
2680
- readonly header: {
2681
- readonly blockNumber: bigint;
2682
- readonly blockHash: `0x${string}`;
2683
- readonly parentBlockHash: `0x${string}`;
2684
- readonly unclesHash: `0x${string}`;
2685
- readonly miner: `0x${string}`;
2686
- readonly stateRoot: `0x${string}`;
2687
- readonly transactionsRoot: `0x${string}`;
2688
- readonly receiptsRoot: `0x${string}`;
2689
- readonly logsBloom: `0x${string}`;
2690
- readonly difficulty: bigint;
2691
- readonly gasLimit: bigint;
2692
- readonly gasUsed: bigint;
2693
- readonly timestamp: Date;
2694
- readonly extraData?: `0x${string}` | undefined;
2695
- readonly mixHash?: `0x${string}` | undefined;
2696
- readonly nonce?: bigint | undefined;
2697
- readonly baseFeePerGas?: bigint | undefined;
2698
- readonly withdrawalsRoot?: `0x${string}` | undefined;
2699
- readonly totalDifficulty?: bigint | undefined;
2700
- readonly blobGasUsed?: bigint | undefined;
2701
- readonly excessBlobGas?: bigint | undefined;
2702
- readonly parentBeaconBlockRoot?: `0x${string}` | undefined;
2703
- readonly requestsHash?: `0x${string}` | undefined;
1687
+ }>, {
1688
+ header: {
1689
+ blockNumber: bigint;
1690
+ blockHash: `0x${string}`;
1691
+ parentBlockHash: `0x${string}`;
1692
+ unclesHash: `0x${string}`;
1693
+ miner: `0x${string}`;
1694
+ stateRoot: `0x${string}`;
1695
+ transactionsRoot: `0x${string}`;
1696
+ receiptsRoot: `0x${string}`;
1697
+ logsBloom: `0x${string}`;
1698
+ difficulty: bigint;
1699
+ gasLimit: bigint;
1700
+ gasUsed: bigint;
1701
+ timestamp: Date;
1702
+ extraData: `0x${string}`;
1703
+ mixHash?: `0x${string}` | undefined;
1704
+ nonce?: bigint | undefined;
1705
+ baseFeePerGas?: bigint | undefined;
1706
+ withdrawalsRoot?: `0x${string}` | undefined;
1707
+ totalDifficulty?: bigint | undefined;
1708
+ blobGasUsed?: bigint | undefined;
1709
+ excessBlobGas?: bigint | undefined;
1710
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
1711
+ requestsHash?: `0x${string}` | undefined;
2704
1712
  };
2705
- readonly withdrawals: readonly {
2706
- readonly validatorIndex: number;
2707
- readonly address: `0x${string}`;
2708
- readonly filterIds: readonly number[];
2709
- readonly withdrawalIndex: number;
2710
- readonly index: bigint;
2711
- readonly amount: bigint;
1713
+ withdrawals: readonly {
1714
+ filterIds: readonly number[];
1715
+ withdrawalIndex: number;
1716
+ index: bigint;
1717
+ validatorIndex: number;
1718
+ address: `0x${string}`;
1719
+ amount: bigint;
2712
1720
  }[];
2713
- readonly transactions: readonly {
2714
- readonly value: bigint;
2715
- readonly from: `0x${string}`;
2716
- readonly to?: `0x${string}` | undefined;
2717
- readonly transactionStatus: "succeeded" | "reverted" | "unknown";
2718
- readonly nonce: bigint;
2719
- readonly filterIds: readonly number[];
2720
- readonly transactionIndex: number;
2721
- readonly transactionHash: `0x${string}`;
2722
- readonly gasPrice?: bigint | undefined;
2723
- readonly gas: bigint;
2724
- readonly maxFeePerGas?: bigint | undefined;
2725
- readonly maxPriorityFeePerGas?: bigint | undefined;
2726
- readonly input?: `0x${string}` | undefined;
2727
- readonly signature?: {
2728
- readonly r: bigint;
2729
- readonly s: bigint;
2730
- readonly v?: bigint | undefined;
2731
- readonly YParity?: boolean | undefined;
1721
+ transactions: readonly {
1722
+ filterIds: readonly number[];
1723
+ transactionIndex: number;
1724
+ transactionHash: `0x${string}`;
1725
+ nonce: bigint;
1726
+ from: `0x${string}`;
1727
+ to?: `0x${string}` | undefined;
1728
+ value: bigint;
1729
+ gasPrice?: bigint | undefined;
1730
+ gas: bigint;
1731
+ maxFeePerGas?: bigint | undefined;
1732
+ maxPriorityFeePerGas?: bigint | undefined;
1733
+ input: `0x${string}`;
1734
+ signature?: {
1735
+ r: bigint;
1736
+ s: bigint;
1737
+ v?: bigint | undefined;
1738
+ YParity?: boolean | undefined;
2732
1739
  } | undefined;
2733
- readonly chainId?: bigint | undefined;
2734
- readonly accessList: readonly {
2735
- readonly address: `0x${string}`;
2736
- readonly storageKeys: readonly `0x${string}`[];
1740
+ chainId?: bigint | undefined;
1741
+ accessList: readonly {
1742
+ address: `0x${string}`;
1743
+ storageKeys: readonly `0x${string}`[];
2737
1744
  }[];
2738
- readonly transactionType: bigint;
2739
- readonly maxFeePerBlobGas?: bigint | undefined;
2740
- readonly blobVersionedHashes: readonly `0x${string}`[];
1745
+ transactionType: bigint;
1746
+ maxFeePerBlobGas?: bigint | undefined;
1747
+ blobVersionedHashes: readonly `0x${string}`[];
1748
+ transactionStatus: "unknown" | "succeeded" | "reverted";
2741
1749
  }[];
2742
- readonly logs: readonly {
2743
- readonly address: `0x${string}`;
2744
- readonly transactionStatus: "succeeded" | "reverted" | "unknown";
2745
- readonly topics: readonly `0x${string}`[];
2746
- readonly filterIds: readonly number[];
2747
- readonly transactionIndex: number;
2748
- readonly transactionHash: `0x${string}`;
2749
- readonly data?: `0x${string}` | undefined;
2750
- readonly logIndex: number;
2751
- readonly logIndexInTransaction: number;
1750
+ receipts: readonly {
1751
+ filterIds: readonly number[];
1752
+ transactionIndex: number;
1753
+ transactionHash: `0x${string}`;
1754
+ cumulativeGasUsed: bigint;
1755
+ gasUsed: bigint;
1756
+ effectiveGasPrice: bigint;
1757
+ from: `0x${string}`;
1758
+ to?: `0x${string}` | undefined;
1759
+ contractAddress?: `0x${string}` | undefined;
1760
+ logsBloom: `0x${string}`;
1761
+ transactionType: bigint;
1762
+ blobGasUsed?: bigint | undefined;
1763
+ blobGasPrice?: bigint | undefined;
1764
+ transactionStatus: "unknown" | "succeeded" | "reverted";
2752
1765
  }[];
2753
- readonly receipts: readonly {
2754
- readonly from: `0x${string}`;
2755
- readonly to?: `0x${string}` | undefined;
2756
- readonly transactionStatus: "succeeded" | "reverted" | "unknown";
2757
- readonly logsBloom: `0x${string}`;
2758
- readonly gasUsed: bigint;
2759
- readonly blobGasUsed?: bigint | undefined;
2760
- readonly filterIds: readonly number[];
2761
- readonly transactionIndex: number;
2762
- readonly transactionHash: `0x${string}`;
2763
- readonly transactionType: bigint;
2764
- readonly cumulativeGasUsed: bigint;
2765
- readonly effectiveGasPrice: bigint;
2766
- readonly contractAddress?: `0x${string}` | undefined;
2767
- readonly blobGasPrice?: bigint | undefined;
1766
+ logs: readonly {
1767
+ filterIds: readonly number[];
1768
+ address: `0x${string}`;
1769
+ topics: readonly `0x${string}`[];
1770
+ data: `0x${string}`;
1771
+ logIndex: number;
1772
+ logIndexInTransaction: number;
1773
+ transactionIndex: number;
1774
+ transactionHash: `0x${string}`;
1775
+ transactionStatus: "unknown" | "succeeded" | "reverted";
2768
1776
  }[];
2769
- readonly traces: readonly {
2770
- readonly filterIds: readonly number[];
2771
- readonly transactionIndex: number;
2772
- readonly transactionHash: `0x${string}`;
2773
- readonly traces: readonly {
2774
- readonly action: {
2775
- readonly _tag: "call";
2776
- readonly call: {
2777
- readonly value: bigint;
2778
- readonly gas: bigint;
2779
- readonly input?: `0x${string}` | undefined;
2780
- readonly fromAddress: `0x${string}`;
2781
- readonly type: "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall";
2782
- readonly toAddress: `0x${string}`;
1777
+ traces: readonly {
1778
+ filterIds: readonly number[];
1779
+ transactionIndex: number;
1780
+ transactionHash: `0x${string}`;
1781
+ traces: readonly {
1782
+ action: ({
1783
+ _tag: "create";
1784
+ } & {
1785
+ create: {
1786
+ fromAddress: `0x${string}`;
1787
+ gas: bigint;
1788
+ init: `0x${string}`;
1789
+ value: bigint;
1790
+ creationMethod: "unknown" | "create" | "create2" | "eofCreate";
2783
1791
  };
2784
- } | {
2785
- readonly create: {
2786
- readonly value: bigint;
2787
- readonly gas: bigint;
2788
- readonly fromAddress: `0x${string}`;
2789
- readonly init?: `0x${string}` | undefined;
2790
- readonly creationMethod: "create" | "unknown" | "create2" | "eofCreate";
1792
+ }) | ({
1793
+ _tag: "call";
1794
+ } & {
1795
+ call: {
1796
+ fromAddress: `0x${string}`;
1797
+ type: "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall";
1798
+ gas: bigint;
1799
+ input: `0x${string}`;
1800
+ toAddress: `0x${string}`;
1801
+ value: bigint;
2791
1802
  };
2792
- readonly _tag: "create";
2793
- } | {
2794
- readonly _tag: "selfDestruct";
2795
- readonly selfDestruct: {
2796
- readonly address: `0x${string}`;
2797
- readonly balance: bigint;
2798
- readonly refundAddress: `0x${string}`;
1803
+ }) | ({
1804
+ _tag: "selfDestruct";
1805
+ } & {
1806
+ selfDestruct: {
1807
+ address: `0x${string}`;
1808
+ balance: bigint;
1809
+ refundAddress: `0x${string}`;
2799
1810
  };
2800
- } | {
2801
- readonly _tag: "reward";
2802
- readonly reward: {
2803
- readonly value: bigint;
2804
- readonly type: "unknown" | "block" | "uncle";
2805
- readonly author: `0x${string}`;
1811
+ }) | ({
1812
+ _tag: "reward";
1813
+ } & {
1814
+ reward: {
1815
+ author: `0x${string}`;
1816
+ type: "unknown" | "block" | "uncle";
1817
+ value: bigint;
2806
1818
  };
2807
- };
2808
- readonly error?: string | undefined;
2809
- readonly output?: {
2810
- readonly _tag: "callOutput";
2811
- readonly callOutput: {
2812
- readonly gasUsed: bigint;
2813
- readonly output?: `0x${string}` | undefined;
1819
+ });
1820
+ error?: string | undefined;
1821
+ output?: (({
1822
+ _tag: "callOutput";
1823
+ } & {
1824
+ callOutput: {
1825
+ gasUsed: bigint;
1826
+ output: `0x${string}`;
2814
1827
  };
2815
- } | {
2816
- readonly _tag: "createOutput";
2817
- readonly createOutput: {
2818
- readonly address: `0x${string}`;
2819
- readonly gasUsed: bigint;
2820
- readonly code?: `0x${string}` | undefined;
1828
+ }) | ({
1829
+ _tag: "createOutput";
1830
+ } & {
1831
+ createOutput: {
1832
+ address: `0x${string}`;
1833
+ code: `0x${string}`;
1834
+ gasUsed: bigint;
2821
1835
  };
2822
- } | undefined;
2823
- readonly subtraces: number;
2824
- readonly traceAddress: readonly number[];
1836
+ })) | undefined;
1837
+ subtraces: number;
1838
+ traceAddress: readonly number[];
2825
1839
  }[];
2826
1840
  }[];
2827
1841
  }>;
2828
1842
 
2829
- export { AccessListItem, Address, B256, B256Proto, Block, BlockFromBytes, BlockHeader, Bloom, CallAction, CallOutput, CallType, CreateAction, CreateOutput, CreationMethod, EvmStream, Filter, FilterFromBytes, HeaderFilter, Log, LogFilter, RewardAction, RewardType, SelfDestructAction, Signature, Topic, Trace, Transaction, TransactionFilter, TransactionReceipt, TransactionStatus, TransactionStatusFilter, TransactionTrace, U128, U256, Withdrawal, WithdrawalFilter, b256FromProto, b256ToProto, filterFromBytes, filterFromProto, filterToBytes, filterToProto, mergeFilter, index as proto, u128FromProto, u128ToProto, u256FromProto, u256ToProto };
1843
+ export { AccessListItem, Address, B256, Block, BlockFromBytes, BlockHeader, Bloom, CallAction, CallOutput, CallType, CreateAction, CreateOutput, CreationMethod, EvmStream, Filter, FilterFromBytes, HeaderFilter, Log, LogFilter, RewardAction, RewardType, SelfDestructAction, Signature, Topic, Trace, Transaction, TransactionFilter, TransactionReceipt, TransactionStatus, TransactionStatusFilter, TransactionTrace, U128, U256, Withdrawal, WithdrawalFilter, mergeFilter, index as proto };