@apibara/evm 2.1.0-beta.9 → 2.1.1-beta.0

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.
package/dist/index.d.mts CHANGED
@@ -1,7 +1,6 @@
1
1
  import { StreamConfig } from '@apibara/protocol';
2
2
  import _m0 from 'protobufjs/minimal.js';
3
- import * as _effect_schema_AST from '@effect/schema/AST';
4
- import { Schema } from '@effect/schema';
3
+ import { Codec, CodecType, MessageCodec } from '@apibara/protocol/codec';
5
4
 
6
5
  declare const protobufPackage$2 = "evm.v2";
7
6
  /**
@@ -89,7 +88,8 @@ type DeepPartial$2<T> = T extends Builtin$2 ? T : T extends globalThis.Array<inf
89
88
  } : Partial<T>;
90
89
 
91
90
  declare namespace common {
92
- export { Address$1 as Address, B256$1 as B256, Bloom$1 as Bloom, type DeepPartial$2 as DeepPartial, U128$1 as U128, U256$1 as U256, protobufPackage$2 as protobufPackage };
91
+ export { Address$1 as Address, B256$1 as B256, Bloom$1 as Bloom, U128$1 as U128, U256$1 as U256, protobufPackage$2 as protobufPackage };
92
+ export type { DeepPartial$2 as DeepPartial };
93
93
  }
94
94
 
95
95
  declare const protobufPackage$1 = "evm.v2";
@@ -102,6 +102,34 @@ declare enum TransactionStatus$1 {
102
102
  }
103
103
  declare function transactionStatusFromJSON(object: any): TransactionStatus$1;
104
104
  declare function transactionStatusToJSON(object: TransactionStatus$1): string;
105
+ declare enum CallType$1 {
106
+ UNSPECIFIED = 0,
107
+ CALL = 1,
108
+ CALL_CODE = 2,
109
+ DELEGATE_CALL = 3,
110
+ STATIC_CALL = 4,
111
+ AUTH_CALL = 5,
112
+ UNRECOGNIZED = -1
113
+ }
114
+ declare function callTypeFromJSON(object: any): CallType$1;
115
+ declare function callTypeToJSON(object: CallType$1): string;
116
+ declare enum CreationMethod$1 {
117
+ UNSPECIFIED = 0,
118
+ CREATE = 1,
119
+ CREATE2 = 2,
120
+ EOF_CREATE = 3,
121
+ UNRECOGNIZED = -1
122
+ }
123
+ declare function creationMethodFromJSON(object: any): CreationMethod$1;
124
+ declare function creationMethodToJSON(object: CreationMethod$1): string;
125
+ declare enum RewardType$1 {
126
+ UNSPECIFIED = 0,
127
+ BLOCK = 1,
128
+ UNCLE = 2,
129
+ UNRECOGNIZED = -1
130
+ }
131
+ declare function rewardTypeFromJSON(object: any): RewardType$1;
132
+ declare function rewardTypeToJSON(object: RewardType$1): string;
105
133
  /** Requested data, grouped by block. */
106
134
  interface Block$1 {
107
135
  /** The header. */
@@ -114,6 +142,8 @@ interface Block$1 {
114
142
  readonly receipts?: readonly TransactionReceipt$1[] | undefined;
115
143
  /** List of logs. */
116
144
  readonly logs?: readonly Log$1[] | undefined;
145
+ /** List of transaction traces. */
146
+ readonly traces?: readonly TransactionTrace$1[] | undefined;
117
147
  }
118
148
  declare const Block$1: {
119
149
  encode(message: Block$1, writer?: _m0.Writer): _m0.Writer;
@@ -169,6 +199,11 @@ interface BlockHeader$1 {
169
199
  readonly excessBlobGas?: U128$1 | undefined;
170
200
  /** Parent beacon block root. */
171
201
  readonly parentBeaconBlockRoot?: B256$1 | undefined;
202
+ /**
203
+ * The Keccak 256-bit hash of the an RLP encoded list with each EIP-7685
204
+ * request in the block body.
205
+ */
206
+ readonly requestsHash?: B256$1 | undefined;
172
207
  }
173
208
  declare const BlockHeader$1: {
174
209
  encode(message: BlockHeader$1, writer?: _m0.Writer): _m0.Writer;
@@ -343,6 +378,163 @@ declare const AccessListItem$1: {
343
378
  create(base?: DeepPartial$1<AccessListItem$1>): AccessListItem$1;
344
379
  fromPartial(object: DeepPartial$1<AccessListItem$1>): AccessListItem$1;
345
380
  };
381
+ interface TransactionTrace$1 {
382
+ readonly filterIds?: readonly number[] | undefined;
383
+ /** Index of the transaction in the block. */
384
+ readonly transactionIndex?: number | undefined;
385
+ /** Transaction hash. */
386
+ readonly transactionHash?: B256$1 | undefined;
387
+ /** Traces. */
388
+ readonly traces?: readonly Trace$1[] | undefined;
389
+ }
390
+ declare const TransactionTrace$1: {
391
+ encode(message: TransactionTrace$1, writer?: _m0.Writer): _m0.Writer;
392
+ decode(input: _m0.Reader | Uint8Array, length?: number): TransactionTrace$1;
393
+ fromJSON(object: any): TransactionTrace$1;
394
+ toJSON(message: TransactionTrace$1): unknown;
395
+ create(base?: DeepPartial$1<TransactionTrace$1>): TransactionTrace$1;
396
+ fromPartial(object: DeepPartial$1<TransactionTrace$1>): TransactionTrace$1;
397
+ };
398
+ interface Trace$1 {
399
+ readonly action?: {
400
+ readonly $case: "call";
401
+ readonly call: CallAction$1;
402
+ } | {
403
+ readonly $case: "create";
404
+ readonly create: CreateAction$1;
405
+ } | {
406
+ readonly $case: "selfDestruct";
407
+ readonly selfDestruct: SelfDestructAction$1;
408
+ } | {
409
+ readonly $case: "reward";
410
+ readonly reward: RewardAction$1;
411
+ } | undefined;
412
+ /** Error message if the transaction failed. */
413
+ readonly error?: string | undefined;
414
+ readonly output?: {
415
+ readonly $case: "callOutput";
416
+ readonly callOutput: CallOutput$1;
417
+ } | {
418
+ readonly $case: "createOutput";
419
+ readonly createOutput: CreateOutput$1;
420
+ } | undefined;
421
+ /** Number of sub traces. */
422
+ readonly subtraces?: number | undefined;
423
+ /** The identifier of this trace in the trace tree. */
424
+ readonly traceAddress?: readonly number[] | undefined;
425
+ }
426
+ declare const Trace$1: {
427
+ encode(message: Trace$1, writer?: _m0.Writer): _m0.Writer;
428
+ decode(input: _m0.Reader | Uint8Array, length?: number): Trace$1;
429
+ fromJSON(object: any): Trace$1;
430
+ toJSON(message: Trace$1): unknown;
431
+ create(base?: DeepPartial$1<Trace$1>): Trace$1;
432
+ fromPartial(object: DeepPartial$1<Trace$1>): Trace$1;
433
+ };
434
+ interface CallAction$1 {
435
+ /** Address of the sending account. */
436
+ readonly fromAddress?: Address$1 | undefined;
437
+ /** Call type. */
438
+ readonly type?: CallType$1 | undefined;
439
+ /** The gas available to execute the call. */
440
+ readonly gas?: bigint | undefined;
441
+ /** Input data provided by the call. */
442
+ readonly input?: Uint8Array | undefined;
443
+ /** Target of the destination address. */
444
+ readonly toAddress?: Address$1 | undefined;
445
+ /** Value transferred to the destination account. */
446
+ readonly value?: U256$1 | undefined;
447
+ }
448
+ declare const CallAction$1: {
449
+ encode(message: CallAction$1, writer?: _m0.Writer): _m0.Writer;
450
+ decode(input: _m0.Reader | Uint8Array, length?: number): CallAction$1;
451
+ fromJSON(object: any): CallAction$1;
452
+ toJSON(message: CallAction$1): unknown;
453
+ create(base?: DeepPartial$1<CallAction$1>): CallAction$1;
454
+ fromPartial(object: DeepPartial$1<CallAction$1>): CallAction$1;
455
+ };
456
+ interface CreateAction$1 {
457
+ /** Address of the sending account. */
458
+ readonly fromAddress?: Address$1 | undefined;
459
+ /** The gas available to execute the call. */
460
+ readonly gas?: bigint | undefined;
461
+ /** Input data provided by the call. */
462
+ readonly init?: Uint8Array | undefined;
463
+ /** Value transferred to the ne account. */
464
+ readonly value?: U256$1 | undefined;
465
+ /** Contract creation method. */
466
+ readonly creationMethod?: CreationMethod$1 | undefined;
467
+ }
468
+ declare const CreateAction$1: {
469
+ encode(message: CreateAction$1, writer?: _m0.Writer): _m0.Writer;
470
+ decode(input: _m0.Reader | Uint8Array, length?: number): CreateAction$1;
471
+ fromJSON(object: any): CreateAction$1;
472
+ toJSON(message: CreateAction$1): unknown;
473
+ create(base?: DeepPartial$1<CreateAction$1>): CreateAction$1;
474
+ fromPartial(object: DeepPartial$1<CreateAction$1>): CreateAction$1;
475
+ };
476
+ interface SelfDestructAction$1 {
477
+ /** The destroyed address. */
478
+ readonly address?: Address$1 | undefined;
479
+ /** Balance of the destroyed account before destruct. */
480
+ readonly balance?: U256$1 | undefined;
481
+ /** The heir address. */
482
+ readonly refundAddress?: Address$1 | undefined;
483
+ }
484
+ declare const SelfDestructAction$1: {
485
+ encode(message: SelfDestructAction$1, writer?: _m0.Writer): _m0.Writer;
486
+ decode(input: _m0.Reader | Uint8Array, length?: number): SelfDestructAction$1;
487
+ fromJSON(object: any): SelfDestructAction$1;
488
+ toJSON(message: SelfDestructAction$1): unknown;
489
+ create(base?: DeepPartial$1<SelfDestructAction$1>): SelfDestructAction$1;
490
+ fromPartial(object: DeepPartial$1<SelfDestructAction$1>): SelfDestructAction$1;
491
+ };
492
+ interface RewardAction$1 {
493
+ /** The author's address. */
494
+ readonly author?: Address$1 | undefined;
495
+ /** Reward type. */
496
+ readonly type?: RewardType$1 | undefined;
497
+ /** The reward's value. */
498
+ readonly value?: U256$1 | undefined;
499
+ }
500
+ declare const RewardAction$1: {
501
+ encode(message: RewardAction$1, writer?: _m0.Writer): _m0.Writer;
502
+ decode(input: _m0.Reader | Uint8Array, length?: number): RewardAction$1;
503
+ fromJSON(object: any): RewardAction$1;
504
+ toJSON(message: RewardAction$1): unknown;
505
+ create(base?: DeepPartial$1<RewardAction$1>): RewardAction$1;
506
+ fromPartial(object: DeepPartial$1<RewardAction$1>): RewardAction$1;
507
+ };
508
+ interface CallOutput$1 {
509
+ /** Gas used. */
510
+ readonly gasUsed?: bigint | undefined;
511
+ /** Output data. */
512
+ readonly output?: Uint8Array | undefined;
513
+ }
514
+ declare const CallOutput$1: {
515
+ encode(message: CallOutput$1, writer?: _m0.Writer): _m0.Writer;
516
+ decode(input: _m0.Reader | Uint8Array, length?: number): CallOutput$1;
517
+ fromJSON(object: any): CallOutput$1;
518
+ toJSON(message: CallOutput$1): unknown;
519
+ create(base?: DeepPartial$1<CallOutput$1>): CallOutput$1;
520
+ fromPartial(object: DeepPartial$1<CallOutput$1>): CallOutput$1;
521
+ };
522
+ interface CreateOutput$1 {
523
+ /** Contract address. */
524
+ readonly address?: Address$1 | undefined;
525
+ /** Code */
526
+ readonly code?: Uint8Array | undefined;
527
+ /** Gas used. */
528
+ readonly gasUsed?: bigint | undefined;
529
+ }
530
+ declare const CreateOutput$1: {
531
+ encode(message: CreateOutput$1, writer?: _m0.Writer): _m0.Writer;
532
+ decode(input: _m0.Reader | Uint8Array, length?: number): CreateOutput$1;
533
+ fromJSON(object: any): CreateOutput$1;
534
+ toJSON(message: CreateOutput$1): unknown;
535
+ create(base?: DeepPartial$1<CreateOutput$1>): CreateOutput$1;
536
+ fromPartial(object: DeepPartial$1<CreateOutput$1>): CreateOutput$1;
537
+ };
346
538
  type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
347
539
  type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {
348
540
  readonly $case: string;
@@ -354,10 +546,17 @@ type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<inf
354
546
  [K in keyof T]?: DeepPartial$1<T[K]>;
355
547
  } : Partial<T>;
356
548
 
549
+ declare const data_callTypeFromJSON: typeof callTypeFromJSON;
550
+ declare const data_callTypeToJSON: typeof callTypeToJSON;
551
+ declare const data_creationMethodFromJSON: typeof creationMethodFromJSON;
552
+ declare const data_creationMethodToJSON: typeof creationMethodToJSON;
553
+ declare const data_rewardTypeFromJSON: typeof rewardTypeFromJSON;
554
+ declare const data_rewardTypeToJSON: typeof rewardTypeToJSON;
357
555
  declare const data_transactionStatusFromJSON: typeof transactionStatusFromJSON;
358
556
  declare const data_transactionStatusToJSON: typeof transactionStatusToJSON;
359
557
  declare namespace data {
360
- export { AccessListItem$1 as AccessListItem, Block$1 as Block, BlockHeader$1 as BlockHeader, type DeepPartial$1 as DeepPartial, Log$1 as Log, Signature$1 as Signature, Transaction$1 as Transaction, TransactionReceipt$1 as TransactionReceipt, TransactionStatus$1 as TransactionStatus, Withdrawal$1 as Withdrawal, protobufPackage$1 as protobufPackage, data_transactionStatusFromJSON as transactionStatusFromJSON, data_transactionStatusToJSON as transactionStatusToJSON };
558
+ export { AccessListItem$1 as AccessListItem, Block$1 as Block, BlockHeader$1 as BlockHeader, CallAction$1 as CallAction, CallOutput$1 as CallOutput, CallType$1 as CallType, CreateAction$1 as CreateAction, CreateOutput$1 as CreateOutput, CreationMethod$1 as CreationMethod, Log$1 as Log, RewardAction$1 as RewardAction, RewardType$1 as RewardType, SelfDestructAction$1 as SelfDestructAction, Signature$1 as Signature, Trace$1 as Trace, Transaction$1 as Transaction, TransactionReceipt$1 as TransactionReceipt, TransactionStatus$1 as TransactionStatus, TransactionTrace$1 as TransactionTrace, Withdrawal$1 as Withdrawal, data_callTypeFromJSON as callTypeFromJSON, data_callTypeToJSON as callTypeToJSON, data_creationMethodFromJSON as creationMethodFromJSON, data_creationMethodToJSON as creationMethodToJSON, protobufPackage$1 as protobufPackage, data_rewardTypeFromJSON as rewardTypeFromJSON, data_rewardTypeToJSON as rewardTypeToJSON, data_transactionStatusFromJSON as transactionStatusFromJSON, data_transactionStatusToJSON as transactionStatusToJSON };
559
+ export type { DeepPartial$1 as DeepPartial };
361
560
  }
362
561
 
363
562
  declare const protobufPackage = "evm.v2";
@@ -431,6 +630,8 @@ interface TransactionFilter$1 {
431
630
  readonly includeReceipt?: boolean | undefined;
432
631
  /** Flag to request the transaction's logs. Defaults to `false`. */
433
632
  readonly includeLogs?: boolean | undefined;
633
+ /** Flag to request the transaction's trace. Defaults to `false`. */
634
+ readonly includeTransactionTrace?: boolean | undefined;
434
635
  }
435
636
  declare const TransactionFilter$1: {
436
637
  encode(message: TransactionFilter$1, writer?: _m0.Writer): _m0.Writer;
@@ -468,6 +669,8 @@ interface LogFilter$1 {
468
669
  * Defaults to false.
469
670
  */
470
671
  readonly includeSiblings?: boolean | undefined;
672
+ /** Flag to request the log's trace. Defaults to `false`. */
673
+ readonly includeTransactionTrace?: boolean | undefined;
471
674
  }
472
675
  declare const LogFilter$1: {
473
676
  encode(message: LogFilter$1, writer?: _m0.Writer): _m0.Writer;
@@ -508,81 +711,33 @@ declare const filter_protobufPackage: typeof protobufPackage;
508
711
  declare const filter_transactionStatusFilterFromJSON: typeof transactionStatusFilterFromJSON;
509
712
  declare const filter_transactionStatusFilterToJSON: typeof transactionStatusFilterToJSON;
510
713
  declare namespace filter {
511
- export { type filter_DeepPartial as DeepPartial, Filter$1 as Filter, HeaderFilter$1 as HeaderFilter, LogFilter$1 as LogFilter, Topic$1 as Topic, TransactionFilter$1 as TransactionFilter, TransactionStatusFilter$1 as TransactionStatusFilter, WithdrawalFilter$1 as WithdrawalFilter, filter_headerFilterFromJSON as headerFilterFromJSON, filter_headerFilterToJSON as headerFilterToJSON, filter_protobufPackage as protobufPackage, filter_transactionStatusFilterFromJSON as transactionStatusFilterFromJSON, filter_transactionStatusFilterToJSON as transactionStatusFilterToJSON };
714
+ export { Filter$1 as Filter, HeaderFilter$1 as HeaderFilter, LogFilter$1 as LogFilter, Topic$1 as Topic, TransactionFilter$1 as TransactionFilter, TransactionStatusFilter$1 as TransactionStatusFilter, WithdrawalFilter$1 as WithdrawalFilter, filter_headerFilterFromJSON as headerFilterFromJSON, filter_headerFilterToJSON as headerFilterToJSON, filter_protobufPackage as protobufPackage, filter_transactionStatusFilterFromJSON as transactionStatusFilterFromJSON, filter_transactionStatusFilterToJSON as transactionStatusFilterToJSON };
715
+ export type { filter_DeepPartial as DeepPartial };
512
716
  }
513
717
 
514
718
  declare const index_common: typeof common;
515
719
  declare const index_data: typeof data;
516
720
  declare const index_filter: typeof filter;
517
721
  declare namespace index {
518
- export { index_common as common, index_data as data, index_filter as filter };
722
+ export {
723
+ index_common as common,
724
+ index_data as data,
725
+ index_filter as filter,
726
+ };
519
727
  }
520
728
 
521
729
  /** An Ethereum address. */
522
- declare const Address: Schema.transform<Schema.Struct<{
523
- x0: typeof Schema.BigIntFromSelf;
524
- x1: typeof Schema.BigIntFromSelf;
525
- x2: typeof Schema.Number;
526
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
527
- type Address = typeof Address.Type;
528
- /** Wire representation of `B256`. */
529
- declare const B256Proto: Schema.Struct<{
530
- x0: typeof Schema.BigIntFromSelf;
531
- x1: typeof Schema.BigIntFromSelf;
532
- x2: typeof Schema.BigIntFromSelf;
533
- x3: typeof Schema.BigIntFromSelf;
534
- }>;
730
+ declare const Address: Codec<`0x${string}`, Address$1>;
731
+ type Address = CodecType<typeof Address>;
535
732
  /** Data with length 256 bits. */
536
- declare const B256: Schema.transform<Schema.Struct<{
537
- x0: typeof Schema.BigIntFromSelf;
538
- x1: typeof Schema.BigIntFromSelf;
539
- x2: typeof Schema.BigIntFromSelf;
540
- x3: typeof Schema.BigIntFromSelf;
541
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
542
- declare const b256ToProto: (a: `0x${string}`, overrideOptions?: _effect_schema_AST.ParseOptions) => {
543
- readonly x0: bigint;
544
- readonly x1: bigint;
545
- readonly x2: bigint;
546
- readonly x3: bigint;
547
- };
548
- declare const b256FromProto: (i: {
549
- readonly x0: bigint;
550
- readonly x1: bigint;
551
- readonly x2: bigint;
552
- readonly x3: bigint;
553
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => `0x${string}`;
733
+ declare const B256: Codec<`0x${string}`, B256$1>;
734
+ type B256 = CodecType<typeof B256>;
554
735
  /** Data with length 256 bits. */
555
- declare const U256: Schema.transform<Schema.Struct<{
556
- x0: typeof Schema.BigIntFromSelf;
557
- x1: typeof Schema.BigIntFromSelf;
558
- x2: typeof Schema.BigIntFromSelf;
559
- x3: typeof Schema.BigIntFromSelf;
560
- }>, typeof Schema.BigIntFromSelf>;
561
- declare const u256ToProto: (a: bigint, overrideOptions?: _effect_schema_AST.ParseOptions) => {
562
- readonly x0: bigint;
563
- readonly x1: bigint;
564
- readonly x2: bigint;
565
- readonly x3: bigint;
566
- };
567
- declare const u256FromProto: (i: {
568
- readonly x0: bigint;
569
- readonly x1: bigint;
570
- readonly x2: bigint;
571
- readonly x3: bigint;
572
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => bigint;
736
+ declare const U256: Codec<bigint, U256$1>;
737
+ type U256 = CodecType<typeof U256>;
573
738
  /** Data with length 128 bits. */
574
- declare const U128: Schema.transform<Schema.Struct<{
575
- x0: typeof Schema.BigIntFromSelf;
576
- x1: typeof Schema.BigIntFromSelf;
577
- }>, typeof Schema.BigIntFromSelf>;
578
- declare const u128ToProto: (a: bigint, overrideOptions?: _effect_schema_AST.ParseOptions) => {
579
- readonly x0: bigint;
580
- readonly x1: bigint;
581
- };
582
- declare const u128FromProto: (i: {
583
- readonly x0: bigint;
584
- readonly x1: bigint;
585
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => bigint;
739
+ declare const U128: Codec<bigint, U128$1>;
740
+ type U128 = CodecType<typeof U128>;
586
741
 
587
742
  /** Header options.
588
743
  *
@@ -590,1383 +745,1106 @@ declare const u128FromProto: (i: {
590
745
  * - `on_data`: receive headers only if any other filter matches.
591
746
  * - `on_data_or_on_new_block`: receive headers only if any other filter matches and for "live" blocks.
592
747
  */
593
- declare const HeaderFilter: Schema.transform<Schema.Enums<typeof HeaderFilter$1>, Schema.Literal<["always", "on_data", "on_data_or_on_new_block", "unknown"]>>;
594
- type HeaderFilter = typeof HeaderFilter.Type;
595
- declare const WithdrawalFilter: Schema.Struct<{
596
- id: Schema.optional<typeof Schema.Number>;
597
- validatorIndex: Schema.optional<typeof Schema.Number>;
598
- address: Schema.optional<Schema.transform<Schema.Struct<{
599
- x0: typeof Schema.BigIntFromSelf;
600
- x1: typeof Schema.BigIntFromSelf;
601
- x2: typeof Schema.Number;
602
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
748
+ declare const HeaderFilter: Codec<"always" | "on_data" | "on_data_or_on_new_block" | "unknown", HeaderFilter$1>;
749
+ type HeaderFilter = CodecType<typeof HeaderFilter>;
750
+ declare const WithdrawalFilter: MessageCodec<{
751
+ id: Codec<number | undefined, number | undefined>;
752
+ validatorIndex: Codec<number | undefined, number | undefined>;
753
+ address: Codec<`0x${string}` | undefined, Address$1 | undefined>;
603
754
  }>;
604
- type WithdrawalFilter = typeof WithdrawalFilter.Type;
605
- declare const TransactionStatusFilter: Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>;
606
- type TransactionStatusFilter = typeof TransactionStatusFilter.Type;
607
- declare const Topic: Schema.transform<Schema.Struct<{
608
- value: Schema.UndefinedOr<Schema.Struct<{
609
- x0: typeof Schema.BigIntFromSelf;
610
- x1: typeof Schema.BigIntFromSelf;
611
- x2: typeof Schema.BigIntFromSelf;
612
- x3: typeof Schema.BigIntFromSelf;
613
- }>>;
614
- }>, Schema.NullOr<Schema.transform<Schema.Struct<{
615
- x0: typeof Schema.BigIntFromSelf;
616
- x1: typeof Schema.BigIntFromSelf;
617
- x2: typeof Schema.BigIntFromSelf;
618
- x3: typeof Schema.BigIntFromSelf;
619
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>>;
620
- declare const LogFilter: Schema.Struct<{
621
- id: Schema.optional<typeof Schema.Number>;
622
- address: Schema.optional<Schema.transform<Schema.Struct<{
623
- x0: typeof Schema.BigIntFromSelf;
624
- x1: typeof Schema.BigIntFromSelf;
625
- x2: typeof Schema.Number;
626
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
627
- topics: Schema.optional<Schema.Array$<Schema.transform<Schema.Struct<{
628
- value: Schema.UndefinedOr<Schema.Struct<{
629
- x0: typeof Schema.BigIntFromSelf;
630
- x1: typeof Schema.BigIntFromSelf;
631
- x2: typeof Schema.BigIntFromSelf;
632
- x3: typeof Schema.BigIntFromSelf;
633
- }>>;
634
- }>, Schema.NullOr<Schema.transform<Schema.Struct<{
635
- x0: typeof Schema.BigIntFromSelf;
636
- x1: typeof Schema.BigIntFromSelf;
637
- x2: typeof Schema.BigIntFromSelf;
638
- x3: typeof Schema.BigIntFromSelf;
639
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>>>>;
640
- strict: Schema.optional<typeof Schema.Boolean>;
641
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
642
- includeTransaction: Schema.optional<typeof Schema.Boolean>;
643
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
755
+ type WithdrawalFilter = CodecType<typeof WithdrawalFilter>;
756
+ declare const TransactionStatusFilter: Codec<"succeeded" | "reverted" | "all" | "unknown", TransactionStatusFilter$1>;
757
+ type TransactionStatusFilter = CodecType<typeof TransactionStatusFilter>;
758
+ declare const Topic: Codec<B256 | null, {
759
+ value?: B256$1 | undefined;
644
760
  }>;
645
- type LogFilter = typeof LogFilter.Type;
646
- declare const TransactionFilter: Schema.Struct<{
647
- id: Schema.optional<typeof Schema.Number>;
648
- from: Schema.optional<Schema.transform<Schema.Struct<{
649
- x0: typeof Schema.BigIntFromSelf;
650
- x1: typeof Schema.BigIntFromSelf;
651
- x2: typeof Schema.Number;
652
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
653
- to: Schema.optional<Schema.transform<Schema.Struct<{
654
- x0: typeof Schema.BigIntFromSelf;
655
- x1: typeof Schema.BigIntFromSelf;
656
- x2: typeof Schema.Number;
657
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
658
- create: Schema.optional<typeof Schema.Boolean>;
659
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
660
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
661
- includeLogs: Schema.optional<typeof Schema.Boolean>;
761
+ type Topic = CodecType<typeof Topic>;
762
+ declare const LogFilter: MessageCodec<{
763
+ id: Codec<number | undefined, number | undefined>;
764
+ address: Codec<`0x${string}` | undefined, Address$1 | undefined>;
765
+ topics: Codec<readonly (`0x${string}` | null)[] | undefined, readonly {
766
+ value?: B256$1 | undefined;
767
+ }[] | undefined>;
768
+ strict: Codec<boolean | undefined, boolean | undefined>;
769
+ transactionStatus: Codec<"unknown" | "succeeded" | "reverted" | "all" | undefined, TransactionStatusFilter$1 | undefined>;
770
+ includeTransaction: Codec<boolean | undefined, boolean | undefined>;
771
+ includeReceipt: Codec<boolean | undefined, boolean | undefined>;
772
+ includeTransactionTrace: Codec<boolean | undefined, boolean | undefined>;
662
773
  }>;
663
- type TransactionFilter = typeof TransactionFilter.Type;
664
- declare const Filter: Schema.Struct<{
665
- header: Schema.optional<Schema.transform<Schema.Enums<typeof HeaderFilter$1>, Schema.Literal<["always", "on_data", "on_data_or_on_new_block", "unknown"]>>>;
666
- withdrawals: Schema.optional<Schema.Array$<Schema.Struct<{
667
- id: Schema.optional<typeof Schema.Number>;
668
- validatorIndex: Schema.optional<typeof Schema.Number>;
669
- address: Schema.optional<Schema.transform<Schema.Struct<{
670
- x0: typeof Schema.BigIntFromSelf;
671
- x1: typeof Schema.BigIntFromSelf;
672
- x2: typeof Schema.Number;
673
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
674
- }>>>;
675
- transactions: Schema.optional<Schema.Array$<Schema.Struct<{
676
- id: Schema.optional<typeof Schema.Number>;
677
- from: Schema.optional<Schema.transform<Schema.Struct<{
678
- x0: typeof Schema.BigIntFromSelf;
679
- x1: typeof Schema.BigIntFromSelf;
680
- x2: typeof Schema.Number;
681
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
682
- to: Schema.optional<Schema.transform<Schema.Struct<{
683
- x0: typeof Schema.BigIntFromSelf;
684
- x1: typeof Schema.BigIntFromSelf;
685
- x2: typeof Schema.Number;
686
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
687
- create: Schema.optional<typeof Schema.Boolean>;
688
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
689
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
690
- includeLogs: Schema.optional<typeof Schema.Boolean>;
691
- }>>>;
692
- logs: Schema.optional<Schema.Array$<Schema.Struct<{
693
- id: Schema.optional<typeof Schema.Number>;
694
- address: Schema.optional<Schema.transform<Schema.Struct<{
695
- x0: typeof Schema.BigIntFromSelf;
696
- x1: typeof Schema.BigIntFromSelf;
697
- x2: typeof Schema.Number;
698
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
699
- topics: Schema.optional<Schema.Array$<Schema.transform<Schema.Struct<{
700
- value: Schema.UndefinedOr<Schema.Struct<{
701
- x0: typeof Schema.BigIntFromSelf;
702
- x1: typeof Schema.BigIntFromSelf;
703
- x2: typeof Schema.BigIntFromSelf;
704
- x3: typeof Schema.BigIntFromSelf;
705
- }>>;
706
- }>, Schema.NullOr<Schema.transform<Schema.Struct<{
707
- x0: typeof Schema.BigIntFromSelf;
708
- x1: typeof Schema.BigIntFromSelf;
709
- x2: typeof Schema.BigIntFromSelf;
710
- x3: typeof Schema.BigIntFromSelf;
711
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>>>>;
712
- strict: Schema.optional<typeof Schema.Boolean>;
713
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
714
- includeTransaction: Schema.optional<typeof Schema.Boolean>;
715
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
716
- }>>>;
774
+ type LogFilter = Readonly<CodecType<typeof LogFilter>>;
775
+ declare const TransactionFilter: MessageCodec<{
776
+ id: Codec<number | undefined, number | undefined>;
777
+ from: Codec<`0x${string}` | undefined, Address$1 | undefined>;
778
+ to: Codec<`0x${string}` | undefined, Address$1 | undefined>;
779
+ create: Codec<boolean | undefined, boolean | undefined>;
780
+ transactionStatus: Codec<"unknown" | "succeeded" | "reverted" | "all" | undefined, TransactionStatusFilter$1 | undefined>;
781
+ includeReceipt: Codec<boolean | undefined, boolean | undefined>;
782
+ includeLogs: Codec<boolean | undefined, boolean | undefined>;
783
+ includeTransactionTrace: Codec<boolean | undefined, boolean | undefined>;
717
784
  }>;
718
- type Filter = typeof Filter.Type;
719
- declare const filterToProto: (a: {
720
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
721
- readonly withdrawals?: readonly {
722
- readonly id?: number | undefined;
723
- readonly validatorIndex?: number | undefined;
724
- readonly address?: `0x${string}` | undefined;
725
- }[] | undefined;
726
- readonly transactions?: readonly {
727
- readonly id?: number | undefined;
728
- readonly from?: `0x${string}` | undefined;
729
- readonly to?: `0x${string}` | undefined;
730
- readonly create?: boolean | undefined;
731
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
732
- readonly includeReceipt?: boolean | undefined;
733
- readonly includeLogs?: boolean | undefined;
734
- }[] | undefined;
735
- readonly logs?: readonly {
736
- readonly id?: number | undefined;
737
- readonly address?: `0x${string}` | undefined;
738
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
739
- readonly includeReceipt?: boolean | undefined;
740
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
741
- readonly strict?: boolean | undefined;
742
- readonly includeTransaction?: boolean | undefined;
743
- }[] | undefined;
744
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => {
745
- readonly header?: HeaderFilter$1 | undefined;
746
- readonly withdrawals?: readonly {
747
- readonly id?: number | undefined;
748
- readonly validatorIndex?: number | undefined;
749
- readonly address?: {
750
- readonly x0: bigint;
751
- readonly x1: bigint;
752
- readonly x2: number;
753
- } | undefined;
754
- }[] | undefined;
755
- readonly transactions?: readonly {
756
- readonly id?: number | undefined;
757
- readonly from?: {
758
- readonly x0: bigint;
759
- readonly x1: bigint;
760
- readonly x2: number;
761
- } | undefined;
762
- readonly to?: {
763
- readonly x0: bigint;
764
- readonly x1: bigint;
765
- readonly x2: number;
766
- } | undefined;
767
- readonly create?: boolean | undefined;
768
- readonly transactionStatus?: TransactionStatusFilter$1 | undefined;
769
- readonly includeReceipt?: boolean | undefined;
770
- readonly includeLogs?: boolean | undefined;
771
- }[] | undefined;
772
- readonly logs?: readonly {
773
- readonly id?: number | undefined;
774
- readonly address?: {
775
- readonly x0: bigint;
776
- readonly x1: bigint;
777
- readonly x2: number;
778
- } | undefined;
779
- readonly transactionStatus?: TransactionStatusFilter$1 | undefined;
780
- readonly includeReceipt?: boolean | undefined;
781
- readonly topics?: readonly {
782
- readonly value: {
783
- readonly x0: bigint;
784
- readonly x1: bigint;
785
- readonly x2: bigint;
786
- readonly x3: bigint;
787
- } | undefined;
788
- }[] | undefined;
789
- readonly strict?: boolean | undefined;
790
- readonly includeTransaction?: boolean | undefined;
791
- }[] | undefined;
792
- };
793
- declare const filterFromProto: (i: {
794
- readonly header?: HeaderFilter$1 | undefined;
795
- readonly withdrawals?: readonly {
796
- readonly id?: number | undefined;
797
- readonly validatorIndex?: number | undefined;
798
- readonly address?: {
799
- readonly x0: bigint;
800
- readonly x1: bigint;
801
- readonly x2: number;
802
- } | undefined;
803
- }[] | undefined;
804
- readonly transactions?: readonly {
805
- readonly id?: number | undefined;
806
- readonly from?: {
807
- readonly x0: bigint;
808
- readonly x1: bigint;
809
- readonly x2: number;
810
- } | undefined;
811
- readonly to?: {
812
- readonly x0: bigint;
813
- readonly x1: bigint;
814
- readonly x2: number;
815
- } | undefined;
816
- readonly create?: boolean | undefined;
817
- readonly transactionStatus?: TransactionStatusFilter$1 | undefined;
818
- readonly includeReceipt?: boolean | undefined;
819
- readonly includeLogs?: boolean | undefined;
820
- }[] | undefined;
821
- readonly logs?: readonly {
822
- readonly id?: number | undefined;
823
- readonly address?: {
824
- readonly x0: bigint;
825
- readonly x1: bigint;
826
- readonly x2: number;
827
- } | undefined;
828
- readonly transactionStatus?: TransactionStatusFilter$1 | undefined;
829
- readonly includeReceipt?: boolean | undefined;
830
- readonly topics?: readonly {
831
- readonly value: {
832
- readonly x0: bigint;
833
- readonly x1: bigint;
834
- readonly x2: bigint;
835
- readonly x3: bigint;
836
- } | undefined;
785
+ type TransactionFilter = Readonly<CodecType<typeof TransactionFilter>>;
786
+ declare const Filter: MessageCodec<{
787
+ header: Codec<"always" | "on_data" | "on_data_or_on_new_block" | "unknown" | undefined, HeaderFilter$1 | undefined>;
788
+ withdrawals: Codec<readonly {
789
+ id?: number | undefined;
790
+ validatorIndex?: number | undefined;
791
+ address?: `0x${string}` | undefined;
792
+ }[] | undefined, readonly {
793
+ id?: number | undefined;
794
+ validatorIndex?: number | undefined;
795
+ address?: Address$1 | undefined;
796
+ }[] | undefined>;
797
+ transactions: Codec<readonly {
798
+ id?: number | undefined;
799
+ from?: `0x${string}` | undefined;
800
+ to?: `0x${string}` | undefined;
801
+ create?: boolean | undefined;
802
+ transactionStatus?: "unknown" | "succeeded" | "reverted" | "all" | undefined;
803
+ includeReceipt?: boolean | undefined;
804
+ includeLogs?: boolean | undefined;
805
+ includeTransactionTrace?: boolean | undefined;
806
+ }[] | undefined, readonly {
807
+ id?: number | undefined;
808
+ from?: Address$1 | undefined;
809
+ to?: Address$1 | undefined;
810
+ create?: boolean | undefined;
811
+ transactionStatus?: TransactionStatusFilter$1 | undefined;
812
+ includeReceipt?: boolean | undefined;
813
+ includeLogs?: boolean | undefined;
814
+ includeTransactionTrace?: boolean | undefined;
815
+ }[] | undefined>;
816
+ logs: Codec<readonly {
817
+ id?: number | undefined;
818
+ address?: `0x${string}` | undefined;
819
+ topics?: readonly (`0x${string}` | null)[] | undefined;
820
+ strict?: boolean | undefined;
821
+ transactionStatus?: "unknown" | "succeeded" | "reverted" | "all" | undefined;
822
+ includeTransaction?: boolean | undefined;
823
+ includeReceipt?: boolean | undefined;
824
+ includeTransactionTrace?: boolean | undefined;
825
+ }[] | undefined, readonly {
826
+ id?: number | undefined;
827
+ address?: Address$1 | undefined;
828
+ topics?: readonly {
829
+ value?: B256$1 | undefined;
837
830
  }[] | undefined;
838
- readonly strict?: boolean | undefined;
839
- readonly includeTransaction?: boolean | undefined;
840
- }[] | undefined;
841
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => {
842
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
843
- readonly withdrawals?: readonly {
844
- readonly id?: number | undefined;
845
- readonly validatorIndex?: number | undefined;
846
- readonly address?: `0x${string}` | undefined;
847
- }[] | undefined;
848
- readonly transactions?: readonly {
849
- readonly id?: number | undefined;
850
- readonly from?: `0x${string}` | undefined;
851
- readonly to?: `0x${string}` | undefined;
852
- readonly create?: boolean | undefined;
853
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
854
- readonly includeReceipt?: boolean | undefined;
855
- readonly includeLogs?: boolean | undefined;
856
- }[] | undefined;
857
- readonly logs?: readonly {
858
- readonly id?: number | undefined;
859
- readonly address?: `0x${string}` | undefined;
860
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
861
- readonly includeReceipt?: boolean | undefined;
862
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
863
- readonly strict?: boolean | undefined;
864
- readonly includeTransaction?: boolean | undefined;
865
- }[] | undefined;
866
- };
867
- declare const FilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, 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
- }>>>;
895
- logs: Schema.optional<Schema.Array$<Schema.Struct<{
896
- id: Schema.optional<typeof Schema.Number>;
897
- address: Schema.optional<Schema.transform<Schema.Struct<{
898
- x0: typeof Schema.BigIntFromSelf;
899
- x1: typeof Schema.BigIntFromSelf;
900
- x2: typeof Schema.Number;
901
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
902
- topics: Schema.optional<Schema.Array$<Schema.transform<Schema.Struct<{
903
- value: Schema.UndefinedOr<Schema.Struct<{
904
- x0: typeof Schema.BigIntFromSelf;
905
- x1: typeof Schema.BigIntFromSelf;
906
- x2: typeof Schema.BigIntFromSelf;
907
- x3: typeof Schema.BigIntFromSelf;
908
- }>>;
909
- }>, Schema.NullOr<Schema.transform<Schema.Struct<{
910
- x0: typeof Schema.BigIntFromSelf;
911
- x1: typeof Schema.BigIntFromSelf;
912
- x2: typeof Schema.BigIntFromSelf;
913
- x3: typeof Schema.BigIntFromSelf;
914
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>>>>;
915
- strict: Schema.optional<typeof Schema.Boolean>;
916
- transactionStatus: Schema.optional<Schema.transform<Schema.Enums<typeof TransactionStatusFilter$1>, Schema.Literal<["succeeded", "reverted", "all", "unknown"]>>>;
917
- includeTransaction: Schema.optional<typeof Schema.Boolean>;
918
- includeReceipt: Schema.optional<typeof Schema.Boolean>;
919
- }>>>;
920
- }>>;
921
- declare const filterToBytes: (a: {
922
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
923
- readonly withdrawals?: readonly {
924
- readonly id?: number | undefined;
925
- readonly validatorIndex?: number | undefined;
926
- readonly address?: `0x${string}` | undefined;
927
- }[] | undefined;
928
- readonly transactions?: readonly {
929
- readonly id?: number | undefined;
930
- readonly from?: `0x${string}` | undefined;
931
- readonly to?: `0x${string}` | undefined;
932
- readonly create?: boolean | undefined;
933
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
934
- readonly includeReceipt?: boolean | undefined;
935
- readonly includeLogs?: boolean | undefined;
936
- }[] | undefined;
937
- readonly logs?: readonly {
938
- readonly id?: number | undefined;
939
- readonly address?: `0x${string}` | undefined;
940
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
941
- readonly includeReceipt?: boolean | undefined;
942
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
943
- readonly strict?: boolean | undefined;
944
- readonly includeTransaction?: boolean | undefined;
945
- }[] | undefined;
946
- }, overrideOptions?: _effect_schema_AST.ParseOptions) => Uint8Array;
947
- declare const filterFromBytes: (i: Uint8Array, overrideOptions?: _effect_schema_AST.ParseOptions) => {
948
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
949
- readonly withdrawals?: readonly {
950
- readonly id?: number | undefined;
951
- readonly validatorIndex?: number | undefined;
952
- readonly address?: `0x${string}` | undefined;
953
- }[] | undefined;
954
- readonly transactions?: readonly {
955
- readonly id?: number | undefined;
956
- readonly from?: `0x${string}` | undefined;
957
- readonly to?: `0x${string}` | undefined;
958
- readonly create?: boolean | undefined;
959
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
960
- readonly includeReceipt?: boolean | undefined;
961
- readonly includeLogs?: boolean | undefined;
962
- }[] | undefined;
963
- readonly logs?: readonly {
964
- readonly id?: number | undefined;
965
- readonly address?: `0x${string}` | undefined;
966
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
967
- readonly includeReceipt?: boolean | undefined;
968
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
969
- readonly strict?: boolean | undefined;
970
- readonly includeTransaction?: boolean | undefined;
971
- }[] | undefined;
972
- };
831
+ strict?: boolean | undefined;
832
+ transactionStatus?: TransactionStatusFilter$1 | undefined;
833
+ includeTransaction?: boolean | undefined;
834
+ includeReceipt?: boolean | undefined;
835
+ includeTransactionTrace?: boolean | undefined;
836
+ }[] | undefined>;
837
+ }>;
838
+ type Filter = Readonly<CodecType<typeof Filter>>;
839
+ declare const FilterFromBytes: Codec<Filter, Uint8Array>;
973
840
  declare function mergeFilter(a: Filter, b: Filter): Filter;
974
841
 
975
- declare const Bloom: Schema.transform<Schema.Struct<{
976
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
977
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
978
- declare const TransactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
979
- type TransactionStatus = typeof TransactionStatus.Type;
980
- declare const BlockHeader: Schema.Struct<{
981
- blockNumber: typeof Schema.BigIntFromSelf;
982
- blockHash: Schema.transform<Schema.Struct<{
983
- x0: typeof Schema.BigIntFromSelf;
984
- x1: typeof Schema.BigIntFromSelf;
985
- x2: typeof Schema.BigIntFromSelf;
986
- x3: typeof Schema.BigIntFromSelf;
987
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
988
- parentBlockHash: Schema.transform<Schema.Struct<{
989
- x0: typeof Schema.BigIntFromSelf;
990
- x1: typeof Schema.BigIntFromSelf;
991
- x2: typeof Schema.BigIntFromSelf;
992
- x3: typeof Schema.BigIntFromSelf;
993
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
994
- unclesHash: Schema.transform<Schema.Struct<{
995
- x0: typeof Schema.BigIntFromSelf;
996
- x1: typeof Schema.BigIntFromSelf;
997
- x2: typeof Schema.BigIntFromSelf;
998
- x3: typeof Schema.BigIntFromSelf;
999
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1000
- miner: Schema.transform<Schema.Struct<{
1001
- x0: typeof Schema.BigIntFromSelf;
1002
- x1: typeof Schema.BigIntFromSelf;
1003
- x2: typeof Schema.Number;
1004
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1005
- stateRoot: Schema.transform<Schema.Struct<{
1006
- x0: typeof Schema.BigIntFromSelf;
1007
- x1: typeof Schema.BigIntFromSelf;
1008
- x2: typeof Schema.BigIntFromSelf;
1009
- x3: typeof Schema.BigIntFromSelf;
1010
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1011
- transactionsRoot: Schema.transform<Schema.Struct<{
1012
- x0: typeof Schema.BigIntFromSelf;
1013
- x1: typeof Schema.BigIntFromSelf;
1014
- x2: typeof Schema.BigIntFromSelf;
1015
- x3: typeof Schema.BigIntFromSelf;
1016
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1017
- receiptsRoot: Schema.transform<Schema.Struct<{
1018
- x0: typeof Schema.BigIntFromSelf;
1019
- x1: typeof Schema.BigIntFromSelf;
1020
- x2: typeof Schema.BigIntFromSelf;
1021
- x3: typeof Schema.BigIntFromSelf;
1022
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1023
- logsBloom: Schema.transform<Schema.Struct<{
1024
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1025
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1026
- difficulty: Schema.transform<Schema.Struct<{
1027
- x0: typeof Schema.BigIntFromSelf;
1028
- x1: typeof Schema.BigIntFromSelf;
1029
- x2: typeof Schema.BigIntFromSelf;
1030
- x3: typeof Schema.BigIntFromSelf;
1031
- }>, typeof Schema.BigIntFromSelf>;
1032
- gasLimit: Schema.transform<Schema.Struct<{
1033
- x0: typeof Schema.BigIntFromSelf;
1034
- x1: typeof Schema.BigIntFromSelf;
1035
- }>, typeof Schema.BigIntFromSelf>;
1036
- gasUsed: Schema.transform<Schema.Struct<{
1037
- x0: typeof Schema.BigIntFromSelf;
1038
- x1: typeof Schema.BigIntFromSelf;
1039
- }>, typeof Schema.BigIntFromSelf>;
1040
- timestamp: typeof Schema.DateFromSelf;
1041
- extraData: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1042
- mixHash: Schema.optional<Schema.transform<Schema.Struct<{
1043
- x0: typeof Schema.BigIntFromSelf;
1044
- x1: typeof Schema.BigIntFromSelf;
1045
- x2: typeof Schema.BigIntFromSelf;
1046
- x3: typeof Schema.BigIntFromSelf;
1047
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1048
- nonce: Schema.optional<typeof Schema.BigIntFromSelf>;
1049
- baseFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1050
- x0: typeof Schema.BigIntFromSelf;
1051
- x1: typeof Schema.BigIntFromSelf;
1052
- }>, typeof Schema.BigIntFromSelf>>;
1053
- withdrawalsRoot: Schema.optional<Schema.transform<Schema.Struct<{
1054
- x0: typeof Schema.BigIntFromSelf;
1055
- x1: typeof Schema.BigIntFromSelf;
1056
- x2: typeof Schema.BigIntFromSelf;
1057
- x3: typeof Schema.BigIntFromSelf;
1058
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1059
- totalDifficulty: Schema.optional<Schema.transform<Schema.Struct<{
1060
- x0: typeof Schema.BigIntFromSelf;
1061
- x1: typeof Schema.BigIntFromSelf;
1062
- x2: typeof Schema.BigIntFromSelf;
1063
- x3: typeof Schema.BigIntFromSelf;
1064
- }>, typeof Schema.BigIntFromSelf>>;
1065
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
1066
- x0: typeof Schema.BigIntFromSelf;
1067
- x1: typeof Schema.BigIntFromSelf;
1068
- }>, typeof Schema.BigIntFromSelf>>;
1069
- excessBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
1070
- x0: typeof Schema.BigIntFromSelf;
1071
- x1: typeof Schema.BigIntFromSelf;
1072
- }>, typeof Schema.BigIntFromSelf>>;
1073
- parentBeaconBlockRoot: Schema.optional<Schema.transform<Schema.Struct<{
1074
- x0: typeof Schema.BigIntFromSelf;
1075
- x1: typeof Schema.BigIntFromSelf;
1076
- x2: typeof Schema.BigIntFromSelf;
1077
- x3: typeof Schema.BigIntFromSelf;
1078
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
842
+ declare const Bloom: Codec<`0x${string}` | undefined, {
843
+ value?: Uint8Array | undefined;
844
+ }>;
845
+ type Bloom = CodecType<typeof Bloom>;
846
+ declare const TransactionStatus: Codec<"unknown" | "succeeded" | "reverted", TransactionStatus$1>;
847
+ type TransactionStatus = CodecType<typeof TransactionStatus>;
848
+ declare const BlockHeader: MessageCodec<{
849
+ blockNumber: Codec<bigint, bigint | undefined>;
850
+ blockHash: Codec<`0x${string}` | undefined, B256$1 | undefined>;
851
+ parentBlockHash: Codec<`0x${string}`, B256$1 | undefined>;
852
+ unclesHash: Codec<`0x${string}`, B256$1 | undefined>;
853
+ miner: Codec<`0x${string}` | undefined, Address$1 | undefined>;
854
+ stateRoot: Codec<`0x${string}`, B256$1 | undefined>;
855
+ transactionsRoot: Codec<`0x${string}`, B256$1 | undefined>;
856
+ receiptsRoot: Codec<`0x${string}`, B256$1 | undefined>;
857
+ logsBloom: Codec<`0x${string}` | undefined, {
858
+ value?: Uint8Array | undefined;
859
+ } | undefined>;
860
+ difficulty: Codec<bigint, U256$1 | undefined>;
861
+ gasLimit: Codec<bigint, U128$1 | undefined>;
862
+ gasUsed: Codec<bigint, U128$1 | undefined>;
863
+ timestamp: Codec<Date, Date | undefined>;
864
+ extraData: Codec<`0x${string}`, Uint8Array<ArrayBufferLike> | undefined>;
865
+ mixHash: Codec<`0x${string}` | undefined, B256$1 | undefined>;
866
+ nonce: Codec<bigint | undefined, bigint | undefined>;
867
+ baseFeePerGas: Codec<bigint | undefined, U128$1 | undefined>;
868
+ withdrawalsRoot: Codec<`0x${string}` | undefined, B256$1 | undefined>;
869
+ totalDifficulty: Codec<bigint | undefined, U256$1 | undefined>;
870
+ blobGasUsed: Codec<bigint | undefined, U128$1 | undefined>;
871
+ excessBlobGas: Codec<bigint | undefined, U128$1 | undefined>;
872
+ parentBeaconBlockRoot: Codec<`0x${string}` | undefined, B256$1 | undefined>;
873
+ requestsHash: Codec<`0x${string}` | undefined, B256$1 | undefined>;
874
+ }>;
875
+ type BlockHeader = CodecType<typeof BlockHeader>;
876
+ declare const Withdrawal: MessageCodec<{
877
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
878
+ withdrawalIndex: Codec<number, number | undefined>;
879
+ index: Codec<bigint, bigint | undefined>;
880
+ validatorIndex: Codec<number, number | undefined>;
881
+ address: Codec<`0x${string}`, Address$1 | undefined>;
882
+ amount: Codec<bigint, bigint | undefined>;
883
+ }>;
884
+ type Withdrawal = CodecType<typeof Withdrawal>;
885
+ declare const AccessListItem: MessageCodec<{
886
+ address: Codec<`0x${string}`, Address$1 | undefined>;
887
+ storageKeys: Codec<readonly `0x${string}`[], readonly B256$1[] | undefined>;
888
+ }>;
889
+ type AccessListItem = CodecType<typeof AccessListItem>;
890
+ declare const Signature: MessageCodec<{
891
+ r: Codec<bigint, U256$1 | undefined>;
892
+ s: Codec<bigint, U256$1 | undefined>;
893
+ v: Codec<bigint | undefined, U256$1 | undefined>;
894
+ YParity: Codec<boolean | undefined, boolean | undefined>;
895
+ }>;
896
+ type Signature = CodecType<typeof Signature>;
897
+ declare const Transaction: MessageCodec<{
898
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
899
+ transactionIndex: Codec<number, number | undefined>;
900
+ transactionHash: Codec<`0x${string}`, B256$1 | undefined>;
901
+ nonce: Codec<bigint, bigint | undefined>;
902
+ from: Codec<`0x${string}`, Address$1 | undefined>;
903
+ to: Codec<`0x${string}` | undefined, Address$1 | undefined>;
904
+ value: Codec<bigint, U256$1 | undefined>;
905
+ gasPrice: Codec<bigint | undefined, U128$1 | undefined>;
906
+ gas: Codec<bigint, U128$1 | undefined>;
907
+ maxFeePerGas: Codec<bigint | undefined, U128$1 | undefined>;
908
+ maxPriorityFeePerGas: Codec<bigint | undefined, U128$1 | undefined>;
909
+ input: Codec<`0x${string}`, Uint8Array<ArrayBufferLike> | undefined>;
910
+ signature: Codec<{
911
+ r: bigint;
912
+ s: bigint;
913
+ v?: bigint | undefined;
914
+ YParity?: boolean | undefined;
915
+ } | undefined, {
916
+ r?: U256$1 | undefined;
917
+ s?: U256$1 | undefined;
918
+ v?: U256$1 | undefined;
919
+ YParity?: boolean | undefined;
920
+ } | undefined>;
921
+ chainId: Codec<bigint | undefined, bigint | undefined>;
922
+ accessList: Codec<readonly {
923
+ address: `0x${string}`;
924
+ storageKeys: readonly `0x${string}`[];
925
+ }[], readonly {
926
+ address?: Address$1 | undefined;
927
+ storageKeys?: readonly B256$1[] | undefined;
928
+ }[] | undefined>;
929
+ transactionType: Codec<bigint, bigint | undefined>;
930
+ maxFeePerBlobGas: Codec<bigint | undefined, U128$1 | undefined>;
931
+ blobVersionedHashes: Codec<readonly `0x${string}`[], readonly B256$1[] | undefined>;
932
+ transactionStatus: Codec<"unknown", TransactionStatus$1 | undefined> | Codec<"succeeded", TransactionStatus$1 | undefined> | Codec<"reverted", TransactionStatus$1 | undefined>;
933
+ }>;
934
+ type Transaction = CodecType<typeof Transaction>;
935
+ declare const TransactionReceipt: MessageCodec<{
936
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
937
+ transactionIndex: Codec<number, number | undefined>;
938
+ transactionHash: Codec<`0x${string}`, B256$1 | undefined>;
939
+ cumulativeGasUsed: Codec<bigint, U128$1 | undefined>;
940
+ gasUsed: Codec<bigint, U128$1 | undefined>;
941
+ effectiveGasPrice: Codec<bigint, U128$1 | undefined>;
942
+ from: Codec<`0x${string}`, Address$1 | undefined>;
943
+ to: Codec<`0x${string}` | undefined, Address$1 | undefined>;
944
+ contractAddress: Codec<`0x${string}` | undefined, Address$1 | undefined>;
945
+ logsBloom: Codec<`0x${string}`, {
946
+ value?: Uint8Array | undefined;
947
+ } | undefined>;
948
+ transactionType: Codec<bigint, bigint | undefined>;
949
+ blobGasUsed: Codec<bigint | undefined, U128$1 | undefined>;
950
+ blobGasPrice: Codec<bigint | undefined, U128$1 | undefined>;
951
+ transactionStatus: Codec<"unknown", TransactionStatus$1 | undefined> | Codec<"succeeded", TransactionStatus$1 | undefined> | Codec<"reverted", TransactionStatus$1 | undefined>;
952
+ }>;
953
+ type TransactionReceipt = CodecType<typeof TransactionReceipt>;
954
+ declare const Log: MessageCodec<{
955
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
956
+ address: Codec<`0x${string}`, Address$1 | undefined>;
957
+ topics: Codec<readonly `0x${string}`[], readonly B256$1[] | undefined>;
958
+ data: Codec<`0x${string}`, Uint8Array<ArrayBufferLike> | undefined>;
959
+ logIndex: Codec<number, number | undefined>;
960
+ logIndexInTransaction: Codec<number, number | undefined>;
961
+ transactionIndex: Codec<number, number | undefined>;
962
+ transactionHash: Codec<`0x${string}`, B256$1 | undefined>;
963
+ transactionStatus: Codec<"unknown", TransactionStatus$1 | undefined> | Codec<"succeeded", TransactionStatus$1 | undefined> | Codec<"reverted", TransactionStatus$1 | undefined>;
1079
964
  }>;
1080
- type BlockHeader = typeof BlockHeader.Type;
1081
- declare const Withdrawal: Schema.Struct<{
1082
- filterIds: Schema.Array$<typeof Schema.Number>;
1083
- withdrawalIndex: typeof Schema.Number;
1084
- index: typeof Schema.BigIntFromSelf;
1085
- validatorIndex: typeof Schema.Number;
1086
- address: Schema.transform<Schema.Struct<{
1087
- x0: typeof Schema.BigIntFromSelf;
1088
- x1: typeof Schema.BigIntFromSelf;
1089
- x2: typeof Schema.Number;
1090
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1091
- amount: typeof Schema.BigIntFromSelf;
965
+ type Log = CodecType<typeof Log>;
966
+ declare const CallType: Codec<"unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall", CallType$1>;
967
+ type CallType = CodecType<typeof CallType>;
968
+ declare const CreationMethod: Codec<"unknown" | "create" | "create2" | "eofCreate", CreationMethod$1>;
969
+ type CreationMethod = CodecType<typeof CreationMethod>;
970
+ declare const CallAction: MessageCodec<{
971
+ fromAddress: Codec<`0x${string}`, Address$1 | undefined>;
972
+ 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>;
973
+ gas: Codec<bigint, bigint | undefined>;
974
+ input: Codec<`0x${string}`, Uint8Array<ArrayBufferLike> | undefined>;
975
+ toAddress: Codec<`0x${string}`, Address$1 | undefined>;
976
+ value: Codec<bigint, U256$1 | undefined>;
1092
977
  }>;
1093
- declare const AccessListItem: Schema.Struct<{
1094
- address: Schema.transform<Schema.Struct<{
1095
- x0: typeof Schema.BigIntFromSelf;
1096
- x1: typeof Schema.BigIntFromSelf;
1097
- x2: typeof Schema.Number;
1098
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1099
- storageKeys: Schema.Array$<Schema.transform<Schema.Struct<{
1100
- x0: typeof Schema.BigIntFromSelf;
1101
- x1: typeof Schema.BigIntFromSelf;
1102
- x2: typeof Schema.BigIntFromSelf;
1103
- x3: typeof Schema.BigIntFromSelf;
1104
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
978
+ type CallAction = CodecType<typeof CallAction>;
979
+ declare const CreateAction: MessageCodec<{
980
+ fromAddress: Codec<`0x${string}`, Address$1 | undefined>;
981
+ gas: Codec<bigint, bigint | undefined>;
982
+ init: Codec<`0x${string}`, Uint8Array<ArrayBufferLike> | undefined>;
983
+ value: Codec<bigint, U256$1 | undefined>;
984
+ creationMethod: Codec<"unknown", CreationMethod$1 | undefined> | Codec<"create", CreationMethod$1 | undefined> | Codec<"create2", CreationMethod$1 | undefined> | Codec<"eofCreate", CreationMethod$1 | undefined>;
1105
985
  }>;
1106
- declare const Signature: Schema.Struct<{
1107
- r: Schema.transform<Schema.Struct<{
1108
- x0: typeof Schema.BigIntFromSelf;
1109
- x1: typeof Schema.BigIntFromSelf;
1110
- x2: typeof Schema.BigIntFromSelf;
1111
- x3: typeof Schema.BigIntFromSelf;
1112
- }>, typeof Schema.BigIntFromSelf>;
1113
- s: Schema.transform<Schema.Struct<{
1114
- x0: typeof Schema.BigIntFromSelf;
1115
- x1: typeof Schema.BigIntFromSelf;
1116
- x2: typeof Schema.BigIntFromSelf;
1117
- x3: typeof Schema.BigIntFromSelf;
1118
- }>, typeof Schema.BigIntFromSelf>;
1119
- v: Schema.transform<Schema.Struct<{
1120
- x0: typeof Schema.BigIntFromSelf;
1121
- x1: typeof Schema.BigIntFromSelf;
1122
- x2: typeof Schema.BigIntFromSelf;
1123
- x3: typeof Schema.BigIntFromSelf;
1124
- }>, typeof Schema.BigIntFromSelf>;
1125
- YParity: Schema.optional<typeof Schema.Boolean>;
986
+ type CreateAction = CodecType<typeof CreateAction>;
987
+ declare const SelfDestructAction: MessageCodec<{
988
+ address: Codec<`0x${string}`, Address$1 | undefined>;
989
+ balance: Codec<bigint, U256$1 | undefined>;
990
+ refundAddress: Codec<`0x${string}`, Address$1 | undefined>;
1126
991
  }>;
1127
- declare const Transaction: Schema.Struct<{
1128
- filterIds: Schema.Array$<typeof Schema.Number>;
1129
- transactionIndex: typeof Schema.Number;
1130
- transactionHash: Schema.transform<Schema.Struct<{
1131
- x0: typeof Schema.BigIntFromSelf;
1132
- x1: typeof Schema.BigIntFromSelf;
1133
- x2: typeof Schema.BigIntFromSelf;
1134
- x3: typeof Schema.BigIntFromSelf;
1135
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1136
- nonce: typeof Schema.BigIntFromSelf;
1137
- from: Schema.transform<Schema.Struct<{
1138
- x0: typeof Schema.BigIntFromSelf;
1139
- x1: typeof Schema.BigIntFromSelf;
1140
- x2: typeof Schema.Number;
1141
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1142
- to: Schema.optional<Schema.transform<Schema.Struct<{
1143
- x0: typeof Schema.BigIntFromSelf;
1144
- x1: typeof Schema.BigIntFromSelf;
1145
- x2: typeof Schema.Number;
1146
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1147
- value: Schema.transform<Schema.Struct<{
1148
- x0: typeof Schema.BigIntFromSelf;
1149
- x1: typeof Schema.BigIntFromSelf;
1150
- x2: typeof Schema.BigIntFromSelf;
1151
- x3: typeof Schema.BigIntFromSelf;
1152
- }>, typeof Schema.BigIntFromSelf>;
1153
- gasPrice: Schema.optional<Schema.transform<Schema.Struct<{
1154
- x0: typeof Schema.BigIntFromSelf;
1155
- x1: typeof Schema.BigIntFromSelf;
1156
- }>, typeof Schema.BigIntFromSelf>>;
1157
- gas: Schema.transform<Schema.Struct<{
1158
- x0: typeof Schema.BigIntFromSelf;
1159
- x1: typeof Schema.BigIntFromSelf;
1160
- }>, typeof Schema.BigIntFromSelf>;
1161
- maxFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1162
- x0: typeof Schema.BigIntFromSelf;
1163
- x1: typeof Schema.BigIntFromSelf;
1164
- }>, typeof Schema.BigIntFromSelf>>;
1165
- maxPriorityFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1166
- x0: typeof Schema.BigIntFromSelf;
1167
- x1: typeof Schema.BigIntFromSelf;
1168
- }>, typeof Schema.BigIntFromSelf>>;
1169
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1170
- signature: Schema.optional<Schema.Struct<{
1171
- r: Schema.transform<Schema.Struct<{
1172
- x0: typeof Schema.BigIntFromSelf;
1173
- x1: typeof Schema.BigIntFromSelf;
1174
- x2: typeof Schema.BigIntFromSelf;
1175
- x3: typeof Schema.BigIntFromSelf;
1176
- }>, typeof Schema.BigIntFromSelf>;
1177
- s: Schema.transform<Schema.Struct<{
1178
- x0: typeof Schema.BigIntFromSelf;
1179
- x1: typeof Schema.BigIntFromSelf;
1180
- x2: typeof Schema.BigIntFromSelf;
1181
- x3: typeof Schema.BigIntFromSelf;
1182
- }>, typeof Schema.BigIntFromSelf>;
1183
- v: Schema.transform<Schema.Struct<{
1184
- x0: typeof Schema.BigIntFromSelf;
1185
- x1: typeof Schema.BigIntFromSelf;
1186
- x2: typeof Schema.BigIntFromSelf;
1187
- x3: typeof Schema.BigIntFromSelf;
1188
- }>, typeof Schema.BigIntFromSelf>;
1189
- YParity: Schema.optional<typeof Schema.Boolean>;
1190
- }>>;
1191
- chainId: Schema.optional<typeof Schema.BigIntFromSelf>;
1192
- accessList: Schema.Array$<Schema.Struct<{
1193
- address: Schema.transform<Schema.Struct<{
1194
- x0: typeof Schema.BigIntFromSelf;
1195
- x1: typeof Schema.BigIntFromSelf;
1196
- x2: typeof Schema.Number;
1197
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1198
- storageKeys: Schema.Array$<Schema.transform<Schema.Struct<{
1199
- x0: typeof Schema.BigIntFromSelf;
1200
- x1: typeof Schema.BigIntFromSelf;
1201
- x2: typeof Schema.BigIntFromSelf;
1202
- x3: typeof Schema.BigIntFromSelf;
1203
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1204
- }>>;
1205
- transactionType: typeof Schema.BigIntFromSelf;
1206
- maxFeePerBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
1207
- x0: typeof Schema.BigIntFromSelf;
1208
- x1: typeof Schema.BigIntFromSelf;
1209
- }>, typeof Schema.BigIntFromSelf>>;
1210
- blobVersionedHashes: Schema.Array$<Schema.transform<Schema.Struct<{
1211
- x0: typeof Schema.BigIntFromSelf;
1212
- x1: typeof Schema.BigIntFromSelf;
1213
- x2: typeof Schema.BigIntFromSelf;
1214
- x3: typeof Schema.BigIntFromSelf;
1215
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1216
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
992
+ type SelfDestructAction = CodecType<typeof SelfDestructAction>;
993
+ declare const RewardType: Codec<"unknown" | "block" | "uncle", RewardType$1>;
994
+ type RewardType = CodecType<typeof RewardType>;
995
+ declare const RewardAction: MessageCodec<{
996
+ author: Codec<`0x${string}`, Address$1 | undefined>;
997
+ type: Codec<"unknown", RewardType$1 | undefined> | Codec<"block", RewardType$1 | undefined> | Codec<"uncle", RewardType$1 | undefined>;
998
+ value: Codec<bigint, U256$1 | undefined>;
1217
999
  }>;
1218
- declare const TransactionReceipt: Schema.Struct<{
1219
- filterIds: Schema.Array$<typeof Schema.Number>;
1220
- transactionIndex: typeof Schema.Number;
1221
- transactionHash: Schema.transform<Schema.Struct<{
1222
- x0: typeof Schema.BigIntFromSelf;
1223
- x1: typeof Schema.BigIntFromSelf;
1224
- x2: typeof Schema.BigIntFromSelf;
1225
- x3: typeof Schema.BigIntFromSelf;
1226
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1227
- cumulativeGasUsed: Schema.transform<Schema.Struct<{
1228
- x0: typeof Schema.BigIntFromSelf;
1229
- x1: typeof Schema.BigIntFromSelf;
1230
- }>, typeof Schema.BigIntFromSelf>;
1231
- gasUsed: Schema.transform<Schema.Struct<{
1232
- x0: typeof Schema.BigIntFromSelf;
1233
- x1: typeof Schema.BigIntFromSelf;
1234
- }>, typeof Schema.BigIntFromSelf>;
1235
- effectiveGasPrice: Schema.transform<Schema.Struct<{
1236
- x0: typeof Schema.BigIntFromSelf;
1237
- x1: typeof Schema.BigIntFromSelf;
1238
- }>, typeof Schema.BigIntFromSelf>;
1239
- from: Schema.transform<Schema.Struct<{
1240
- x0: typeof Schema.BigIntFromSelf;
1241
- x1: typeof Schema.BigIntFromSelf;
1242
- x2: typeof Schema.Number;
1243
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1244
- to: Schema.optional<Schema.transform<Schema.Struct<{
1245
- x0: typeof Schema.BigIntFromSelf;
1246
- x1: typeof Schema.BigIntFromSelf;
1247
- x2: typeof Schema.Number;
1248
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1249
- contractAddress: Schema.optional<Schema.transform<Schema.Struct<{
1250
- x0: typeof Schema.BigIntFromSelf;
1251
- x1: typeof Schema.BigIntFromSelf;
1252
- x2: typeof Schema.Number;
1253
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1254
- logsBloom: Schema.transform<Schema.Struct<{
1255
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1256
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1257
- transactionType: typeof Schema.BigIntFromSelf;
1258
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
1259
- x0: typeof Schema.BigIntFromSelf;
1260
- x1: typeof Schema.BigIntFromSelf;
1261
- }>, typeof Schema.BigIntFromSelf>>;
1262
- blobGasPrice: Schema.optional<Schema.transform<Schema.Struct<{
1263
- x0: typeof Schema.BigIntFromSelf;
1264
- x1: typeof Schema.BigIntFromSelf;
1265
- }>, typeof Schema.BigIntFromSelf>>;
1266
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
1000
+ type RewardAction = CodecType<typeof RewardAction>;
1001
+ declare const CallOutput: MessageCodec<{
1002
+ gasUsed: Codec<bigint, bigint | undefined>;
1003
+ output: Codec<`0x${string}`, Uint8Array<ArrayBufferLike> | undefined>;
1267
1004
  }>;
1268
- declare const Log: Schema.Struct<{
1269
- filterIds: Schema.Array$<typeof Schema.Number>;
1270
- address: Schema.transform<Schema.Struct<{
1271
- x0: typeof Schema.BigIntFromSelf;
1272
- x1: typeof Schema.BigIntFromSelf;
1273
- x2: typeof Schema.Number;
1274
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1275
- topics: Schema.Array$<Schema.transform<Schema.Struct<{
1276
- x0: typeof Schema.BigIntFromSelf;
1277
- x1: typeof Schema.BigIntFromSelf;
1278
- x2: typeof Schema.BigIntFromSelf;
1279
- x3: typeof Schema.BigIntFromSelf;
1280
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1281
- data: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1282
- logIndex: typeof Schema.Number;
1283
- logIndexInTransaction: typeof Schema.Number;
1284
- transactionIndex: typeof Schema.Number;
1285
- transactionHash: Schema.transform<Schema.Struct<{
1286
- x0: typeof Schema.BigIntFromSelf;
1287
- x1: typeof Schema.BigIntFromSelf;
1288
- x2: typeof Schema.BigIntFromSelf;
1289
- x3: typeof Schema.BigIntFromSelf;
1290
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1291
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
1005
+ type CallOutput = CodecType<typeof CallOutput>;
1006
+ declare const CreateOutput: MessageCodec<{
1007
+ address: Codec<`0x${string}`, Address$1 | undefined>;
1008
+ code: Codec<`0x${string}`, Uint8Array<ArrayBufferLike> | undefined>;
1009
+ gasUsed: Codec<bigint, bigint | undefined>;
1292
1010
  }>;
1293
- type Log = typeof Log.Type;
1294
- declare const Block: Schema.Struct<{
1295
- header: Schema.Struct<{
1296
- blockNumber: typeof Schema.BigIntFromSelf;
1297
- blockHash: Schema.transform<Schema.Struct<{
1298
- x0: typeof Schema.BigIntFromSelf;
1299
- x1: typeof Schema.BigIntFromSelf;
1300
- x2: typeof Schema.BigIntFromSelf;
1301
- x3: typeof Schema.BigIntFromSelf;
1302
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1303
- parentBlockHash: Schema.transform<Schema.Struct<{
1304
- x0: typeof Schema.BigIntFromSelf;
1305
- x1: typeof Schema.BigIntFromSelf;
1306
- x2: typeof Schema.BigIntFromSelf;
1307
- x3: typeof Schema.BigIntFromSelf;
1308
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1309
- unclesHash: Schema.transform<Schema.Struct<{
1310
- x0: typeof Schema.BigIntFromSelf;
1311
- x1: typeof Schema.BigIntFromSelf;
1312
- x2: typeof Schema.BigIntFromSelf;
1313
- x3: typeof Schema.BigIntFromSelf;
1314
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1315
- miner: 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
- stateRoot: 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>>;
1326
- transactionsRoot: Schema.transform<Schema.Struct<{
1327
- x0: typeof Schema.BigIntFromSelf;
1328
- x1: typeof Schema.BigIntFromSelf;
1329
- x2: typeof Schema.BigIntFromSelf;
1330
- x3: typeof Schema.BigIntFromSelf;
1331
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1332
- receiptsRoot: Schema.transform<Schema.Struct<{
1333
- x0: typeof Schema.BigIntFromSelf;
1334
- x1: typeof Schema.BigIntFromSelf;
1335
- x2: typeof Schema.BigIntFromSelf;
1336
- x3: typeof Schema.BigIntFromSelf;
1337
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1338
- logsBloom: Schema.transform<Schema.Struct<{
1339
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1340
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1341
- difficulty: 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
- gasLimit: Schema.transform<Schema.Struct<{
1348
- x0: typeof Schema.BigIntFromSelf;
1349
- x1: typeof Schema.BigIntFromSelf;
1350
- }>, typeof Schema.BigIntFromSelf>;
1351
- gasUsed: Schema.transform<Schema.Struct<{
1352
- x0: typeof Schema.BigIntFromSelf;
1353
- x1: typeof Schema.BigIntFromSelf;
1354
- }>, typeof Schema.BigIntFromSelf>;
1355
- timestamp: typeof Schema.DateFromSelf;
1356
- extraData: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1357
- mixHash: Schema.optional<Schema.transform<Schema.Struct<{
1358
- x0: typeof Schema.BigIntFromSelf;
1359
- x1: typeof Schema.BigIntFromSelf;
1360
- x2: typeof Schema.BigIntFromSelf;
1361
- x3: typeof Schema.BigIntFromSelf;
1362
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1363
- nonce: Schema.optional<typeof Schema.BigIntFromSelf>;
1364
- baseFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1365
- x0: typeof Schema.BigIntFromSelf;
1366
- x1: typeof Schema.BigIntFromSelf;
1367
- }>, typeof Schema.BigIntFromSelf>>;
1368
- withdrawalsRoot: Schema.optional<Schema.transform<Schema.Struct<{
1369
- x0: typeof Schema.BigIntFromSelf;
1370
- x1: typeof Schema.BigIntFromSelf;
1371
- x2: typeof Schema.BigIntFromSelf;
1372
- x3: typeof Schema.BigIntFromSelf;
1373
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1374
- totalDifficulty: Schema.optional<Schema.transform<Schema.Struct<{
1375
- x0: typeof Schema.BigIntFromSelf;
1376
- x1: typeof Schema.BigIntFromSelf;
1377
- x2: typeof Schema.BigIntFromSelf;
1378
- x3: typeof Schema.BigIntFromSelf;
1379
- }>, typeof Schema.BigIntFromSelf>>;
1380
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
1381
- x0: typeof Schema.BigIntFromSelf;
1382
- x1: typeof Schema.BigIntFromSelf;
1383
- }>, typeof Schema.BigIntFromSelf>>;
1384
- excessBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
1385
- x0: typeof Schema.BigIntFromSelf;
1386
- x1: typeof Schema.BigIntFromSelf;
1387
- }>, typeof Schema.BigIntFromSelf>>;
1388
- parentBeaconBlockRoot: Schema.optional<Schema.transform<Schema.Struct<{
1389
- x0: typeof Schema.BigIntFromSelf;
1390
- x1: typeof Schema.BigIntFromSelf;
1391
- x2: typeof Schema.BigIntFromSelf;
1392
- x3: typeof Schema.BigIntFromSelf;
1393
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1394
- }>;
1395
- withdrawals: Schema.Array$<Schema.Struct<{
1396
- filterIds: Schema.Array$<typeof Schema.Number>;
1397
- withdrawalIndex: typeof Schema.Number;
1398
- index: typeof Schema.BigIntFromSelf;
1399
- validatorIndex: typeof Schema.Number;
1400
- address: Schema.transform<Schema.Struct<{
1401
- x0: typeof Schema.BigIntFromSelf;
1402
- x1: typeof Schema.BigIntFromSelf;
1403
- x2: typeof Schema.Number;
1404
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1405
- amount: typeof Schema.BigIntFromSelf;
1406
- }>>;
1407
- transactions: Schema.Array$<Schema.Struct<{
1408
- filterIds: Schema.Array$<typeof Schema.Number>;
1409
- transactionIndex: typeof Schema.Number;
1410
- transactionHash: Schema.transform<Schema.Struct<{
1411
- x0: typeof Schema.BigIntFromSelf;
1412
- x1: typeof Schema.BigIntFromSelf;
1413
- x2: typeof Schema.BigIntFromSelf;
1414
- x3: typeof Schema.BigIntFromSelf;
1415
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1416
- nonce: typeof Schema.BigIntFromSelf;
1417
- from: Schema.transform<Schema.Struct<{
1418
- x0: typeof Schema.BigIntFromSelf;
1419
- x1: typeof Schema.BigIntFromSelf;
1420
- x2: typeof Schema.Number;
1421
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1422
- to: Schema.optional<Schema.transform<Schema.Struct<{
1423
- x0: typeof Schema.BigIntFromSelf;
1424
- x1: typeof Schema.BigIntFromSelf;
1425
- x2: typeof Schema.Number;
1426
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1427
- value: Schema.transform<Schema.Struct<{
1428
- x0: typeof Schema.BigIntFromSelf;
1429
- x1: typeof Schema.BigIntFromSelf;
1430
- x2: typeof Schema.BigIntFromSelf;
1431
- x3: typeof Schema.BigIntFromSelf;
1432
- }>, typeof Schema.BigIntFromSelf>;
1433
- gasPrice: Schema.optional<Schema.transform<Schema.Struct<{
1434
- x0: typeof Schema.BigIntFromSelf;
1435
- x1: typeof Schema.BigIntFromSelf;
1436
- }>, typeof Schema.BigIntFromSelf>>;
1437
- gas: Schema.transform<Schema.Struct<{
1438
- x0: typeof Schema.BigIntFromSelf;
1439
- x1: typeof Schema.BigIntFromSelf;
1440
- }>, typeof Schema.BigIntFromSelf>;
1441
- maxFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1442
- x0: typeof Schema.BigIntFromSelf;
1443
- x1: typeof Schema.BigIntFromSelf;
1444
- }>, typeof Schema.BigIntFromSelf>>;
1445
- maxPriorityFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1446
- x0: typeof Schema.BigIntFromSelf;
1447
- x1: typeof Schema.BigIntFromSelf;
1448
- }>, typeof Schema.BigIntFromSelf>>;
1449
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1450
- signature: Schema.optional<Schema.Struct<{
1451
- r: Schema.transform<Schema.Struct<{
1452
- x0: typeof Schema.BigIntFromSelf;
1453
- x1: typeof Schema.BigIntFromSelf;
1454
- x2: typeof Schema.BigIntFromSelf;
1455
- x3: typeof Schema.BigIntFromSelf;
1456
- }>, typeof Schema.BigIntFromSelf>;
1457
- s: Schema.transform<Schema.Struct<{
1458
- x0: typeof Schema.BigIntFromSelf;
1459
- x1: typeof Schema.BigIntFromSelf;
1460
- x2: typeof Schema.BigIntFromSelf;
1461
- x3: typeof Schema.BigIntFromSelf;
1462
- }>, typeof Schema.BigIntFromSelf>;
1463
- v: Schema.transform<Schema.Struct<{
1464
- x0: typeof Schema.BigIntFromSelf;
1465
- x1: typeof Schema.BigIntFromSelf;
1466
- x2: typeof Schema.BigIntFromSelf;
1467
- x3: typeof Schema.BigIntFromSelf;
1468
- }>, typeof Schema.BigIntFromSelf>;
1469
- YParity: Schema.optional<typeof Schema.Boolean>;
1470
- }>>;
1471
- chainId: Schema.optional<typeof Schema.BigIntFromSelf>;
1472
- accessList: Schema.Array$<Schema.Struct<{
1473
- address: 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
- storageKeys: Schema.Array$<Schema.transform<Schema.Struct<{
1479
- x0: typeof Schema.BigIntFromSelf;
1480
- x1: typeof Schema.BigIntFromSelf;
1481
- x2: typeof Schema.BigIntFromSelf;
1482
- x3: typeof Schema.BigIntFromSelf;
1483
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1484
- }>>;
1485
- transactionType: typeof Schema.BigIntFromSelf;
1486
- maxFeePerBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
1487
- x0: typeof Schema.BigIntFromSelf;
1488
- x1: typeof Schema.BigIntFromSelf;
1489
- }>, typeof Schema.BigIntFromSelf>>;
1490
- blobVersionedHashes: Schema.Array$<Schema.transform<Schema.Struct<{
1491
- x0: typeof Schema.BigIntFromSelf;
1492
- x1: typeof Schema.BigIntFromSelf;
1493
- x2: typeof Schema.BigIntFromSelf;
1494
- x3: typeof Schema.BigIntFromSelf;
1495
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1496
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
1497
- }>>;
1498
- receipts: Schema.Array$<Schema.Struct<{
1499
- filterIds: Schema.Array$<typeof Schema.Number>;
1500
- transactionIndex: typeof Schema.Number;
1501
- transactionHash: Schema.transform<Schema.Struct<{
1502
- x0: typeof Schema.BigIntFromSelf;
1503
- x1: typeof Schema.BigIntFromSelf;
1504
- x2: typeof Schema.BigIntFromSelf;
1505
- x3: typeof Schema.BigIntFromSelf;
1506
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1507
- cumulativeGasUsed: Schema.transform<Schema.Struct<{
1508
- x0: typeof Schema.BigIntFromSelf;
1509
- x1: typeof Schema.BigIntFromSelf;
1510
- }>, typeof Schema.BigIntFromSelf>;
1511
- gasUsed: Schema.transform<Schema.Struct<{
1512
- x0: typeof Schema.BigIntFromSelf;
1513
- x1: typeof Schema.BigIntFromSelf;
1514
- }>, typeof Schema.BigIntFromSelf>;
1515
- effectiveGasPrice: Schema.transform<Schema.Struct<{
1516
- x0: typeof Schema.BigIntFromSelf;
1517
- x1: typeof Schema.BigIntFromSelf;
1518
- }>, typeof Schema.BigIntFromSelf>;
1519
- from: Schema.transform<Schema.Struct<{
1520
- x0: typeof Schema.BigIntFromSelf;
1521
- x1: typeof Schema.BigIntFromSelf;
1522
- x2: typeof Schema.Number;
1523
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1524
- to: Schema.optional<Schema.transform<Schema.Struct<{
1525
- x0: typeof Schema.BigIntFromSelf;
1526
- x1: typeof Schema.BigIntFromSelf;
1527
- x2: typeof Schema.Number;
1528
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1529
- contractAddress: Schema.optional<Schema.transform<Schema.Struct<{
1530
- x0: typeof Schema.BigIntFromSelf;
1531
- x1: typeof Schema.BigIntFromSelf;
1532
- x2: typeof Schema.Number;
1533
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1534
- logsBloom: Schema.transform<Schema.Struct<{
1535
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1536
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1537
- transactionType: typeof Schema.BigIntFromSelf;
1538
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
1539
- x0: typeof Schema.BigIntFromSelf;
1540
- x1: typeof Schema.BigIntFromSelf;
1541
- }>, typeof Schema.BigIntFromSelf>>;
1542
- blobGasPrice: Schema.optional<Schema.transform<Schema.Struct<{
1543
- x0: typeof Schema.BigIntFromSelf;
1544
- x1: typeof Schema.BigIntFromSelf;
1545
- }>, typeof Schema.BigIntFromSelf>>;
1546
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
1547
- }>>;
1548
- logs: Schema.Array$<Schema.Struct<{
1549
- filterIds: Schema.Array$<typeof Schema.Number>;
1550
- address: Schema.transform<Schema.Struct<{
1551
- x0: typeof Schema.BigIntFromSelf;
1552
- x1: typeof Schema.BigIntFromSelf;
1553
- x2: typeof Schema.Number;
1554
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1555
- topics: Schema.Array$<Schema.transform<Schema.Struct<{
1556
- x0: typeof Schema.BigIntFromSelf;
1557
- x1: typeof Schema.BigIntFromSelf;
1558
- x2: typeof Schema.BigIntFromSelf;
1559
- x3: typeof Schema.BigIntFromSelf;
1560
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1561
- data: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1562
- logIndex: typeof Schema.Number;
1563
- logIndexInTransaction: typeof Schema.Number;
1564
- transactionIndex: typeof Schema.Number;
1565
- transactionHash: Schema.transform<Schema.Struct<{
1566
- x0: typeof Schema.BigIntFromSelf;
1567
- x1: typeof Schema.BigIntFromSelf;
1568
- x2: typeof Schema.BigIntFromSelf;
1569
- x3: typeof Schema.BigIntFromSelf;
1570
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1571
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
1572
- }>>;
1011
+ type CreateOutput = CodecType<typeof CreateOutput>;
1012
+ declare const Trace: MessageCodec<{
1013
+ action: Codec<{
1014
+ _tag: "create";
1015
+ } & {
1016
+ create: {
1017
+ fromAddress: `0x${string}`;
1018
+ gas: bigint;
1019
+ init: `0x${string}`;
1020
+ value: bigint;
1021
+ creationMethod: "unknown" | "create" | "create2" | "eofCreate";
1022
+ };
1023
+ }, (({
1024
+ $case: "create";
1025
+ } & {
1026
+ create: {
1027
+ fromAddress?: Address$1 | undefined;
1028
+ gas?: bigint | undefined;
1029
+ init?: Uint8Array<ArrayBufferLike> | undefined;
1030
+ value?: U256$1 | undefined;
1031
+ creationMethod?: CreationMethod$1 | undefined;
1032
+ };
1033
+ }) | ({
1034
+ $case: "call";
1035
+ } & {
1036
+ call: {
1037
+ fromAddress?: Address$1 | undefined;
1038
+ type?: CallType$1 | undefined;
1039
+ gas?: bigint | undefined;
1040
+ input?: Uint8Array<ArrayBufferLike> | undefined;
1041
+ toAddress?: Address$1 | undefined;
1042
+ value?: U256$1 | undefined;
1043
+ };
1044
+ }) | ({
1045
+ $case: "selfDestruct";
1046
+ } & {
1047
+ selfDestruct: {
1048
+ address?: Address$1 | undefined;
1049
+ balance?: U256$1 | undefined;
1050
+ refundAddress?: Address$1 | undefined;
1051
+ };
1052
+ }) | ({
1053
+ $case: "reward";
1054
+ } & {
1055
+ reward: {
1056
+ author?: Address$1 | undefined;
1057
+ type?: RewardType$1 | undefined;
1058
+ value?: U256$1 | undefined;
1059
+ };
1060
+ })) | undefined> | Codec<{
1061
+ _tag: "call";
1062
+ } & {
1063
+ call: {
1064
+ fromAddress: `0x${string}`;
1065
+ type: "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall";
1066
+ gas: bigint;
1067
+ input: `0x${string}`;
1068
+ toAddress: `0x${string}`;
1069
+ value: bigint;
1070
+ };
1071
+ }, (({
1072
+ $case: "create";
1073
+ } & {
1074
+ create: {
1075
+ fromAddress?: Address$1 | undefined;
1076
+ gas?: bigint | undefined;
1077
+ init?: Uint8Array<ArrayBufferLike> | undefined;
1078
+ value?: U256$1 | undefined;
1079
+ creationMethod?: CreationMethod$1 | undefined;
1080
+ };
1081
+ }) | ({
1082
+ $case: "call";
1083
+ } & {
1084
+ call: {
1085
+ fromAddress?: Address$1 | undefined;
1086
+ type?: CallType$1 | undefined;
1087
+ gas?: bigint | undefined;
1088
+ input?: Uint8Array<ArrayBufferLike> | undefined;
1089
+ toAddress?: Address$1 | undefined;
1090
+ value?: U256$1 | undefined;
1091
+ };
1092
+ }) | ({
1093
+ $case: "selfDestruct";
1094
+ } & {
1095
+ selfDestruct: {
1096
+ address?: Address$1 | undefined;
1097
+ balance?: U256$1 | undefined;
1098
+ refundAddress?: Address$1 | undefined;
1099
+ };
1100
+ }) | ({
1101
+ $case: "reward";
1102
+ } & {
1103
+ reward: {
1104
+ author?: Address$1 | undefined;
1105
+ type?: RewardType$1 | undefined;
1106
+ value?: U256$1 | undefined;
1107
+ };
1108
+ })) | undefined> | Codec<{
1109
+ _tag: "selfDestruct";
1110
+ } & {
1111
+ selfDestruct: {
1112
+ address: `0x${string}`;
1113
+ balance: bigint;
1114
+ refundAddress: `0x${string}`;
1115
+ };
1116
+ }, (({
1117
+ $case: "create";
1118
+ } & {
1119
+ create: {
1120
+ fromAddress?: Address$1 | undefined;
1121
+ gas?: bigint | undefined;
1122
+ init?: Uint8Array<ArrayBufferLike> | undefined;
1123
+ value?: U256$1 | undefined;
1124
+ creationMethod?: CreationMethod$1 | undefined;
1125
+ };
1126
+ }) | ({
1127
+ $case: "call";
1128
+ } & {
1129
+ call: {
1130
+ fromAddress?: Address$1 | undefined;
1131
+ type?: CallType$1 | undefined;
1132
+ gas?: bigint | undefined;
1133
+ input?: Uint8Array<ArrayBufferLike> | undefined;
1134
+ toAddress?: Address$1 | undefined;
1135
+ value?: U256$1 | undefined;
1136
+ };
1137
+ }) | ({
1138
+ $case: "selfDestruct";
1139
+ } & {
1140
+ selfDestruct: {
1141
+ address?: Address$1 | undefined;
1142
+ balance?: U256$1 | undefined;
1143
+ refundAddress?: Address$1 | undefined;
1144
+ };
1145
+ }) | ({
1146
+ $case: "reward";
1147
+ } & {
1148
+ reward: {
1149
+ author?: Address$1 | undefined;
1150
+ type?: RewardType$1 | undefined;
1151
+ value?: U256$1 | undefined;
1152
+ };
1153
+ })) | undefined> | Codec<{
1154
+ _tag: "reward";
1155
+ } & {
1156
+ reward: {
1157
+ author: `0x${string}`;
1158
+ type: "unknown" | "block" | "uncle";
1159
+ value: bigint;
1160
+ };
1161
+ }, (({
1162
+ $case: "create";
1163
+ } & {
1164
+ create: {
1165
+ fromAddress?: Address$1 | undefined;
1166
+ gas?: bigint | undefined;
1167
+ init?: Uint8Array<ArrayBufferLike> | undefined;
1168
+ value?: U256$1 | undefined;
1169
+ creationMethod?: CreationMethod$1 | undefined;
1170
+ };
1171
+ }) | ({
1172
+ $case: "call";
1173
+ } & {
1174
+ call: {
1175
+ fromAddress?: Address$1 | undefined;
1176
+ type?: CallType$1 | undefined;
1177
+ gas?: bigint | undefined;
1178
+ input?: Uint8Array<ArrayBufferLike> | undefined;
1179
+ toAddress?: Address$1 | undefined;
1180
+ value?: U256$1 | undefined;
1181
+ };
1182
+ }) | ({
1183
+ $case: "selfDestruct";
1184
+ } & {
1185
+ selfDestruct: {
1186
+ address?: Address$1 | undefined;
1187
+ balance?: U256$1 | undefined;
1188
+ refundAddress?: Address$1 | undefined;
1189
+ };
1190
+ }) | ({
1191
+ $case: "reward";
1192
+ } & {
1193
+ reward: {
1194
+ author?: Address$1 | undefined;
1195
+ type?: RewardType$1 | undefined;
1196
+ value?: U256$1 | undefined;
1197
+ };
1198
+ })) | undefined>;
1199
+ error: Codec<string | undefined, string | undefined>;
1200
+ output: Codec<(({
1201
+ _tag: "callOutput";
1202
+ } & {
1203
+ callOutput: {
1204
+ gasUsed: bigint;
1205
+ output: `0x${string}`;
1206
+ };
1207
+ }) | ({
1208
+ _tag: "createOutput";
1209
+ } & {
1210
+ createOutput: {
1211
+ address: `0x${string}`;
1212
+ code: `0x${string}`;
1213
+ gasUsed: bigint;
1214
+ };
1215
+ })) | undefined, (({
1216
+ $case: "callOutput";
1217
+ } & {
1218
+ callOutput: {
1219
+ gasUsed?: bigint | undefined;
1220
+ output?: Uint8Array<ArrayBufferLike> | undefined;
1221
+ };
1222
+ }) | ({
1223
+ $case: "createOutput";
1224
+ } & {
1225
+ createOutput: {
1226
+ address?: Address$1 | undefined;
1227
+ code?: Uint8Array<ArrayBufferLike> | undefined;
1228
+ gasUsed?: bigint | undefined;
1229
+ };
1230
+ })) | undefined>;
1231
+ subtraces: Codec<number, number | undefined>;
1232
+ traceAddress: Codec<readonly number[], readonly number[] | undefined>;
1573
1233
  }>;
1574
- type Block = typeof Block.Type;
1575
- declare const BlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
1576
- header: Schema.Struct<{
1577
- blockNumber: typeof Schema.BigIntFromSelf;
1578
- blockHash: Schema.transform<Schema.Struct<{
1579
- x0: typeof Schema.BigIntFromSelf;
1580
- x1: typeof Schema.BigIntFromSelf;
1581
- x2: typeof Schema.BigIntFromSelf;
1582
- x3: typeof Schema.BigIntFromSelf;
1583
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1584
- parentBlockHash: Schema.transform<Schema.Struct<{
1585
- x0: typeof Schema.BigIntFromSelf;
1586
- x1: typeof Schema.BigIntFromSelf;
1587
- x2: typeof Schema.BigIntFromSelf;
1588
- x3: typeof Schema.BigIntFromSelf;
1589
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1590
- unclesHash: Schema.transform<Schema.Struct<{
1591
- x0: typeof Schema.BigIntFromSelf;
1592
- x1: typeof Schema.BigIntFromSelf;
1593
- x2: typeof Schema.BigIntFromSelf;
1594
- x3: typeof Schema.BigIntFromSelf;
1595
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1596
- miner: Schema.transform<Schema.Struct<{
1597
- x0: typeof Schema.BigIntFromSelf;
1598
- x1: typeof Schema.BigIntFromSelf;
1599
- x2: typeof Schema.Number;
1600
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1601
- stateRoot: 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
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1607
- transactionsRoot: Schema.transform<Schema.Struct<{
1608
- x0: typeof Schema.BigIntFromSelf;
1609
- x1: typeof Schema.BigIntFromSelf;
1610
- x2: typeof Schema.BigIntFromSelf;
1611
- x3: typeof Schema.BigIntFromSelf;
1612
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1613
- receiptsRoot: Schema.transform<Schema.Struct<{
1614
- x0: typeof Schema.BigIntFromSelf;
1615
- x1: typeof Schema.BigIntFromSelf;
1616
- x2: typeof Schema.BigIntFromSelf;
1617
- x3: typeof Schema.BigIntFromSelf;
1618
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1619
- logsBloom: Schema.transform<Schema.Struct<{
1620
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1621
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1622
- difficulty: Schema.transform<Schema.Struct<{
1623
- x0: typeof Schema.BigIntFromSelf;
1624
- x1: typeof Schema.BigIntFromSelf;
1625
- x2: typeof Schema.BigIntFromSelf;
1626
- x3: typeof Schema.BigIntFromSelf;
1627
- }>, typeof Schema.BigIntFromSelf>;
1628
- gasLimit: Schema.transform<Schema.Struct<{
1629
- x0: typeof Schema.BigIntFromSelf;
1630
- x1: typeof Schema.BigIntFromSelf;
1631
- }>, typeof Schema.BigIntFromSelf>;
1632
- gasUsed: Schema.transform<Schema.Struct<{
1633
- x0: typeof Schema.BigIntFromSelf;
1634
- x1: typeof Schema.BigIntFromSelf;
1635
- }>, typeof Schema.BigIntFromSelf>;
1636
- timestamp: typeof Schema.DateFromSelf;
1637
- extraData: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1638
- mixHash: Schema.optional<Schema.transform<Schema.Struct<{
1639
- x0: typeof Schema.BigIntFromSelf;
1640
- x1: typeof Schema.BigIntFromSelf;
1641
- x2: typeof Schema.BigIntFromSelf;
1642
- x3: typeof Schema.BigIntFromSelf;
1643
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1644
- nonce: Schema.optional<typeof Schema.BigIntFromSelf>;
1645
- baseFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1646
- x0: typeof Schema.BigIntFromSelf;
1647
- x1: typeof Schema.BigIntFromSelf;
1648
- }>, typeof Schema.BigIntFromSelf>>;
1649
- withdrawalsRoot: Schema.optional<Schema.transform<Schema.Struct<{
1650
- x0: typeof Schema.BigIntFromSelf;
1651
- x1: typeof Schema.BigIntFromSelf;
1652
- x2: typeof Schema.BigIntFromSelf;
1653
- x3: typeof Schema.BigIntFromSelf;
1654
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1655
- totalDifficulty: Schema.optional<Schema.transform<Schema.Struct<{
1656
- x0: typeof Schema.BigIntFromSelf;
1657
- x1: typeof Schema.BigIntFromSelf;
1658
- x2: typeof Schema.BigIntFromSelf;
1659
- x3: typeof Schema.BigIntFromSelf;
1660
- }>, typeof Schema.BigIntFromSelf>>;
1661
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
1662
- x0: typeof Schema.BigIntFromSelf;
1663
- x1: typeof Schema.BigIntFromSelf;
1664
- }>, typeof Schema.BigIntFromSelf>>;
1665
- excessBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
1666
- x0: typeof Schema.BigIntFromSelf;
1667
- x1: typeof Schema.BigIntFromSelf;
1668
- }>, typeof Schema.BigIntFromSelf>>;
1669
- parentBeaconBlockRoot: Schema.optional<Schema.transform<Schema.Struct<{
1670
- x0: typeof Schema.BigIntFromSelf;
1671
- x1: typeof Schema.BigIntFromSelf;
1672
- x2: typeof Schema.BigIntFromSelf;
1673
- x3: typeof Schema.BigIntFromSelf;
1674
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1675
- }>;
1676
- withdrawals: Schema.Array$<Schema.Struct<{
1677
- filterIds: Schema.Array$<typeof Schema.Number>;
1678
- withdrawalIndex: typeof Schema.Number;
1679
- index: typeof Schema.BigIntFromSelf;
1680
- validatorIndex: typeof Schema.Number;
1681
- address: Schema.transform<Schema.Struct<{
1682
- x0: typeof Schema.BigIntFromSelf;
1683
- x1: typeof Schema.BigIntFromSelf;
1684
- x2: typeof Schema.Number;
1685
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1686
- amount: typeof Schema.BigIntFromSelf;
1687
- }>>;
1688
- transactions: Schema.Array$<Schema.Struct<{
1689
- filterIds: Schema.Array$<typeof Schema.Number>;
1690
- transactionIndex: typeof Schema.Number;
1691
- transactionHash: Schema.transform<Schema.Struct<{
1692
- x0: typeof Schema.BigIntFromSelf;
1693
- x1: typeof Schema.BigIntFromSelf;
1694
- x2: typeof Schema.BigIntFromSelf;
1695
- x3: typeof Schema.BigIntFromSelf;
1696
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1697
- nonce: typeof Schema.BigIntFromSelf;
1698
- from: Schema.transform<Schema.Struct<{
1699
- x0: typeof Schema.BigIntFromSelf;
1700
- x1: typeof Schema.BigIntFromSelf;
1701
- x2: typeof Schema.Number;
1702
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1703
- to: Schema.optional<Schema.transform<Schema.Struct<{
1704
- x0: typeof Schema.BigIntFromSelf;
1705
- x1: typeof Schema.BigIntFromSelf;
1706
- x2: typeof Schema.Number;
1707
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1708
- value: Schema.transform<Schema.Struct<{
1709
- x0: typeof Schema.BigIntFromSelf;
1710
- x1: typeof Schema.BigIntFromSelf;
1711
- x2: typeof Schema.BigIntFromSelf;
1712
- x3: typeof Schema.BigIntFromSelf;
1713
- }>, typeof Schema.BigIntFromSelf>;
1714
- gasPrice: Schema.optional<Schema.transform<Schema.Struct<{
1715
- x0: typeof Schema.BigIntFromSelf;
1716
- x1: typeof Schema.BigIntFromSelf;
1717
- }>, typeof Schema.BigIntFromSelf>>;
1718
- gas: Schema.transform<Schema.Struct<{
1719
- x0: typeof Schema.BigIntFromSelf;
1720
- x1: typeof Schema.BigIntFromSelf;
1721
- }>, typeof Schema.BigIntFromSelf>;
1722
- maxFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1723
- x0: typeof Schema.BigIntFromSelf;
1724
- x1: typeof Schema.BigIntFromSelf;
1725
- }>, typeof Schema.BigIntFromSelf>>;
1726
- maxPriorityFeePerGas: Schema.optional<Schema.transform<Schema.Struct<{
1727
- x0: typeof Schema.BigIntFromSelf;
1728
- x1: typeof Schema.BigIntFromSelf;
1729
- }>, typeof Schema.BigIntFromSelf>>;
1730
- input: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1731
- signature: Schema.optional<Schema.Struct<{
1732
- r: Schema.transform<Schema.Struct<{
1733
- x0: typeof Schema.BigIntFromSelf;
1734
- x1: typeof Schema.BigIntFromSelf;
1735
- x2: typeof Schema.BigIntFromSelf;
1736
- x3: typeof Schema.BigIntFromSelf;
1737
- }>, typeof Schema.BigIntFromSelf>;
1738
- s: Schema.transform<Schema.Struct<{
1739
- x0: typeof Schema.BigIntFromSelf;
1740
- x1: typeof Schema.BigIntFromSelf;
1741
- x2: typeof Schema.BigIntFromSelf;
1742
- x3: typeof Schema.BigIntFromSelf;
1743
- }>, typeof Schema.BigIntFromSelf>;
1744
- v: Schema.transform<Schema.Struct<{
1745
- x0: typeof Schema.BigIntFromSelf;
1746
- x1: typeof Schema.BigIntFromSelf;
1747
- x2: typeof Schema.BigIntFromSelf;
1748
- x3: typeof Schema.BigIntFromSelf;
1749
- }>, typeof Schema.BigIntFromSelf>;
1750
- YParity: Schema.optional<typeof Schema.Boolean>;
1751
- }>>;
1752
- chainId: Schema.optional<typeof Schema.BigIntFromSelf>;
1753
- accessList: Schema.Array$<Schema.Struct<{
1754
- address: 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
- storageKeys: Schema.Array$<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
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1765
- }>>;
1766
- transactionType: typeof Schema.BigIntFromSelf;
1767
- maxFeePerBlobGas: Schema.optional<Schema.transform<Schema.Struct<{
1768
- x0: typeof Schema.BigIntFromSelf;
1769
- x1: typeof Schema.BigIntFromSelf;
1770
- }>, typeof Schema.BigIntFromSelf>>;
1771
- blobVersionedHashes: Schema.Array$<Schema.transform<Schema.Struct<{
1772
- x0: typeof Schema.BigIntFromSelf;
1773
- x1: typeof Schema.BigIntFromSelf;
1774
- x2: typeof Schema.BigIntFromSelf;
1775
- x3: typeof Schema.BigIntFromSelf;
1776
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1777
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
1778
- }>>;
1779
- receipts: Schema.Array$<Schema.Struct<{
1780
- filterIds: Schema.Array$<typeof Schema.Number>;
1781
- transactionIndex: typeof Schema.Number;
1782
- transactionHash: Schema.transform<Schema.Struct<{
1783
- x0: typeof Schema.BigIntFromSelf;
1784
- x1: typeof Schema.BigIntFromSelf;
1785
- x2: typeof Schema.BigIntFromSelf;
1786
- x3: typeof Schema.BigIntFromSelf;
1787
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1788
- cumulativeGasUsed: Schema.transform<Schema.Struct<{
1789
- x0: typeof Schema.BigIntFromSelf;
1790
- x1: typeof Schema.BigIntFromSelf;
1791
- }>, typeof Schema.BigIntFromSelf>;
1792
- gasUsed: Schema.transform<Schema.Struct<{
1793
- x0: typeof Schema.BigIntFromSelf;
1794
- x1: typeof Schema.BigIntFromSelf;
1795
- }>, typeof Schema.BigIntFromSelf>;
1796
- effectiveGasPrice: Schema.transform<Schema.Struct<{
1797
- x0: typeof Schema.BigIntFromSelf;
1798
- x1: typeof Schema.BigIntFromSelf;
1799
- }>, typeof Schema.BigIntFromSelf>;
1800
- from: Schema.transform<Schema.Struct<{
1801
- x0: typeof Schema.BigIntFromSelf;
1802
- x1: typeof Schema.BigIntFromSelf;
1803
- x2: typeof Schema.Number;
1804
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1805
- to: Schema.optional<Schema.transform<Schema.Struct<{
1806
- x0: typeof Schema.BigIntFromSelf;
1807
- x1: typeof Schema.BigIntFromSelf;
1808
- x2: typeof Schema.Number;
1809
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1810
- contractAddress: Schema.optional<Schema.transform<Schema.Struct<{
1811
- x0: typeof Schema.BigIntFromSelf;
1812
- x1: typeof Schema.BigIntFromSelf;
1813
- x2: typeof Schema.Number;
1814
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1815
- logsBloom: Schema.transform<Schema.Struct<{
1816
- value: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1817
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1818
- transactionType: typeof Schema.BigIntFromSelf;
1819
- blobGasUsed: Schema.optional<Schema.transform<Schema.Struct<{
1820
- x0: typeof Schema.BigIntFromSelf;
1821
- x1: typeof Schema.BigIntFromSelf;
1822
- }>, typeof Schema.BigIntFromSelf>>;
1823
- blobGasPrice: Schema.optional<Schema.transform<Schema.Struct<{
1824
- x0: typeof Schema.BigIntFromSelf;
1825
- x1: typeof Schema.BigIntFromSelf;
1826
- }>, typeof Schema.BigIntFromSelf>>;
1827
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
1828
- }>>;
1829
- logs: Schema.Array$<Schema.Struct<{
1830
- filterIds: Schema.Array$<typeof Schema.Number>;
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
- topics: Schema.Array$<Schema.transform<Schema.Struct<{
1837
- x0: typeof Schema.BigIntFromSelf;
1838
- x1: typeof Schema.BigIntFromSelf;
1839
- x2: typeof Schema.BigIntFromSelf;
1840
- x3: typeof Schema.BigIntFromSelf;
1841
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>>;
1842
- data: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
1843
- logIndex: typeof Schema.Number;
1844
- logIndexInTransaction: typeof Schema.Number;
1845
- transactionIndex: typeof Schema.Number;
1846
- transactionHash: Schema.transform<Schema.Struct<{
1847
- x0: typeof Schema.BigIntFromSelf;
1848
- x1: typeof Schema.BigIntFromSelf;
1849
- x2: typeof Schema.BigIntFromSelf;
1850
- x3: typeof Schema.BigIntFromSelf;
1851
- }>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
1852
- transactionStatus: Schema.transform<Schema.Enums<typeof TransactionStatus$1>, Schema.Literal<["unknown", "succeeded", "reverted"]>>;
1853
- }>>;
1854
- }>>>;
1234
+ type Trace = CodecType<typeof Trace>;
1235
+ declare const TransactionTrace: MessageCodec<{
1236
+ filterIds: Codec<readonly number[], readonly number[] | undefined>;
1237
+ transactionIndex: Codec<number, number | undefined>;
1238
+ transactionHash: Codec<`0x${string}`, B256$1 | undefined>;
1239
+ traces: Codec<readonly {
1240
+ action: ({
1241
+ _tag: "create";
1242
+ } & {
1243
+ create: {
1244
+ fromAddress: `0x${string}`;
1245
+ gas: bigint;
1246
+ init: `0x${string}`;
1247
+ value: bigint;
1248
+ creationMethod: "unknown" | "create" | "create2" | "eofCreate";
1249
+ };
1250
+ }) | ({
1251
+ _tag: "call";
1252
+ } & {
1253
+ call: {
1254
+ fromAddress: `0x${string}`;
1255
+ type: "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall";
1256
+ gas: bigint;
1257
+ input: `0x${string}`;
1258
+ toAddress: `0x${string}`;
1259
+ value: bigint;
1260
+ };
1261
+ }) | ({
1262
+ _tag: "selfDestruct";
1263
+ } & {
1264
+ selfDestruct: {
1265
+ address: `0x${string}`;
1266
+ balance: bigint;
1267
+ refundAddress: `0x${string}`;
1268
+ };
1269
+ }) | ({
1270
+ _tag: "reward";
1271
+ } & {
1272
+ reward: {
1273
+ author: `0x${string}`;
1274
+ type: "unknown" | "block" | "uncle";
1275
+ value: bigint;
1276
+ };
1277
+ });
1278
+ error?: string | undefined;
1279
+ output?: (({
1280
+ _tag: "callOutput";
1281
+ } & {
1282
+ callOutput: {
1283
+ gasUsed: bigint;
1284
+ output: `0x${string}`;
1285
+ };
1286
+ }) | ({
1287
+ _tag: "createOutput";
1288
+ } & {
1289
+ createOutput: {
1290
+ address: `0x${string}`;
1291
+ code: `0x${string}`;
1292
+ gasUsed: bigint;
1293
+ };
1294
+ })) | undefined;
1295
+ subtraces: number;
1296
+ traceAddress: readonly number[];
1297
+ }[], readonly {
1298
+ action?: (({
1299
+ $case: "create";
1300
+ } & {
1301
+ create: {
1302
+ fromAddress?: Address$1 | undefined;
1303
+ gas?: bigint | undefined;
1304
+ init?: Uint8Array<ArrayBufferLike> | undefined;
1305
+ value?: U256$1 | undefined;
1306
+ creationMethod?: CreationMethod$1 | undefined;
1307
+ };
1308
+ }) | ({
1309
+ $case: "call";
1310
+ } & {
1311
+ call: {
1312
+ fromAddress?: Address$1 | undefined;
1313
+ type?: CallType$1 | undefined;
1314
+ gas?: bigint | undefined;
1315
+ input?: Uint8Array<ArrayBufferLike> | undefined;
1316
+ toAddress?: Address$1 | undefined;
1317
+ value?: U256$1 | undefined;
1318
+ };
1319
+ }) | ({
1320
+ $case: "selfDestruct";
1321
+ } & {
1322
+ selfDestruct: {
1323
+ address?: Address$1 | undefined;
1324
+ balance?: U256$1 | undefined;
1325
+ refundAddress?: Address$1 | undefined;
1326
+ };
1327
+ }) | ({
1328
+ $case: "reward";
1329
+ } & {
1330
+ reward: {
1331
+ author?: Address$1 | undefined;
1332
+ type?: RewardType$1 | undefined;
1333
+ value?: U256$1 | undefined;
1334
+ };
1335
+ })) | undefined;
1336
+ error?: string | undefined;
1337
+ output?: (({
1338
+ $case: "callOutput";
1339
+ } & {
1340
+ callOutput: {
1341
+ gasUsed?: bigint | undefined;
1342
+ output?: Uint8Array<ArrayBufferLike> | undefined;
1343
+ };
1344
+ }) | ({
1345
+ $case: "createOutput";
1346
+ } & {
1347
+ createOutput: {
1348
+ address?: Address$1 | undefined;
1349
+ code?: Uint8Array<ArrayBufferLike> | undefined;
1350
+ gasUsed?: bigint | undefined;
1351
+ };
1352
+ })) | undefined;
1353
+ subtraces?: number | undefined;
1354
+ traceAddress?: readonly number[] | undefined;
1355
+ }[] | undefined>;
1356
+ }>;
1357
+ type TransactionTrace = CodecType<typeof TransactionTrace>;
1358
+ declare const Block: MessageCodec<{
1359
+ header: Codec<{
1360
+ blockNumber: bigint;
1361
+ blockHash?: `0x${string}` | undefined;
1362
+ parentBlockHash: `0x${string}`;
1363
+ unclesHash: `0x${string}`;
1364
+ miner?: `0x${string}` | undefined;
1365
+ stateRoot: `0x${string}`;
1366
+ transactionsRoot: `0x${string}`;
1367
+ receiptsRoot: `0x${string}`;
1368
+ logsBloom?: `0x${string}` | undefined;
1369
+ difficulty: bigint;
1370
+ gasLimit: bigint;
1371
+ gasUsed: bigint;
1372
+ timestamp: Date;
1373
+ extraData: `0x${string}`;
1374
+ mixHash?: `0x${string}` | undefined;
1375
+ nonce?: bigint | undefined;
1376
+ baseFeePerGas?: bigint | undefined;
1377
+ withdrawalsRoot?: `0x${string}` | undefined;
1378
+ totalDifficulty?: bigint | undefined;
1379
+ blobGasUsed?: bigint | undefined;
1380
+ excessBlobGas?: bigint | undefined;
1381
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
1382
+ requestsHash?: `0x${string}` | undefined;
1383
+ }, {
1384
+ blockNumber?: bigint | undefined;
1385
+ blockHash?: B256$1 | undefined;
1386
+ parentBlockHash?: B256$1 | undefined;
1387
+ unclesHash?: B256$1 | undefined;
1388
+ miner?: Address$1 | undefined;
1389
+ stateRoot?: B256$1 | undefined;
1390
+ transactionsRoot?: B256$1 | undefined;
1391
+ receiptsRoot?: B256$1 | undefined;
1392
+ logsBloom?: {
1393
+ value?: Uint8Array | undefined;
1394
+ } | undefined;
1395
+ difficulty?: U256$1 | undefined;
1396
+ gasLimit?: U128$1 | undefined;
1397
+ gasUsed?: U128$1 | undefined;
1398
+ timestamp?: Date | undefined;
1399
+ extraData?: Uint8Array<ArrayBufferLike> | undefined;
1400
+ mixHash?: B256$1 | undefined;
1401
+ nonce?: bigint | undefined;
1402
+ baseFeePerGas?: U128$1 | undefined;
1403
+ withdrawalsRoot?: B256$1 | undefined;
1404
+ totalDifficulty?: U256$1 | undefined;
1405
+ blobGasUsed?: U128$1 | undefined;
1406
+ excessBlobGas?: U128$1 | undefined;
1407
+ parentBeaconBlockRoot?: B256$1 | undefined;
1408
+ requestsHash?: B256$1 | undefined;
1409
+ } | undefined>;
1410
+ withdrawals: Codec<readonly {
1411
+ filterIds: readonly number[];
1412
+ withdrawalIndex: number;
1413
+ index: bigint;
1414
+ validatorIndex: number;
1415
+ address: `0x${string}`;
1416
+ amount: bigint;
1417
+ }[], readonly {
1418
+ filterIds?: readonly number[] | undefined;
1419
+ withdrawalIndex?: number | undefined;
1420
+ index?: bigint | undefined;
1421
+ validatorIndex?: number | undefined;
1422
+ address?: Address$1 | undefined;
1423
+ amount?: bigint | undefined;
1424
+ }[] | undefined>;
1425
+ transactions: Codec<readonly {
1426
+ filterIds: readonly number[];
1427
+ transactionIndex: number;
1428
+ transactionHash: `0x${string}`;
1429
+ nonce: bigint;
1430
+ from: `0x${string}`;
1431
+ to?: `0x${string}` | undefined;
1432
+ value: bigint;
1433
+ gasPrice?: bigint | undefined;
1434
+ gas: bigint;
1435
+ maxFeePerGas?: bigint | undefined;
1436
+ maxPriorityFeePerGas?: bigint | undefined;
1437
+ input: `0x${string}`;
1438
+ signature?: {
1439
+ r: bigint;
1440
+ s: bigint;
1441
+ v?: bigint | undefined;
1442
+ YParity?: boolean | undefined;
1443
+ } | undefined;
1444
+ chainId?: bigint | undefined;
1445
+ accessList: readonly {
1446
+ address: `0x${string}`;
1447
+ storageKeys: readonly `0x${string}`[];
1448
+ }[];
1449
+ transactionType: bigint;
1450
+ maxFeePerBlobGas?: bigint | undefined;
1451
+ blobVersionedHashes: readonly `0x${string}`[];
1452
+ transactionStatus: "unknown" | "succeeded" | "reverted";
1453
+ }[], readonly {
1454
+ filterIds?: readonly number[] | undefined;
1455
+ transactionIndex?: number | undefined;
1456
+ transactionHash?: B256$1 | undefined;
1457
+ nonce?: bigint | undefined;
1458
+ from?: Address$1 | undefined;
1459
+ to?: Address$1 | undefined;
1460
+ value?: U256$1 | undefined;
1461
+ gasPrice?: U128$1 | undefined;
1462
+ gas?: U128$1 | undefined;
1463
+ maxFeePerGas?: U128$1 | undefined;
1464
+ maxPriorityFeePerGas?: U128$1 | undefined;
1465
+ input?: Uint8Array<ArrayBufferLike> | undefined;
1466
+ signature?: {
1467
+ r?: U256$1 | undefined;
1468
+ s?: U256$1 | undefined;
1469
+ v?: U256$1 | undefined;
1470
+ YParity?: boolean | undefined;
1471
+ } | undefined;
1472
+ chainId?: bigint | undefined;
1473
+ accessList?: readonly {
1474
+ address?: Address$1 | undefined;
1475
+ storageKeys?: readonly B256$1[] | undefined;
1476
+ }[] | undefined;
1477
+ transactionType?: bigint | undefined;
1478
+ maxFeePerBlobGas?: U128$1 | undefined;
1479
+ blobVersionedHashes?: readonly B256$1[] | undefined;
1480
+ transactionStatus?: TransactionStatus$1 | undefined;
1481
+ }[] | undefined>;
1482
+ receipts: Codec<readonly {
1483
+ filterIds: readonly number[];
1484
+ transactionIndex: number;
1485
+ transactionHash: `0x${string}`;
1486
+ cumulativeGasUsed: bigint;
1487
+ gasUsed: bigint;
1488
+ effectiveGasPrice: bigint;
1489
+ from: `0x${string}`;
1490
+ to?: `0x${string}` | undefined;
1491
+ contractAddress?: `0x${string}` | undefined;
1492
+ logsBloom: `0x${string}`;
1493
+ transactionType: bigint;
1494
+ blobGasUsed?: bigint | undefined;
1495
+ blobGasPrice?: bigint | undefined;
1496
+ transactionStatus: "unknown" | "succeeded" | "reverted";
1497
+ }[], readonly {
1498
+ filterIds?: readonly number[] | undefined;
1499
+ transactionIndex?: number | undefined;
1500
+ transactionHash?: B256$1 | undefined;
1501
+ cumulativeGasUsed?: U128$1 | undefined;
1502
+ gasUsed?: U128$1 | undefined;
1503
+ effectiveGasPrice?: U128$1 | undefined;
1504
+ from?: Address$1 | undefined;
1505
+ to?: Address$1 | undefined;
1506
+ contractAddress?: Address$1 | undefined;
1507
+ logsBloom?: {
1508
+ value?: Uint8Array | undefined;
1509
+ } | undefined;
1510
+ transactionType?: bigint | undefined;
1511
+ blobGasUsed?: U128$1 | undefined;
1512
+ blobGasPrice?: U128$1 | undefined;
1513
+ transactionStatus?: TransactionStatus$1 | undefined;
1514
+ }[] | undefined>;
1515
+ logs: Codec<readonly {
1516
+ filterIds: readonly number[];
1517
+ address: `0x${string}`;
1518
+ topics: readonly `0x${string}`[];
1519
+ data: `0x${string}`;
1520
+ logIndex: number;
1521
+ logIndexInTransaction: number;
1522
+ transactionIndex: number;
1523
+ transactionHash: `0x${string}`;
1524
+ transactionStatus: "unknown" | "succeeded" | "reverted";
1525
+ }[], readonly {
1526
+ filterIds?: readonly number[] | undefined;
1527
+ address?: Address$1 | undefined;
1528
+ topics?: readonly B256$1[] | undefined;
1529
+ data?: Uint8Array<ArrayBufferLike> | undefined;
1530
+ logIndex?: number | undefined;
1531
+ logIndexInTransaction?: number | undefined;
1532
+ transactionIndex?: number | undefined;
1533
+ transactionHash?: B256$1 | undefined;
1534
+ transactionStatus?: TransactionStatus$1 | undefined;
1535
+ }[] | undefined>;
1536
+ traces: Codec<readonly {
1537
+ filterIds: readonly number[];
1538
+ transactionIndex: number;
1539
+ transactionHash: `0x${string}`;
1540
+ traces: readonly {
1541
+ action: ({
1542
+ _tag: "create";
1543
+ } & {
1544
+ create: {
1545
+ fromAddress: `0x${string}`;
1546
+ gas: bigint;
1547
+ init: `0x${string}`;
1548
+ value: bigint;
1549
+ creationMethod: "unknown" | "create" | "create2" | "eofCreate";
1550
+ };
1551
+ }) | ({
1552
+ _tag: "call";
1553
+ } & {
1554
+ call: {
1555
+ fromAddress: `0x${string}`;
1556
+ type: "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall";
1557
+ gas: bigint;
1558
+ input: `0x${string}`;
1559
+ toAddress: `0x${string}`;
1560
+ value: bigint;
1561
+ };
1562
+ }) | ({
1563
+ _tag: "selfDestruct";
1564
+ } & {
1565
+ selfDestruct: {
1566
+ address: `0x${string}`;
1567
+ balance: bigint;
1568
+ refundAddress: `0x${string}`;
1569
+ };
1570
+ }) | ({
1571
+ _tag: "reward";
1572
+ } & {
1573
+ reward: {
1574
+ author: `0x${string}`;
1575
+ type: "unknown" | "block" | "uncle";
1576
+ value: bigint;
1577
+ };
1578
+ });
1579
+ error?: string | undefined;
1580
+ output?: (({
1581
+ _tag: "callOutput";
1582
+ } & {
1583
+ callOutput: {
1584
+ gasUsed: bigint;
1585
+ output: `0x${string}`;
1586
+ };
1587
+ }) | ({
1588
+ _tag: "createOutput";
1589
+ } & {
1590
+ createOutput: {
1591
+ address: `0x${string}`;
1592
+ code: `0x${string}`;
1593
+ gasUsed: bigint;
1594
+ };
1595
+ })) | undefined;
1596
+ subtraces: number;
1597
+ traceAddress: readonly number[];
1598
+ }[];
1599
+ }[], readonly {
1600
+ filterIds?: readonly number[] | undefined;
1601
+ transactionIndex?: number | undefined;
1602
+ transactionHash?: B256$1 | undefined;
1603
+ traces?: readonly {
1604
+ action?: (({
1605
+ $case: "create";
1606
+ } & {
1607
+ create: {
1608
+ fromAddress?: Address$1 | undefined;
1609
+ gas?: bigint | undefined;
1610
+ init?: Uint8Array<ArrayBufferLike> | undefined;
1611
+ value?: U256$1 | undefined;
1612
+ creationMethod?: CreationMethod$1 | undefined;
1613
+ };
1614
+ }) | ({
1615
+ $case: "call";
1616
+ } & {
1617
+ call: {
1618
+ fromAddress?: Address$1 | undefined;
1619
+ type?: CallType$1 | undefined;
1620
+ gas?: bigint | undefined;
1621
+ input?: Uint8Array<ArrayBufferLike> | undefined;
1622
+ toAddress?: Address$1 | undefined;
1623
+ value?: U256$1 | undefined;
1624
+ };
1625
+ }) | ({
1626
+ $case: "selfDestruct";
1627
+ } & {
1628
+ selfDestruct: {
1629
+ address?: Address$1 | undefined;
1630
+ balance?: U256$1 | undefined;
1631
+ refundAddress?: Address$1 | undefined;
1632
+ };
1633
+ }) | ({
1634
+ $case: "reward";
1635
+ } & {
1636
+ reward: {
1637
+ author?: Address$1 | undefined;
1638
+ type?: RewardType$1 | undefined;
1639
+ value?: U256$1 | undefined;
1640
+ };
1641
+ })) | undefined;
1642
+ error?: string | undefined;
1643
+ output?: (({
1644
+ $case: "callOutput";
1645
+ } & {
1646
+ callOutput: {
1647
+ gasUsed?: bigint | undefined;
1648
+ output?: Uint8Array<ArrayBufferLike> | undefined;
1649
+ };
1650
+ }) | ({
1651
+ $case: "createOutput";
1652
+ } & {
1653
+ createOutput: {
1654
+ address?: Address$1 | undefined;
1655
+ code?: Uint8Array<ArrayBufferLike> | undefined;
1656
+ gasUsed?: bigint | undefined;
1657
+ };
1658
+ })) | undefined;
1659
+ subtraces?: number | undefined;
1660
+ traceAddress?: readonly number[] | undefined;
1661
+ }[] | undefined;
1662
+ }[] | undefined>;
1663
+ }>;
1664
+ type Block = CodecType<typeof Block>;
1665
+ declare const BlockFromBytes: Codec<Block, Uint8Array>;
1855
1666
 
1856
- declare const EvmStream: StreamConfig<{
1857
- readonly header?: "unknown" | "always" | "on_data" | "on_data_or_on_new_block" | undefined;
1858
- readonly withdrawals?: readonly {
1859
- readonly id?: number | undefined;
1860
- readonly validatorIndex?: number | undefined;
1861
- readonly address?: `0x${string}` | undefined;
1667
+ declare const EvmStream: StreamConfig<Readonly<{
1668
+ header?: "always" | "on_data" | "on_data_or_on_new_block" | "unknown" | undefined;
1669
+ withdrawals?: readonly {
1670
+ id?: number | undefined;
1671
+ validatorIndex?: number | undefined;
1672
+ address?: `0x${string}` | undefined;
1862
1673
  }[] | undefined;
1863
- readonly transactions?: readonly {
1864
- readonly id?: number | undefined;
1865
- readonly from?: `0x${string}` | undefined;
1866
- readonly to?: `0x${string}` | undefined;
1867
- readonly create?: boolean | undefined;
1868
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
1869
- readonly includeReceipt?: boolean | undefined;
1870
- readonly includeLogs?: boolean | undefined;
1674
+ transactions?: readonly {
1675
+ id?: number | undefined;
1676
+ from?: `0x${string}` | undefined;
1677
+ to?: `0x${string}` | undefined;
1678
+ create?: boolean | undefined;
1679
+ transactionStatus?: "unknown" | "succeeded" | "reverted" | "all" | undefined;
1680
+ includeReceipt?: boolean | undefined;
1681
+ includeLogs?: boolean | undefined;
1682
+ includeTransactionTrace?: boolean | undefined;
1871
1683
  }[] | undefined;
1872
- readonly logs?: readonly {
1873
- readonly id?: number | undefined;
1874
- readonly address?: `0x${string}` | undefined;
1875
- readonly transactionStatus?: "succeeded" | "reverted" | "all" | "unknown" | undefined;
1876
- readonly includeReceipt?: boolean | undefined;
1877
- readonly topics?: readonly (`0x${string}` | null)[] | undefined;
1878
- readonly strict?: boolean | undefined;
1879
- readonly includeTransaction?: boolean | undefined;
1684
+ logs?: readonly {
1685
+ id?: number | undefined;
1686
+ address?: `0x${string}` | undefined;
1687
+ topics?: readonly (`0x${string}` | null)[] | undefined;
1688
+ strict?: boolean | undefined;
1689
+ transactionStatus?: "unknown" | "succeeded" | "reverted" | "all" | undefined;
1690
+ includeTransaction?: boolean | undefined;
1691
+ includeReceipt?: boolean | undefined;
1692
+ includeTransactionTrace?: boolean | undefined;
1880
1693
  }[] | undefined;
1881
- }, {
1882
- readonly header: {
1883
- readonly blockNumber: bigint;
1884
- readonly blockHash: `0x${string}`;
1885
- readonly parentBlockHash: `0x${string}`;
1886
- readonly unclesHash: `0x${string}`;
1887
- readonly miner: `0x${string}`;
1888
- readonly stateRoot: `0x${string}`;
1889
- readonly transactionsRoot: `0x${string}`;
1890
- readonly receiptsRoot: `0x${string}`;
1891
- readonly logsBloom: `0x${string}`;
1892
- readonly difficulty: bigint;
1893
- readonly gasLimit: bigint;
1894
- readonly gasUsed: bigint;
1895
- readonly timestamp: Date;
1896
- readonly extraData?: `0x${string}` | undefined;
1897
- readonly mixHash?: `0x${string}` | undefined;
1898
- readonly nonce?: bigint | undefined;
1899
- readonly baseFeePerGas?: bigint | undefined;
1900
- readonly withdrawalsRoot?: `0x${string}` | undefined;
1901
- readonly totalDifficulty?: bigint | undefined;
1902
- readonly blobGasUsed?: bigint | undefined;
1903
- readonly excessBlobGas?: bigint | undefined;
1904
- readonly parentBeaconBlockRoot?: `0x${string}` | undefined;
1694
+ }>, {
1695
+ header: {
1696
+ blockNumber: bigint;
1697
+ blockHash?: `0x${string}` | undefined;
1698
+ parentBlockHash: `0x${string}`;
1699
+ unclesHash: `0x${string}`;
1700
+ miner?: `0x${string}` | undefined;
1701
+ stateRoot: `0x${string}`;
1702
+ transactionsRoot: `0x${string}`;
1703
+ receiptsRoot: `0x${string}`;
1704
+ logsBloom?: `0x${string}` | undefined;
1705
+ difficulty: bigint;
1706
+ gasLimit: bigint;
1707
+ gasUsed: bigint;
1708
+ timestamp: Date;
1709
+ extraData: `0x${string}`;
1710
+ mixHash?: `0x${string}` | undefined;
1711
+ nonce?: bigint | undefined;
1712
+ baseFeePerGas?: bigint | undefined;
1713
+ withdrawalsRoot?: `0x${string}` | undefined;
1714
+ totalDifficulty?: bigint | undefined;
1715
+ blobGasUsed?: bigint | undefined;
1716
+ excessBlobGas?: bigint | undefined;
1717
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
1718
+ requestsHash?: `0x${string}` | undefined;
1905
1719
  };
1906
- readonly withdrawals: readonly {
1907
- readonly validatorIndex: number;
1908
- readonly address: `0x${string}`;
1909
- readonly filterIds: readonly number[];
1910
- readonly withdrawalIndex: number;
1911
- readonly index: bigint;
1912
- readonly amount: bigint;
1720
+ withdrawals: readonly {
1721
+ filterIds: readonly number[];
1722
+ withdrawalIndex: number;
1723
+ index: bigint;
1724
+ validatorIndex: number;
1725
+ address: `0x${string}`;
1726
+ amount: bigint;
1913
1727
  }[];
1914
- readonly transactions: readonly {
1915
- readonly value: bigint;
1916
- readonly from: `0x${string}`;
1917
- readonly to?: `0x${string}` | undefined;
1918
- readonly transactionStatus: "succeeded" | "reverted" | "unknown";
1919
- readonly nonce: bigint;
1920
- readonly filterIds: readonly number[];
1921
- readonly transactionIndex: number;
1922
- readonly transactionHash: `0x${string}`;
1923
- readonly gasPrice?: bigint | undefined;
1924
- readonly gas: bigint;
1925
- readonly maxFeePerGas?: bigint | undefined;
1926
- readonly maxPriorityFeePerGas?: bigint | undefined;
1927
- readonly input?: `0x${string}` | undefined;
1928
- readonly signature?: {
1929
- readonly r: bigint;
1930
- readonly s: bigint;
1931
- readonly v: bigint;
1932
- readonly YParity?: boolean | undefined;
1728
+ transactions: readonly {
1729
+ filterIds: readonly number[];
1730
+ transactionIndex: number;
1731
+ transactionHash: `0x${string}`;
1732
+ nonce: bigint;
1733
+ from: `0x${string}`;
1734
+ to?: `0x${string}` | undefined;
1735
+ value: bigint;
1736
+ gasPrice?: bigint | undefined;
1737
+ gas: bigint;
1738
+ maxFeePerGas?: bigint | undefined;
1739
+ maxPriorityFeePerGas?: bigint | undefined;
1740
+ input: `0x${string}`;
1741
+ signature?: {
1742
+ r: bigint;
1743
+ s: bigint;
1744
+ v?: bigint | undefined;
1745
+ YParity?: boolean | undefined;
1933
1746
  } | undefined;
1934
- readonly chainId?: bigint | undefined;
1935
- readonly accessList: readonly {
1936
- readonly address: `0x${string}`;
1937
- readonly storageKeys: readonly `0x${string}`[];
1747
+ chainId?: bigint | undefined;
1748
+ accessList: readonly {
1749
+ address: `0x${string}`;
1750
+ storageKeys: readonly `0x${string}`[];
1938
1751
  }[];
1939
- readonly transactionType: bigint;
1940
- readonly maxFeePerBlobGas?: bigint | undefined;
1941
- readonly blobVersionedHashes: readonly `0x${string}`[];
1752
+ transactionType: bigint;
1753
+ maxFeePerBlobGas?: bigint | undefined;
1754
+ blobVersionedHashes: readonly `0x${string}`[];
1755
+ transactionStatus: "unknown" | "succeeded" | "reverted";
1756
+ }[];
1757
+ receipts: readonly {
1758
+ filterIds: readonly number[];
1759
+ transactionIndex: number;
1760
+ transactionHash: `0x${string}`;
1761
+ cumulativeGasUsed: bigint;
1762
+ gasUsed: bigint;
1763
+ effectiveGasPrice: bigint;
1764
+ from: `0x${string}`;
1765
+ to?: `0x${string}` | undefined;
1766
+ contractAddress?: `0x${string}` | undefined;
1767
+ logsBloom: `0x${string}`;
1768
+ transactionType: bigint;
1769
+ blobGasUsed?: bigint | undefined;
1770
+ blobGasPrice?: bigint | undefined;
1771
+ transactionStatus: "unknown" | "succeeded" | "reverted";
1942
1772
  }[];
1943
- readonly logs: readonly {
1944
- readonly address: `0x${string}`;
1945
- readonly transactionStatus: "succeeded" | "reverted" | "unknown";
1946
- readonly topics: readonly `0x${string}`[];
1947
- readonly filterIds: readonly number[];
1948
- readonly transactionIndex: number;
1949
- readonly transactionHash: `0x${string}`;
1950
- readonly data?: `0x${string}` | undefined;
1951
- readonly logIndex: number;
1952
- readonly logIndexInTransaction: number;
1773
+ logs: readonly {
1774
+ filterIds: readonly number[];
1775
+ address: `0x${string}`;
1776
+ topics: readonly `0x${string}`[];
1777
+ data: `0x${string}`;
1778
+ logIndex: number;
1779
+ logIndexInTransaction: number;
1780
+ transactionIndex: number;
1781
+ transactionHash: `0x${string}`;
1782
+ transactionStatus: "unknown" | "succeeded" | "reverted";
1953
1783
  }[];
1954
- readonly receipts: readonly {
1955
- readonly from: `0x${string}`;
1956
- readonly to?: `0x${string}` | undefined;
1957
- readonly transactionStatus: "succeeded" | "reverted" | "unknown";
1958
- readonly logsBloom: `0x${string}`;
1959
- readonly gasUsed: bigint;
1960
- readonly blobGasUsed?: bigint | undefined;
1961
- readonly filterIds: readonly number[];
1962
- readonly transactionIndex: number;
1963
- readonly transactionHash: `0x${string}`;
1964
- readonly transactionType: bigint;
1965
- readonly cumulativeGasUsed: bigint;
1966
- readonly effectiveGasPrice: bigint;
1967
- readonly contractAddress?: `0x${string}` | undefined;
1968
- readonly blobGasPrice?: bigint | undefined;
1784
+ traces: readonly {
1785
+ filterIds: readonly number[];
1786
+ transactionIndex: number;
1787
+ transactionHash: `0x${string}`;
1788
+ traces: readonly {
1789
+ action: ({
1790
+ _tag: "create";
1791
+ } & {
1792
+ create: {
1793
+ fromAddress: `0x${string}`;
1794
+ gas: bigint;
1795
+ init: `0x${string}`;
1796
+ value: bigint;
1797
+ creationMethod: "unknown" | "create" | "create2" | "eofCreate";
1798
+ };
1799
+ }) | ({
1800
+ _tag: "call";
1801
+ } & {
1802
+ call: {
1803
+ fromAddress: `0x${string}`;
1804
+ type: "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall";
1805
+ gas: bigint;
1806
+ input: `0x${string}`;
1807
+ toAddress: `0x${string}`;
1808
+ value: bigint;
1809
+ };
1810
+ }) | ({
1811
+ _tag: "selfDestruct";
1812
+ } & {
1813
+ selfDestruct: {
1814
+ address: `0x${string}`;
1815
+ balance: bigint;
1816
+ refundAddress: `0x${string}`;
1817
+ };
1818
+ }) | ({
1819
+ _tag: "reward";
1820
+ } & {
1821
+ reward: {
1822
+ author: `0x${string}`;
1823
+ type: "unknown" | "block" | "uncle";
1824
+ value: bigint;
1825
+ };
1826
+ });
1827
+ error?: string | undefined;
1828
+ output?: (({
1829
+ _tag: "callOutput";
1830
+ } & {
1831
+ callOutput: {
1832
+ gasUsed: bigint;
1833
+ output: `0x${string}`;
1834
+ };
1835
+ }) | ({
1836
+ _tag: "createOutput";
1837
+ } & {
1838
+ createOutput: {
1839
+ address: `0x${string}`;
1840
+ code: `0x${string}`;
1841
+ gasUsed: bigint;
1842
+ };
1843
+ })) | undefined;
1844
+ subtraces: number;
1845
+ traceAddress: readonly number[];
1846
+ }[];
1969
1847
  }[];
1970
1848
  }>;
1971
1849
 
1972
- export { AccessListItem, Address, B256, B256Proto, Block, BlockFromBytes, BlockHeader, Bloom, EvmStream, Filter, FilterFromBytes, HeaderFilter, Log, LogFilter, Signature, Topic, Transaction, TransactionFilter, TransactionReceipt, TransactionStatus, TransactionStatusFilter, U128, U256, Withdrawal, WithdrawalFilter, b256FromProto, b256ToProto, filterFromBytes, filterFromProto, filterToBytes, filterToProto, mergeFilter, index as proto, u128FromProto, u128ToProto, u256FromProto, u256ToProto };
1850
+ 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 };