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