@apibara/evm 2.1.0-beta.4 → 2.1.0-beta.41

package/dist/index.cjs

@@ -1,8 +1,7 @@
 'use strict';
 
 const protocol = require('@apibara/protocol');
-const schema = require('@effect/schema');
-const viem = require('viem');
+const codec = require('@apibara/protocol/codec');
 const Long = require('long');
 const _m0 = require('protobufjs/minimal.js');
 
@@ -12,91 +11,70 @@ const Long__default = /*#__PURE__*/_interopDefaultCompat(Long);
 const _m0__default = /*#__PURE__*/_interopDefaultCompat(_m0);
 
 const MAX_U64 = 0xffffffffffffffffn;
-const _Address = schema.Schema.TemplateLiteral(schema.Schema.Literal("0x"), schema.Schema.String);
-const AddressProto = schema.Schema.Struct({
-  x0: schema.Schema.BigIntFromSelf,
-  x1: schema.Schema.BigIntFromSelf,
-  x2: schema.Schema.Number
-});
-const Address$1 = schema.Schema.transform(AddressProto, _Address, {
-  decode(value) {
-    const x0 = value.x0.toString(16).padStart(16, "0");
-    const x1 = value.x1.toString(16).padStart(16, "0");
-    const x2 = value.x2.toString(16).padStart(8, "0");
-    return `0x${x0}${x1}${x2}`;
+const MAX_U32 = 0xffffffffn;
+const Address$1 = {
+  encode(x) {
+    const bn = BigInt(x);
+    const x2 = bn & MAX_U32;
+    const x1 = bn >> 32n & MAX_U64;
+    const x0 = bn >> 96n & MAX_U64;
+    return { x0, x1, x2: Number(x2) };
   },
-  encode(value) {
-    const bytes = viem.hexToBytes(viem.pad(value, { size: 20, dir: "left" }));
-    const dv = new DataView(bytes.buffer);
-    const x0 = dv.getBigUint64(0);
-    const x1 = dv.getBigUint64(8);
-    const x2 = dv.getUint32(16);
-    return { x0, x1, x2 };
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = BigInt(p.x2 ?? 0);
+    const bn = x2 + (x1 << 32n) + (x0 << 96n);
+    return `0x${bn.toString(16).padStart(40, "0")}`;
   }
-});
-const _B256 = schema.Schema.TemplateLiteral(schema.Schema.Literal("0x"), schema.Schema.String);
-const B256Proto = schema.Schema.Struct({
-  x0: schema.Schema.BigIntFromSelf,
-  x1: schema.Schema.BigIntFromSelf,
-  x2: schema.Schema.BigIntFromSelf,
-  x3: schema.Schema.BigIntFromSelf
-});
-const B256$1 = schema.Schema.transform(B256Proto, _B256, {
-  decode(value) {
-    const x0 = value.x0.toString(16).padStart(16, "0");
-    const x1 = value.x1.toString(16).padStart(16, "0");
-    const x2 = value.x2.toString(16).padStart(16, "0");
-    const x3 = value.x3.toString(16).padStart(16, "0");
-    return `0x${x0}${x1}${x2}${x3}`;
-  },
-  encode(value) {
-    const bytes = viem.hexToBytes(viem.pad(value, { size: 32, dir: "left" }));
-    const dv = new DataView(bytes.buffer);
-    const x0 = dv.getBigUint64(0);
-    const x1 = dv.getBigUint64(8);
-    const x2 = dv.getBigUint64(16);
-    const x3 = dv.getBigUint64(24);
+};
+const B256$1 = {
+  encode(x) {
+    const bn = BigInt(x);
+    const x3 = bn & MAX_U64;
+    const x2 = bn >> 64n & MAX_U64;
+    const x1 = bn >> 128n & MAX_U64;
+    const x0 = bn >> 192n & MAX_U64;
     return { x0, x1, x2, x3 };
-  }
-});
-const b256ToProto = schema.Schema.encodeSync(B256$1);
-const b256FromProto = schema.Schema.decodeSync(B256$1);
-const U256Proto = schema.Schema.Struct({
-  x0: schema.Schema.BigIntFromSelf,
-  x1: schema.Schema.BigIntFromSelf,
-  x2: schema.Schema.BigIntFromSelf,
-  x3: schema.Schema.BigIntFromSelf
-});
-const U256$1 = schema.Schema.transform(U256Proto, schema.Schema.BigIntFromSelf, {
-  decode(value) {
-    return (value.x0 << 8n * 24n) + (value.x1 << 8n * 16n) + (value.x2 << 8n * 8n) + value.x3;
   },
-  encode(value) {
-    const x0 = value >> 8n * 24n & MAX_U64;
-    const x1 = value >> 8n * 16n & MAX_U64;
-    const x2 = value >> 8n * 8n & MAX_U64;
-    const x3 = value & MAX_U64;
-    return { x0, x1, x2, x3 };
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = p.x2 ?? 0n;
+    const x3 = p.x3 ?? 0n;
+    const bn = x3 + (x2 << 64n) + (x1 << 128n) + (x0 << 192n);
+    return `0x${bn.toString(16).padStart(64, "0")}`;
   }
-});
-const u256ToProto = schema.Schema.encodeSync(U256$1);
-const u256FromProto = schema.Schema.decodeSync(U256$1);
-const U128Proto = schema.Schema.Struct({
-  x0: schema.Schema.BigIntFromSelf,
-  x1: schema.Schema.BigIntFromSelf
-});
-const U128$1 = schema.Schema.transform(U128Proto, schema.Schema.BigIntFromSelf, {
-  decode(value) {
-    return (value.x0 << 8n * 8n) + value.x1;
+};
+const U256$1 = {
+  encode(x) {
+    const bn = BigInt(x);
+    const x3 = bn & MAX_U64;
+    const x2 = bn >> 64n & MAX_U64;
+    const x1 = bn >> 128n & MAX_U64;
+    const x0 = bn >> 192n & MAX_U64;
+    return { x0, x1, x2, x3 };
   },
-  encode(value) {
-    const x0 = value >> 8n * 8n & MAX_U64;
-    const x1 = value & MAX_U64;
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = p.x2 ?? 0n;
+    const x3 = p.x3 ?? 0n;
+    return x3 + (x2 << 64n) + (x1 << 128n) + (x0 << 192n);
+  }
+};
+const U128$1 = {
+  encode(x) {
+    const x1 = x & MAX_U64;
+    const x0 = x >> 64n & MAX_U64;
     return { x0, x1 };
+  },
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    return x1 + (x0 << 64n);
   }
-});
-const u128ToProto = schema.Schema.encodeSync(U128$1);
-const u128FromProto = schema.Schema.decodeSync(U128$1);
+};
 
 const protobufPackage$2 = "evm.v2";
 function createBaseAddress() {
@@ -681,8 +659,143 @@ function transactionStatusToJSON(object) {
       return "UNRECOGNIZED";
   }
 }
+var CallType$1 = /* @__PURE__ */ ((CallType2) => {
+  CallType2[CallType2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  CallType2[CallType2["CALL"] = 1] = "CALL";
+  CallType2[CallType2["CALL_CODE"] = 2] = "CALL_CODE";
+  CallType2[CallType2["DELEGATE_CALL"] = 3] = "DELEGATE_CALL";
+  CallType2[CallType2["STATIC_CALL"] = 4] = "STATIC_CALL";
+  CallType2[CallType2["AUTH_CALL"] = 5] = "AUTH_CALL";
+  CallType2[CallType2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+  return CallType2;
+})(CallType$1 || {});
+function callTypeFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "CALL_TYPE_UNSPECIFIED":
+      return 0 /* UNSPECIFIED */;
+    case 1:
+    case "CALL_TYPE_CALL":
+      return 1 /* CALL */;
+    case 2:
+    case "CALL_TYPE_CALL_CODE":
+      return 2 /* CALL_CODE */;
+    case 3:
+    case "CALL_TYPE_DELEGATE_CALL":
+      return 3 /* DELEGATE_CALL */;
+    case 4:
+    case "CALL_TYPE_STATIC_CALL":
+      return 4 /* STATIC_CALL */;
+    case 5:
+    case "CALL_TYPE_AUTH_CALL":
+      return 5 /* AUTH_CALL */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function callTypeToJSON(object) {
+  switch (object) {
+    case 0 /* UNSPECIFIED */:
+      return "CALL_TYPE_UNSPECIFIED";
+    case 1 /* CALL */:
+      return "CALL_TYPE_CALL";
+    case 2 /* CALL_CODE */:
+      return "CALL_TYPE_CALL_CODE";
+    case 3 /* DELEGATE_CALL */:
+      return "CALL_TYPE_DELEGATE_CALL";
+    case 4 /* STATIC_CALL */:
+      return "CALL_TYPE_STATIC_CALL";
+    case 5 /* AUTH_CALL */:
+      return "CALL_TYPE_AUTH_CALL";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+var CreationMethod$1 = /* @__PURE__ */ ((CreationMethod2) => {
+  CreationMethod2[CreationMethod2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  CreationMethod2[CreationMethod2["CREATE"] = 1] = "CREATE";
+  CreationMethod2[CreationMethod2["CREATE2"] = 2] = "CREATE2";
+  CreationMethod2[CreationMethod2["EOF_CREATE"] = 3] = "EOF_CREATE";
+  CreationMethod2[CreationMethod2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+  return CreationMethod2;
+})(CreationMethod$1 || {});
+function creationMethodFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "CREATION_METHOD_UNSPECIFIED":
+      return 0 /* UNSPECIFIED */;
+    case 1:
+    case "CREATION_METHOD_CREATE":
+      return 1 /* CREATE */;
+    case 2:
+    case "CREATION_METHOD_CREATE2":
+      return 2 /* CREATE2 */;
+    case 3:
+    case "CREATION_METHOD_EOF_CREATE":
+      return 3 /* EOF_CREATE */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function creationMethodToJSON(object) {
+  switch (object) {
+    case 0 /* UNSPECIFIED */:
+      return "CREATION_METHOD_UNSPECIFIED";
+    case 1 /* CREATE */:
+      return "CREATION_METHOD_CREATE";
+    case 2 /* CREATE2 */:
+      return "CREATION_METHOD_CREATE2";
+    case 3 /* EOF_CREATE */:
+      return "CREATION_METHOD_EOF_CREATE";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+var RewardType$1 = /* @__PURE__ */ ((RewardType2) => {
+  RewardType2[RewardType2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  RewardType2[RewardType2["BLOCK"] = 1] = "BLOCK";
+  RewardType2[RewardType2["UNCLE"] = 2] = "UNCLE";
+  RewardType2[RewardType2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+  return RewardType2;
+})(RewardType$1 || {});
+function rewardTypeFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "REWARD_TYPE_UNSPECIFIED":
+      return 0 /* UNSPECIFIED */;
+    case 1:
+    case "REWARD_TYPE_BLOCK":
+      return 1 /* BLOCK */;
+    case 2:
+    case "REWARD_TYPE_UNCLE":
+      return 2 /* UNCLE */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function rewardTypeToJSON(object) {
+  switch (object) {
+    case 0 /* UNSPECIFIED */:
+      return "REWARD_TYPE_UNSPECIFIED";
+    case 1 /* BLOCK */:
+      return "REWARD_TYPE_BLOCK";
+    case 2 /* UNCLE */:
+      return "REWARD_TYPE_UNCLE";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
 function createBaseBlock() {
-  return { header: void 0, withdrawals: [], transactions: [], receipts: [], logs: [] };
+  return { header: void 0, withdrawals: [], transactions: [], receipts: [], logs: [], traces: [] };
 }
 const Block$1 = {
   encode(message, writer = _m0__default.Writer.create()) {
@@ -709,6 +822,11 @@ const Block$1 = {
         Log$1.encode(v, writer.uint32(42).fork()).ldelim();
       }
     }
+    if (message.traces !== void 0 && message.traces.length !== 0) {
+      for (const v of message.traces) {
+        TransactionTrace$1.encode(v, writer.uint32(50).fork()).ldelim();
+      }
+    }
     return writer;
   },
   decode(input, length) {
@@ -748,6 +866,12 @@ const Block$1 = {
           }
           message.logs.push(Log$1.decode(reader, reader.uint32()));
           continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.traces.push(TransactionTrace$1.decode(reader, reader.uint32()));
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -762,7 +886,8 @@ const Block$1 = {
       withdrawals: globalThis.Array.isArray(object?.withdrawals) ? object.withdrawals.map((e) => Withdrawal$1.fromJSON(e)) : [],
       transactions: globalThis.Array.isArray(object?.transactions) ? object.transactions.map((e) => Transaction$1.fromJSON(e)) : [],
       receipts: globalThis.Array.isArray(object?.receipts) ? object.receipts.map((e) => TransactionReceipt$1.fromJSON(e)) : [],
-      logs: globalThis.Array.isArray(object?.logs) ? object.logs.map((e) => Log$1.fromJSON(e)) : []
+      logs: globalThis.Array.isArray(object?.logs) ? object.logs.map((e) => Log$1.fromJSON(e)) : [],
+      traces: globalThis.Array.isArray(object?.traces) ? object.traces.map((e) => TransactionTrace$1.fromJSON(e)) : []
     };
   },
   toJSON(message) {
@@ -782,6 +907,9 @@ const Block$1 = {
     if (message.logs?.length) {
       obj.logs = message.logs.map((e) => Log$1.toJSON(e));
     }
+    if (message.traces?.length) {
+      obj.traces = message.traces.map((e) => TransactionTrace$1.toJSON(e));
+    }
     return obj;
   },
   create(base) {
@@ -794,6 +922,7 @@ const Block$1 = {
     message.transactions = object.transactions?.map((e) => Transaction$1.fromPartial(e)) || [];
     message.receipts = object.receipts?.map((e) => TransactionReceipt$1.fromPartial(e)) || [];
     message.logs = object.logs?.map((e) => Log$1.fromPartial(e)) || [];
+    message.traces = object.traces?.map((e) => TransactionTrace$1.fromPartial(e)) || [];
     return message;
   }
 };
@@ -820,7 +949,8 @@ function createBaseBlockHeader() {
     totalDifficulty: void 0,
     blobGasUsed: void 0,
     excessBlobGas: void 0,
-    parentBeaconBlockRoot: void 0
+    parentBeaconBlockRoot: void 0,
+    requestsHash: void 0
   };
 }
 const BlockHeader$1 = {
@@ -897,6 +1027,9 @@ const BlockHeader$1 = {
     if (message.parentBeaconBlockRoot !== void 0) {
       B256.encode(message.parentBeaconBlockRoot, writer.uint32(178).fork()).ldelim();
     }
+    if (message.requestsHash !== void 0) {
+      B256.encode(message.requestsHash, writer.uint32(186).fork()).ldelim();
+    }
     return writer;
   },
   decode(input, length) {
@@ -1038,6 +1171,12 @@ const BlockHeader$1 = {
           }
           message.parentBeaconBlockRoot = B256.decode(reader, reader.uint32());
           continue;
+        case 23:
+          if (tag !== 186) {
+            break;
+          }
+          message.requestsHash = B256.decode(reader, reader.uint32());
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -1069,7 +1208,8 @@ const BlockHeader$1 = {
       totalDifficulty: isSet$1(object.totalDifficulty) ? U256.fromJSON(object.totalDifficulty) : void 0,
       blobGasUsed: isSet$1(object.blobGasUsed) ? U128.fromJSON(object.blobGasUsed) : void 0,
       excessBlobGas: isSet$1(object.excessBlobGas) ? U128.fromJSON(object.excessBlobGas) : void 0,
-      parentBeaconBlockRoot: isSet$1(object.parentBeaconBlockRoot) ? B256.fromJSON(object.parentBeaconBlockRoot) : void 0
+      parentBeaconBlockRoot: isSet$1(object.parentBeaconBlockRoot) ? B256.fromJSON(object.parentBeaconBlockRoot) : void 0,
+      requestsHash: isSet$1(object.requestsHash) ? B256.fromJSON(object.requestsHash) : void 0
     };
   },
   toJSON(message) {
@@ -1140,6 +1280,9 @@ const BlockHeader$1 = {
     if (message.parentBeaconBlockRoot !== void 0) {
       obj.parentBeaconBlockRoot = B256.toJSON(message.parentBeaconBlockRoot);
     }
+    if (message.requestsHash !== void 0) {
+      obj.requestsHash = B256.toJSON(message.requestsHash);
+    }
     return obj;
   },
   create(base) {
@@ -1169,6 +1312,7 @@ const BlockHeader$1 = {
     message.blobGasUsed = object.blobGasUsed !== void 0 && object.blobGasUsed !== null ? U128.fromPartial(object.blobGasUsed) : void 0;
     message.excessBlobGas = object.excessBlobGas !== void 0 && object.excessBlobGas !== null ? U128.fromPartial(object.excessBlobGas) : void 0;
     message.parentBeaconBlockRoot = object.parentBeaconBlockRoot !== void 0 && object.parentBeaconBlockRoot !== null ? B256.fromPartial(object.parentBeaconBlockRoot) : void 0;
+    message.requestsHash = object.requestsHash !== void 0 && object.requestsHash !== null ? B256.fromPartial(object.requestsHash) : void 0;
     return message;
   }
 };
@@ -2278,80 +2422,949 @@ const AccessListItem$1 = {
     return message;
   }
 };
-function bytesFromBase64(b64) {
-  if (globalThis.Buffer) {
-    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
-  } else {
-    const bin = globalThis.atob(b64);
-    const arr = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; ++i) {
-      arr[i] = bin.charCodeAt(i);
-    }
-    return arr;
-  }
-}
-function base64FromBytes(arr) {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(arr).toString("base64");
-  } else {
-    const bin = [];
-    arr.forEach((byte) => {
-      bin.push(globalThis.String.fromCharCode(byte));
-    });
-    return globalThis.btoa(bin.join(""));
-  }
-}
-function toTimestamp(date) {
-  const seconds = BigInt(Math.trunc(date.getTime() / 1e3));
-  const nanos = date.getTime() % 1e3 * 1e6;
-  return { seconds, nanos };
-}
-function fromTimestamp(t) {
-  let millis = (globalThis.Number(t.seconds?.toString()) || 0) * 1e3;
-  millis += (t.nanos || 0) / 1e6;
-  return new globalThis.Date(millis);
+function createBaseTransactionTrace() {
+  return { filterIds: [], transactionIndex: 0, transactionHash: void 0, traces: [] };
 }
-function fromJsonTimestamp(o) {
-  if (o instanceof globalThis.Date) {
-    return o;
-  } else if (typeof o === "string") {
-    return new globalThis.Date(o);
-  } else {
-    return fromTimestamp(Timestamp.fromJSON(o));
+const TransactionTrace$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.filterIds !== void 0 && message.filterIds.length !== 0) {
+      writer.uint32(10).fork();
+      for (const v of message.filterIds) {
+        writer.uint32(v);
+      }
+      writer.ldelim();
+    }
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== 0) {
+      writer.uint32(16).uint32(message.transactionIndex);
+    }
+    if (message.transactionHash !== void 0) {
+      B256.encode(message.transactionHash, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.traces !== void 0 && message.traces.length !== 0) {
+      for (const v of message.traces) {
+        Trace$1.encode(v, writer.uint32(34).fork()).ldelim();
+      }
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTransactionTrace();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag === 8) {
+            message.filterIds.push(reader.uint32());
+            continue;
+          }
+          if (tag === 10) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.filterIds.push(reader.uint32());
+            }
+            continue;
+          }
+          break;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.transactionIndex = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.transactionHash = B256.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.traces.push(Trace$1.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      filterIds: globalThis.Array.isArray(object?.filterIds) ? object.filterIds.map((e) => globalThis.Number(e)) : [],
+      transactionIndex: isSet$1(object.transactionIndex) ? globalThis.Number(object.transactionIndex) : 0,
+      transactionHash: isSet$1(object.transactionHash) ? B256.fromJSON(object.transactionHash) : void 0,
+      traces: globalThis.Array.isArray(object?.traces) ? object.traces.map((e) => Trace$1.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.filterIds?.length) {
+      obj.filterIds = message.filterIds.map((e) => Math.round(e));
+    }
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== 0) {
+      obj.transactionIndex = Math.round(message.transactionIndex);
+    }
+    if (message.transactionHash !== void 0) {
+      obj.transactionHash = B256.toJSON(message.transactionHash);
+    }
+    if (message.traces?.length) {
+      obj.traces = message.traces.map((e) => Trace$1.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return TransactionTrace$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTransactionTrace();
+    message.filterIds = object.filterIds?.map((e) => e) || [];
+    message.transactionIndex = object.transactionIndex ?? 0;
+    message.transactionHash = object.transactionHash !== void 0 && object.transactionHash !== null ? B256.fromPartial(object.transactionHash) : void 0;
+    message.traces = object.traces?.map((e) => Trace$1.fromPartial(e)) || [];
+    return message;
   }
-}
-function longToBigint(long) {
-  return BigInt(long.toString());
-}
-if (_m0__default.util.Long !== Long__default) {
-  _m0__default.util.Long = Long__default;
-  _m0__default.configure();
-}
-function isSet$1(value) {
-  return value !== null && value !== void 0;
-}
-
-const data = {
-  __proto__: null,
-  AccessListItem: AccessListItem$1,
-  Block: Block$1,
-  BlockHeader: BlockHeader$1,
-  Log: Log$1,
-  Signature: Signature$1,
-  Transaction: Transaction$1,
-  TransactionReceipt: TransactionReceipt$1,
-  TransactionStatus: TransactionStatus$1,
-  Withdrawal: Withdrawal$1,
-  protobufPackage: protobufPackage$1,
-  transactionStatusFromJSON: transactionStatusFromJSON,
-  transactionStatusToJSON: transactionStatusToJSON
 };
-
-const protobufPackage = "evm.v2";
-var HeaderFilter$1 = /* @__PURE__ */ ((HeaderFilter2) => {
-  HeaderFilter2[HeaderFilter2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
-  HeaderFilter2[HeaderFilter2["ALWAYS"] = 1] = "ALWAYS";
-  HeaderFilter2[HeaderFilter2["ON_DATA"] = 2] = "ON_DATA";
+function createBaseTrace() {
+  return { action: void 0, error: void 0, output: void 0, subtraces: 0, traceAddress: [] };
+}
+const Trace$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    switch (message.action?.$case) {
+      case "call":
+        CallAction$1.encode(message.action.call, writer.uint32(10).fork()).ldelim();
+        break;
+      case "create":
+        CreateAction$1.encode(message.action.create, writer.uint32(18).fork()).ldelim();
+        break;
+      case "selfDestruct":
+        SelfDestructAction$1.encode(message.action.selfDestruct, writer.uint32(26).fork()).ldelim();
+        break;
+      case "reward":
+        RewardAction$1.encode(message.action.reward, writer.uint32(34).fork()).ldelim();
+        break;
+    }
+    if (message.error !== void 0) {
+      writer.uint32(42).string(message.error);
+    }
+    switch (message.output?.$case) {
+      case "callOutput":
+        CallOutput$1.encode(message.output.callOutput, writer.uint32(50).fork()).ldelim();
+        break;
+      case "createOutput":
+        CreateOutput$1.encode(message.output.createOutput, writer.uint32(58).fork()).ldelim();
+        break;
+    }
+    if (message.subtraces !== void 0 && message.subtraces !== 0) {
+      writer.uint32(64).uint32(message.subtraces);
+    }
+    if (message.traceAddress !== void 0 && message.traceAddress.length !== 0) {
+      writer.uint32(74).fork();
+      for (const v of message.traceAddress) {
+        writer.uint32(v);
+      }
+      writer.ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTrace();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.action = { $case: "call", call: CallAction$1.decode(reader, reader.uint32()) };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.action = { $case: "create", create: CreateAction$1.decode(reader, reader.uint32()) };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.action = { $case: "selfDestruct", selfDestruct: SelfDestructAction$1.decode(reader, reader.uint32()) };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.action = { $case: "reward", reward: RewardAction$1.decode(reader, reader.uint32()) };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.error = reader.string();
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.output = { $case: "callOutput", callOutput: CallOutput$1.decode(reader, reader.uint32()) };
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+          message.output = { $case: "createOutput", createOutput: CreateOutput$1.decode(reader, reader.uint32()) };
+          continue;
+        case 8:
+          if (tag !== 64) {
+            break;
+          }
+          message.subtraces = reader.uint32();
+          continue;
+        case 9:
+          if (tag === 72) {
+            message.traceAddress.push(reader.uint32());
+            continue;
+          }
+          if (tag === 74) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.traceAddress.push(reader.uint32());
+            }
+            continue;
+          }
+          break;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      action: isSet$1(object.call) ? { $case: "call", call: CallAction$1.fromJSON(object.call) } : isSet$1(object.create) ? { $case: "create", create: CreateAction$1.fromJSON(object.create) } : isSet$1(object.selfDestruct) ? { $case: "selfDestruct", selfDestruct: SelfDestructAction$1.fromJSON(object.selfDestruct) } : isSet$1(object.reward) ? { $case: "reward", reward: RewardAction$1.fromJSON(object.reward) } : void 0,
+      error: isSet$1(object.error) ? globalThis.String(object.error) : void 0,
+      output: isSet$1(object.callOutput) ? { $case: "callOutput", callOutput: CallOutput$1.fromJSON(object.callOutput) } : isSet$1(object.createOutput) ? { $case: "createOutput", createOutput: CreateOutput$1.fromJSON(object.createOutput) } : void 0,
+      subtraces: isSet$1(object.subtraces) ? globalThis.Number(object.subtraces) : 0,
+      traceAddress: globalThis.Array.isArray(object?.traceAddress) ? object.traceAddress.map((e) => globalThis.Number(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.action?.$case === "call") {
+      obj.call = CallAction$1.toJSON(message.action.call);
+    }
+    if (message.action?.$case === "create") {
+      obj.create = CreateAction$1.toJSON(message.action.create);
+    }
+    if (message.action?.$case === "selfDestruct") {
+      obj.selfDestruct = SelfDestructAction$1.toJSON(message.action.selfDestruct);
+    }
+    if (message.action?.$case === "reward") {
+      obj.reward = RewardAction$1.toJSON(message.action.reward);
+    }
+    if (message.error !== void 0) {
+      obj.error = message.error;
+    }
+    if (message.output?.$case === "callOutput") {
+      obj.callOutput = CallOutput$1.toJSON(message.output.callOutput);
+    }
+    if (message.output?.$case === "createOutput") {
+      obj.createOutput = CreateOutput$1.toJSON(message.output.createOutput);
+    }
+    if (message.subtraces !== void 0 && message.subtraces !== 0) {
+      obj.subtraces = Math.round(message.subtraces);
+    }
+    if (message.traceAddress?.length) {
+      obj.traceAddress = message.traceAddress.map((e) => Math.round(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return Trace$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTrace();
+    if (object.action?.$case === "call" && object.action?.call !== void 0 && object.action?.call !== null) {
+      message.action = { $case: "call", call: CallAction$1.fromPartial(object.action.call) };
+    }
+    if (object.action?.$case === "create" && object.action?.create !== void 0 && object.action?.create !== null) {
+      message.action = { $case: "create", create: CreateAction$1.fromPartial(object.action.create) };
+    }
+    if (object.action?.$case === "selfDestruct" && object.action?.selfDestruct !== void 0 && object.action?.selfDestruct !== null) {
+      message.action = {
+        $case: "selfDestruct",
+        selfDestruct: SelfDestructAction$1.fromPartial(object.action.selfDestruct)
+      };
+    }
+    if (object.action?.$case === "reward" && object.action?.reward !== void 0 && object.action?.reward !== null) {
+      message.action = { $case: "reward", reward: RewardAction$1.fromPartial(object.action.reward) };
+    }
+    message.error = object.error ?? void 0;
+    if (object.output?.$case === "callOutput" && object.output?.callOutput !== void 0 && object.output?.callOutput !== null) {
+      message.output = { $case: "callOutput", callOutput: CallOutput$1.fromPartial(object.output.callOutput) };
+    }
+    if (object.output?.$case === "createOutput" && object.output?.createOutput !== void 0 && object.output?.createOutput !== null) {
+      message.output = { $case: "createOutput", createOutput: CreateOutput$1.fromPartial(object.output.createOutput) };
+    }
+    message.subtraces = object.subtraces ?? 0;
+    message.traceAddress = object.traceAddress?.map((e) => e) || [];
+    return message;
+  }
+};
+function createBaseCallAction() {
+  return {
+    fromAddress: void 0,
+    type: 0,
+    gas: BigInt("0"),
+    input: new Uint8Array(0),
+    toAddress: void 0,
+    value: void 0
+  };
+}
+const CallAction$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.fromAddress !== void 0) {
+      Address.encode(message.fromAddress, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.type !== void 0 && message.type !== 0) {
+      writer.uint32(16).int32(message.type);
+    }
+    if (message.gas !== void 0 && message.gas !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.gas) !== message.gas) {
+        throw new globalThis.Error("value provided for field message.gas of type uint64 too large");
+      }
+      writer.uint32(24).uint64(message.gas.toString());
+    }
+    if (message.input !== void 0 && message.input.length !== 0) {
+      writer.uint32(34).bytes(message.input);
+    }
+    if (message.toAddress !== void 0) {
+      Address.encode(message.toAddress, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.value !== void 0) {
+      U256.encode(message.value, writer.uint32(50).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCallAction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.fromAddress = Address.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.type = reader.int32();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+          message.gas = longToBigint(reader.uint64());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.input = reader.bytes();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.toAddress = Address.decode(reader, reader.uint32());
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.value = U256.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      fromAddress: isSet$1(object.fromAddress) ? Address.fromJSON(object.fromAddress) : void 0,
+      type: isSet$1(object.type) ? callTypeFromJSON(object.type) : 0,
+      gas: isSet$1(object.gas) ? BigInt(object.gas) : BigInt("0"),
+      input: isSet$1(object.input) ? bytesFromBase64(object.input) : new Uint8Array(0),
+      toAddress: isSet$1(object.toAddress) ? Address.fromJSON(object.toAddress) : void 0,
+      value: isSet$1(object.value) ? U256.fromJSON(object.value) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.fromAddress !== void 0) {
+      obj.fromAddress = Address.toJSON(message.fromAddress);
+    }
+    if (message.type !== void 0 && message.type !== 0) {
+      obj.type = callTypeToJSON(message.type);
+    }
+    if (message.gas !== void 0 && message.gas !== BigInt("0")) {
+      obj.gas = message.gas.toString();
+    }
+    if (message.input !== void 0 && message.input.length !== 0) {
+      obj.input = base64FromBytes(message.input);
+    }
+    if (message.toAddress !== void 0) {
+      obj.toAddress = Address.toJSON(message.toAddress);
+    }
+    if (message.value !== void 0) {
+      obj.value = U256.toJSON(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return CallAction$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseCallAction();
+    message.fromAddress = object.fromAddress !== void 0 && object.fromAddress !== null ? Address.fromPartial(object.fromAddress) : void 0;
+    message.type = object.type ?? 0;
+    message.gas = object.gas ?? BigInt("0");
+    message.input = object.input ?? new Uint8Array(0);
+    message.toAddress = object.toAddress !== void 0 && object.toAddress !== null ? Address.fromPartial(object.toAddress) : void 0;
+    message.value = object.value !== void 0 && object.value !== null ? U256.fromPartial(object.value) : void 0;
+    return message;
+  }
+};
+function createBaseCreateAction() {
+  return { fromAddress: void 0, gas: BigInt("0"), init: new Uint8Array(0), value: void 0, creationMethod: 0 };
+}
+const CreateAction$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.fromAddress !== void 0) {
+      Address.encode(message.fromAddress, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.gas !== void 0 && message.gas !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.gas) !== message.gas) {
+        throw new globalThis.Error("value provided for field message.gas of type uint64 too large");
+      }
+      writer.uint32(16).uint64(message.gas.toString());
+    }
+    if (message.init !== void 0 && message.init.length !== 0) {
+      writer.uint32(26).bytes(message.init);
+    }
+    if (message.value !== void 0) {
+      U256.encode(message.value, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.creationMethod !== void 0 && message.creationMethod !== 0) {
+      writer.uint32(40).int32(message.creationMethod);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCreateAction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.fromAddress = Address.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.gas = longToBigint(reader.uint64());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.init = reader.bytes();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.value = U256.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+          message.creationMethod = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      fromAddress: isSet$1(object.fromAddress) ? Address.fromJSON(object.fromAddress) : void 0,
+      gas: isSet$1(object.gas) ? BigInt(object.gas) : BigInt("0"),
+      init: isSet$1(object.init) ? bytesFromBase64(object.init) : new Uint8Array(0),
+      value: isSet$1(object.value) ? U256.fromJSON(object.value) : void 0,
+      creationMethod: isSet$1(object.creationMethod) ? creationMethodFromJSON(object.creationMethod) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.fromAddress !== void 0) {
+      obj.fromAddress = Address.toJSON(message.fromAddress);
+    }
+    if (message.gas !== void 0 && message.gas !== BigInt("0")) {
+      obj.gas = message.gas.toString();
+    }
+    if (message.init !== void 0 && message.init.length !== 0) {
+      obj.init = base64FromBytes(message.init);
+    }
+    if (message.value !== void 0) {
+      obj.value = U256.toJSON(message.value);
+    }
+    if (message.creationMethod !== void 0 && message.creationMethod !== 0) {
+      obj.creationMethod = creationMethodToJSON(message.creationMethod);
+    }
+    return obj;
+  },
+  create(base) {
+    return CreateAction$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseCreateAction();
+    message.fromAddress = object.fromAddress !== void 0 && object.fromAddress !== null ? Address.fromPartial(object.fromAddress) : void 0;
+    message.gas = object.gas ?? BigInt("0");
+    message.init = object.init ?? new Uint8Array(0);
+    message.value = object.value !== void 0 && object.value !== null ? U256.fromPartial(object.value) : void 0;
+    message.creationMethod = object.creationMethod ?? 0;
+    return message;
+  }
+};
+function createBaseSelfDestructAction() {
+  return { address: void 0, balance: void 0, refundAddress: void 0 };
+}
+const SelfDestructAction$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.address !== void 0) {
+      Address.encode(message.address, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.balance !== void 0) {
+      U256.encode(message.balance, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.refundAddress !== void 0) {
+      Address.encode(message.refundAddress, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSelfDestructAction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.address = Address.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.balance = U256.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.refundAddress = Address.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      address: isSet$1(object.address) ? Address.fromJSON(object.address) : void 0,
+      balance: isSet$1(object.balance) ? U256.fromJSON(object.balance) : void 0,
+      refundAddress: isSet$1(object.refundAddress) ? Address.fromJSON(object.refundAddress) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.address !== void 0) {
+      obj.address = Address.toJSON(message.address);
+    }
+    if (message.balance !== void 0) {
+      obj.balance = U256.toJSON(message.balance);
+    }
+    if (message.refundAddress !== void 0) {
+      obj.refundAddress = Address.toJSON(message.refundAddress);
+    }
+    return obj;
+  },
+  create(base) {
+    return SelfDestructAction$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSelfDestructAction();
+    message.address = object.address !== void 0 && object.address !== null ? Address.fromPartial(object.address) : void 0;
+    message.balance = object.balance !== void 0 && object.balance !== null ? U256.fromPartial(object.balance) : void 0;
+    message.refundAddress = object.refundAddress !== void 0 && object.refundAddress !== null ? Address.fromPartial(object.refundAddress) : void 0;
+    return message;
+  }
+};
+function createBaseRewardAction() {
+  return { author: void 0, type: 0, value: void 0 };
+}
+const RewardAction$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.author !== void 0) {
+      Address.encode(message.author, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.type !== void 0 && message.type !== 0) {
+      writer.uint32(16).int32(message.type);
+    }
+    if (message.value !== void 0) {
+      U256.encode(message.value, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseRewardAction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.author = Address.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.type = reader.int32();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.value = U256.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      author: isSet$1(object.author) ? Address.fromJSON(object.author) : void 0,
+      type: isSet$1(object.type) ? rewardTypeFromJSON(object.type) : 0,
+      value: isSet$1(object.value) ? U256.fromJSON(object.value) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.author !== void 0) {
+      obj.author = Address.toJSON(message.author);
+    }
+    if (message.type !== void 0 && message.type !== 0) {
+      obj.type = rewardTypeToJSON(message.type);
+    }
+    if (message.value !== void 0) {
+      obj.value = U256.toJSON(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return RewardAction$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRewardAction();
+    message.author = object.author !== void 0 && object.author !== null ? Address.fromPartial(object.author) : void 0;
+    message.type = object.type ?? 0;
+    message.value = object.value !== void 0 && object.value !== null ? U256.fromPartial(object.value) : void 0;
+    return message;
+  }
+};
+function createBaseCallOutput() {
+  return { gasUsed: BigInt("0"), output: new Uint8Array(0) };
+}
+const CallOutput$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.gasUsed !== void 0 && message.gasUsed !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.gasUsed) !== message.gasUsed) {
+        throw new globalThis.Error("value provided for field message.gasUsed of type uint64 too large");
+      }
+      writer.uint32(8).uint64(message.gasUsed.toString());
+    }
+    if (message.output !== void 0 && message.output.length !== 0) {
+      writer.uint32(18).bytes(message.output);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCallOutput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+          message.gasUsed = longToBigint(reader.uint64());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.output = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      gasUsed: isSet$1(object.gasUsed) ? BigInt(object.gasUsed) : BigInt("0"),
+      output: isSet$1(object.output) ? bytesFromBase64(object.output) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.gasUsed !== void 0 && message.gasUsed !== BigInt("0")) {
+      obj.gasUsed = message.gasUsed.toString();
+    }
+    if (message.output !== void 0 && message.output.length !== 0) {
+      obj.output = base64FromBytes(message.output);
+    }
+    return obj;
+  },
+  create(base) {
+    return CallOutput$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseCallOutput();
+    message.gasUsed = object.gasUsed ?? BigInt("0");
+    message.output = object.output ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseCreateOutput() {
+  return { address: void 0, code: new Uint8Array(0), gasUsed: BigInt("0") };
+}
+const CreateOutput$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.address !== void 0) {
+      Address.encode(message.address, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.code !== void 0 && message.code.length !== 0) {
+      writer.uint32(18).bytes(message.code);
+    }
+    if (message.gasUsed !== void 0 && message.gasUsed !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.gasUsed) !== message.gasUsed) {
+        throw new globalThis.Error("value provided for field message.gasUsed of type uint64 too large");
+      }
+      writer.uint32(24).uint64(message.gasUsed.toString());
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCreateOutput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.address = Address.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.code = reader.bytes();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+          message.gasUsed = longToBigint(reader.uint64());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      address: isSet$1(object.address) ? Address.fromJSON(object.address) : void 0,
+      code: isSet$1(object.code) ? bytesFromBase64(object.code) : new Uint8Array(0),
+      gasUsed: isSet$1(object.gasUsed) ? BigInt(object.gasUsed) : BigInt("0")
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.address !== void 0) {
+      obj.address = Address.toJSON(message.address);
+    }
+    if (message.code !== void 0 && message.code.length !== 0) {
+      obj.code = base64FromBytes(message.code);
+    }
+    if (message.gasUsed !== void 0 && message.gasUsed !== BigInt("0")) {
+      obj.gasUsed = message.gasUsed.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return CreateOutput$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseCreateOutput();
+    message.address = object.address !== void 0 && object.address !== null ? Address.fromPartial(object.address) : void 0;
+    message.code = object.code ?? new Uint8Array(0);
+    message.gasUsed = object.gasUsed ?? BigInt("0");
+    return message;
+  }
+};
+function bytesFromBase64(b64) {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+function base64FromBytes(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+function toTimestamp(date) {
+  const seconds = BigInt(Math.trunc(date.getTime() / 1e3));
+  const nanos = date.getTime() % 1e3 * 1e6;
+  return { seconds, nanos };
+}
+function fromTimestamp(t) {
+  let millis = (globalThis.Number(t.seconds?.toString()) || 0) * 1e3;
+  millis += (t.nanos || 0) / 1e6;
+  return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+  if (o instanceof globalThis.Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new globalThis.Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
+  }
+}
+function longToBigint(long) {
+  return BigInt(long.toString());
+}
+if (_m0__default.util.Long !== Long__default) {
+  _m0__default.util.Long = Long__default;
+  _m0__default.configure();
+}
+function isSet$1(value) {
+  return value !== null && value !== void 0;
+}
+
+const data = {
+  __proto__: null,
+  AccessListItem: AccessListItem$1,
+  Block: Block$1,
+  BlockHeader: BlockHeader$1,
+  CallAction: CallAction$1,
+  CallOutput: CallOutput$1,
+  CallType: CallType$1,
+  CreateAction: CreateAction$1,
+  CreateOutput: CreateOutput$1,
+  CreationMethod: CreationMethod$1,
+  Log: Log$1,
+  RewardAction: RewardAction$1,
+  RewardType: RewardType$1,
+  SelfDestructAction: SelfDestructAction$1,
+  Signature: Signature$1,
+  Trace: Trace$1,
+  Transaction: Transaction$1,
+  TransactionReceipt: TransactionReceipt$1,
+  TransactionStatus: TransactionStatus$1,
+  TransactionTrace: TransactionTrace$1,
+  Withdrawal: Withdrawal$1,
+  callTypeFromJSON: callTypeFromJSON,
+  callTypeToJSON: callTypeToJSON,
+  creationMethodFromJSON: creationMethodFromJSON,
+  creationMethodToJSON: creationMethodToJSON,
+  protobufPackage: protobufPackage$1,
+  rewardTypeFromJSON: rewardTypeFromJSON,
+  rewardTypeToJSON: rewardTypeToJSON,
+  transactionStatusFromJSON: transactionStatusFromJSON,
+  transactionStatusToJSON: transactionStatusToJSON
+};
+
+const protobufPackage = "evm.v2";
+var HeaderFilter$1 = /* @__PURE__ */ ((HeaderFilter2) => {
+  HeaderFilter2[HeaderFilter2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  HeaderFilter2[HeaderFilter2["ALWAYS"] = 1] = "ALWAYS";
+  HeaderFilter2[HeaderFilter2["ON_DATA"] = 2] = "ON_DATA";
   HeaderFilter2[HeaderFilter2["ON_DATA_OR_ON_NEW_BLOCK"] = 3] = "ON_DATA_OR_ON_NEW_BLOCK";
   HeaderFilter2[HeaderFilter2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
   return HeaderFilter2;
@@ -2622,7 +3635,8 @@ function createBaseTransactionFilter() {
     create: void 0,
     transactionStatus: void 0,
     includeReceipt: void 0,
-    includeLogs: void 0
+    includeLogs: void 0,
+    includeTransactionTrace: void 0
   };
 }
 const TransactionFilter$1 = {
@@ -2648,6 +3662,9 @@ const TransactionFilter$1 = {
     if (message.includeLogs !== void 0) {
       writer.uint32(56).bool(message.includeLogs);
     }
+    if (message.includeTransactionTrace !== void 0) {
+      writer.uint32(64).bool(message.includeTransactionTrace);
+    }
     return writer;
   },
   decode(input, length) {
@@ -2699,6 +3716,12 @@ const TransactionFilter$1 = {
           }
           message.includeLogs = reader.bool();
           continue;
+        case 8:
+          if (tag !== 64) {
+            break;
+          }
+          message.includeTransactionTrace = reader.bool();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -2715,7 +3738,8 @@ const TransactionFilter$1 = {
       create: isSet(object.create) ? globalThis.Boolean(object.create) : void 0,
       transactionStatus: isSet(object.transactionStatus) ? transactionStatusFilterFromJSON(object.transactionStatus) : void 0,
       includeReceipt: isSet(object.includeReceipt) ? globalThis.Boolean(object.includeReceipt) : void 0,
-      includeLogs: isSet(object.includeLogs) ? globalThis.Boolean(object.includeLogs) : void 0
+      includeLogs: isSet(object.includeLogs) ? globalThis.Boolean(object.includeLogs) : void 0,
+      includeTransactionTrace: isSet(object.includeTransactionTrace) ? globalThis.Boolean(object.includeTransactionTrace) : void 0
     };
   },
   toJSON(message) {
@@ -2741,6 +3765,9 @@ const TransactionFilter$1 = {
     if (message.includeLogs !== void 0) {
       obj.includeLogs = message.includeLogs;
     }
+    if (message.includeTransactionTrace !== void 0) {
+      obj.includeTransactionTrace = message.includeTransactionTrace;
+    }
     return obj;
   },
   create(base) {
@@ -2755,6 +3782,7 @@ const TransactionFilter$1 = {
     message.transactionStatus = object.transactionStatus ?? void 0;
     message.includeReceipt = object.includeReceipt ?? void 0;
     message.includeLogs = object.includeLogs ?? void 0;
+    message.includeTransactionTrace = object.includeTransactionTrace ?? void 0;
     return message;
   }
 };
@@ -2767,7 +3795,8 @@ function createBaseLogFilter() {
     transactionStatus: void 0,
     includeTransaction: void 0,
     includeReceipt: void 0,
-    includeSiblings: void 0
+    includeSiblings: void 0,
+    includeTransactionTrace: void 0
   };
 }
 const LogFilter$1 = {
@@ -2798,6 +3827,9 @@ const LogFilter$1 = {
     if (message.includeSiblings !== void 0) {
       writer.uint32(64).bool(message.includeSiblings);
     }
+    if (message.includeTransactionTrace !== void 0) {
+      writer.uint32(72).bool(message.includeTransactionTrace);
+    }
     return writer;
   },
   decode(input, length) {
@@ -2855,6 +3887,12 @@ const LogFilter$1 = {
           }
           message.includeSiblings = reader.bool();
           continue;
+        case 9:
+          if (tag !== 72) {
+            break;
+          }
+          message.includeTransactionTrace = reader.bool();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -2872,7 +3910,8 @@ const LogFilter$1 = {
       transactionStatus: isSet(object.transactionStatus) ? transactionStatusFilterFromJSON(object.transactionStatus) : void 0,
       includeTransaction: isSet(object.includeTransaction) ? globalThis.Boolean(object.includeTransaction) : void 0,
       includeReceipt: isSet(object.includeReceipt) ? globalThis.Boolean(object.includeReceipt) : void 0,
-      includeSiblings: isSet(object.includeSiblings) ? globalThis.Boolean(object.includeSiblings) : void 0
+      includeSiblings: isSet(object.includeSiblings) ? globalThis.Boolean(object.includeSiblings) : void 0,
+      includeTransactionTrace: isSet(object.includeTransactionTrace) ? globalThis.Boolean(object.includeTransactionTrace) : void 0
     };
   },
   toJSON(message) {
@@ -2901,6 +3940,9 @@ const LogFilter$1 = {
     if (message.includeSiblings !== void 0) {
       obj.includeSiblings = message.includeSiblings;
     }
+    if (message.includeTransactionTrace !== void 0) {
+      obj.includeTransactionTrace = message.includeTransactionTrace;
+    }
     return obj;
   },
   create(base) {
@@ -2916,6 +3958,7 @@ const LogFilter$1 = {
     message.includeTransaction = object.includeTransaction ?? void 0;
     message.includeReceipt = object.includeReceipt ?? void 0;
     message.includeSiblings = object.includeSiblings ?? void 0;
+    message.includeTransactionTrace = object.includeTransactionTrace ?? void 0;
     return message;
   }
 };
@@ -2996,277 +4039,368 @@ const index = {
   filter: filter
 };
 
-const Bloom = schema.Schema.transform(
-  schema.Schema.Struct({
-    value: protocol.BytesFromUint8Array
-  }),
-  protocol.Bytes,
-  {
-    strict: false,
-    encode(value) {
-      throw new Error("Not implemented");
-    },
-    decode({ value }) {
-      return value;
-    }
+const Bloom = {
+  encode(x) {
+    return { value: protocol.BytesFromUint8Array.encode(x) };
+  },
+  decode({ value }) {
+    return protocol.BytesFromUint8Array.decode(value);
   }
-);
-const TransactionStatus = schema.Schema.transform(
-  schema.Schema.Enums(TransactionStatus$1),
-  schema.Schema.Literal("unknown", "succeeded", "reverted"),
-  {
-    decode(value) {
-      const enumMap = {
-        [TransactionStatus$1.SUCCEEDED]: "succeeded",
-        [TransactionStatus$1.REVERTED]: "reverted",
-        [TransactionStatus$1.UNSPECIFIED]: "unknown",
-        [TransactionStatus$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+};
+const TransactionStatus = {
+  encode(x) {
+    const enumMap = {
+      unknown: TransactionStatus$1.UNSPECIFIED,
+      succeeded: TransactionStatus$1.SUCCEEDED,
+      reverted: TransactionStatus$1.REVERTED
+    };
+    return enumMap[x] ?? TransactionStatus$1.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [TransactionStatus$1.SUCCEEDED]: "succeeded",
+      [TransactionStatus$1.REVERTED]: "reverted",
+      [TransactionStatus$1.UNSPECIFIED]: "unknown",
+      [TransactionStatus$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const BlockHeader = schema.Schema.Struct({
-  blockNumber: schema.Schema.BigIntFromSelf,
-  blockHash: B256$1,
-  parentBlockHash: B256$1,
-  unclesHash: B256$1,
-  miner: Address$1,
-  stateRoot: B256$1,
-  transactionsRoot: B256$1,
-  receiptsRoot: B256$1,
-  logsBloom: Bloom,
-  difficulty: U256$1,
-  gasLimit: U128$1,
-  gasUsed: U128$1,
-  timestamp: schema.Schema.DateFromSelf,
-  extraData: protocol.BytesFromUint8Array,
-  mixHash: schema.Schema.optional(B256$1),
-  nonce: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  baseFeePerGas: schema.Schema.optional(U128$1),
-  withdrawalsRoot: schema.Schema.optional(B256$1),
-  totalDifficulty: schema.Schema.optional(U256$1),
-  blobGasUsed: schema.Schema.optional(U128$1),
-  excessBlobGas: schema.Schema.optional(U128$1),
-  parentBeaconBlockRoot: schema.Schema.optional(B256$1)
+};
+const BlockHeader = codec.MessageCodec({
+  blockNumber: codec.RequiredCodec(codec.BigIntCodec),
+  blockHash: codec.OptionalCodec(B256$1),
+  parentBlockHash: codec.RequiredCodec(B256$1),
+  unclesHash: codec.RequiredCodec(B256$1),
+  miner: codec.RequiredCodec(Address$1),
+  stateRoot: codec.RequiredCodec(B256$1),
+  transactionsRoot: codec.RequiredCodec(B256$1),
+  receiptsRoot: codec.RequiredCodec(B256$1),
+  logsBloom: codec.RequiredCodec(Bloom),
+  difficulty: codec.RequiredCodec(U256$1),
+  gasLimit: codec.RequiredCodec(U128$1),
+  gasUsed: codec.RequiredCodec(U128$1),
+  timestamp: codec.RequiredCodec(codec.DateCodec),
+  extraData: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  mixHash: codec.OptionalCodec(B256$1),
+  nonce: codec.OptionalCodec(codec.BigIntCodec),
+  baseFeePerGas: codec.OptionalCodec(U128$1),
+  withdrawalsRoot: codec.OptionalCodec(B256$1),
+  totalDifficulty: codec.OptionalCodec(U256$1),
+  blobGasUsed: codec.OptionalCodec(U128$1),
+  excessBlobGas: codec.OptionalCodec(U128$1),
+  parentBeaconBlockRoot: codec.OptionalCodec(B256$1),
+  requestsHash: codec.OptionalCodec(B256$1)
+});
+const Withdrawal = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  withdrawalIndex: codec.RequiredCodec(codec.NumberCodec),
+  index: codec.RequiredCodec(codec.BigIntCodec),
+  validatorIndex: codec.RequiredCodec(codec.NumberCodec),
+  address: codec.RequiredCodec(Address$1),
+  amount: codec.RequiredCodec(codec.BigIntCodec)
 });
-const Withdrawal = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  withdrawalIndex: schema.Schema.Number,
-  index: schema.Schema.BigIntFromSelf,
-  validatorIndex: schema.Schema.Number,
-  address: Address$1,
-  amount: schema.Schema.BigIntFromSelf
+const AccessListItem = codec.MessageCodec({
+  address: codec.RequiredCodec(Address$1),
+  storageKeys: codec.ArrayCodec(B256$1)
 });
-const AccessListItem = schema.Schema.Struct({
-  address: Address$1,
-  storageKeys: schema.Schema.Array(B256$1)
+const Signature = codec.MessageCodec({
+  r: codec.RequiredCodec(U256$1),
+  s: codec.RequiredCodec(U256$1),
+  v: codec.OptionalCodec(U256$1),
+  YParity: codec.OptionalCodec(codec.BooleanCodec)
 });
-const Signature = schema.Schema.Struct({
-  r: U256$1,
-  s: U256$1,
-  v: U256$1,
-  YParity: schema.Schema.optional(schema.Schema.Boolean)
+const Transaction = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(B256$1),
+  nonce: codec.RequiredCodec(codec.BigIntCodec),
+  from: codec.RequiredCodec(Address$1),
+  to: codec.OptionalCodec(Address$1),
+  value: codec.RequiredCodec(U256$1),
+  gasPrice: codec.OptionalCodec(U128$1),
+  gas: codec.RequiredCodec(U128$1),
+  maxFeePerGas: codec.OptionalCodec(U128$1),
+  maxPriorityFeePerGas: codec.OptionalCodec(U128$1),
+  input: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  signature: codec.OptionalCodec(Signature),
+  chainId: codec.OptionalCodec(codec.BigIntCodec),
+  accessList: codec.ArrayCodec(AccessListItem),
+  transactionType: codec.RequiredCodec(codec.BigIntCodec),
+  maxFeePerBlobGas: codec.OptionalCodec(U128$1),
+  blobVersionedHashes: codec.ArrayCodec(B256$1),
+  transactionStatus: codec.RequiredCodec(TransactionStatus)
 });
-const Transaction = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  transactionIndex: schema.Schema.Number,
-  transactionHash: B256$1,
-  nonce: schema.Schema.BigIntFromSelf,
-  from: Address$1,
-  to: schema.Schema.optional(Address$1),
-  value: U256$1,
-  gasPrice: schema.Schema.optional(U128$1),
-  gas: U128$1,
-  maxFeePerGas: schema.Schema.optional(U128$1),
-  maxPriorityFeePerGas: schema.Schema.optional(U128$1),
-  input: protocol.BytesFromUint8Array,
-  signature: schema.Schema.optional(Signature),
-  chainId: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  accessList: schema.Schema.Array(AccessListItem),
-  transactionType: schema.Schema.BigIntFromSelf,
-  maxFeePerBlobGas: schema.Schema.optional(U128$1),
-  blobVersionedHashes: schema.Schema.Array(B256$1),
-  transactionStatus: TransactionStatus
+const TransactionReceipt = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(B256$1),
+  cumulativeGasUsed: codec.RequiredCodec(U128$1),
+  gasUsed: codec.RequiredCodec(U128$1),
+  effectiveGasPrice: codec.RequiredCodec(U128$1),
+  from: codec.RequiredCodec(Address$1),
+  to: codec.OptionalCodec(Address$1),
+  contractAddress: codec.OptionalCodec(Address$1),
+  logsBloom: codec.RequiredCodec(Bloom),
+  transactionType: codec.RequiredCodec(codec.BigIntCodec),
+  blobGasUsed: codec.OptionalCodec(U128$1),
+  blobGasPrice: codec.OptionalCodec(U128$1),
+  transactionStatus: codec.RequiredCodec(TransactionStatus)
 });
-const TransactionReceipt = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  transactionIndex: schema.Schema.Number,
-  transactionHash: B256$1,
-  cumulativeGasUsed: U128$1,
-  gasUsed: U128$1,
-  effectiveGasPrice: U128$1,
-  from: Address$1,
-  to: schema.Schema.optional(Address$1),
-  contractAddress: schema.Schema.optional(Address$1),
-  logsBloom: Bloom,
-  transactionType: schema.Schema.BigIntFromSelf,
-  blobGasUsed: schema.Schema.optional(U128$1),
-  blobGasPrice: schema.Schema.optional(U128$1),
-  transactionStatus: TransactionStatus
+const Log = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  address: codec.RequiredCodec(Address$1),
+  topics: codec.ArrayCodec(B256$1),
+  data: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  logIndex: codec.RequiredCodec(codec.NumberCodec),
+  logIndexInTransaction: codec.RequiredCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(B256$1),
+  transactionStatus: codec.RequiredCodec(TransactionStatus)
 });
-const Log = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  address: Address$1,
-  topics: schema.Schema.Array(B256$1),
-  data: protocol.BytesFromUint8Array,
-  logIndex: schema.Schema.Number,
-  logIndexInTransaction: schema.Schema.Number,
-  transactionIndex: schema.Schema.Number,
-  transactionHash: B256$1,
-  transactionStatus: TransactionStatus
+const CallType = {
+  encode(x) {
+    const enumMap = {
+      unknown: CallType$1.UNSPECIFIED,
+      call: CallType$1.CALL,
+      callCode: CallType$1.CALL_CODE,
+      delegateCall: CallType$1.DELEGATE_CALL,
+      staticCall: CallType$1.STATIC_CALL,
+      authCall: CallType$1.AUTH_CALL
+    };
+    return enumMap[x] ?? CallType$1.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [CallType$1.CALL]: "call",
+      [CallType$1.CALL_CODE]: "callCode",
+      [CallType$1.DELEGATE_CALL]: "delegateCall",
+      [CallType$1.STATIC_CALL]: "staticCall",
+      [CallType$1.AUTH_CALL]: "authCall",
+      [CallType$1.UNSPECIFIED]: "unknown",
+      [CallType$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
+  }
+};
+const CreationMethod = {
+  encode(x) {
+    const enumMap = {
+      unknown: CreationMethod$1.UNSPECIFIED,
+      create: CreationMethod$1.CREATE,
+      create2: CreationMethod$1.CREATE2,
+      eofCreate: CreationMethod$1.EOF_CREATE
+    };
+    return enumMap[x] ?? CreationMethod$1.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [CreationMethod$1.CREATE]: "create",
+      [CreationMethod$1.CREATE2]: "create2",
+      [CreationMethod$1.EOF_CREATE]: "eofCreate",
+      [CreationMethod$1.UNSPECIFIED]: "unknown",
+      [CreationMethod$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
+  }
+};
+const CallAction = codec.MessageCodec({
+  fromAddress: codec.RequiredCodec(Address$1),
+  type: codec.RequiredCodec(CallType),
+  gas: codec.RequiredCodec(codec.BigIntCodec),
+  input: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  toAddress: codec.RequiredCodec(Address$1),
+  value: codec.RequiredCodec(U256$1)
 });
-const Block = schema.Schema.Struct({
-  header: BlockHeader,
-  withdrawals: schema.Schema.Array(Withdrawal),
-  transactions: schema.Schema.Array(Transaction),
-  receipts: schema.Schema.Array(TransactionReceipt),
-  logs: schema.Schema.Array(Log)
+const CreateAction = codec.MessageCodec({
+  fromAddress: codec.RequiredCodec(Address$1),
+  gas: codec.RequiredCodec(codec.BigIntCodec),
+  init: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  value: codec.RequiredCodec(U256$1),
+  creationMethod: codec.RequiredCodec(CreationMethod)
 });
-const BlockFromBytes = schema.Schema.transform(
-  schema.Schema.Uint8ArrayFromSelf,
-  schema.Schema.NullOr(Block),
-  {
-    strict: false,
-    decode(value) {
-      if (value.length === 0) {
-        return null;
-      }
-      return Block$1.decode(value);
-    },
-    encode(value) {
-      if (value === null) {
-        return new Uint8Array();
-      }
-      return Block$1.encode(value).finish();
-    }
+const SelfDestructAction = codec.MessageCodec({
+  address: codec.RequiredCodec(Address$1),
+  balance: codec.RequiredCodec(U256$1),
+  refundAddress: codec.RequiredCodec(Address$1)
+});
+const RewardType = {
+  encode(x) {
+    const enumMap = {
+      unknown: RewardType$1.UNSPECIFIED,
+      block: RewardType$1.BLOCK,
+      uncle: RewardType$1.UNCLE
+    };
+    return enumMap[x] ?? RewardType$1.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [RewardType$1.BLOCK]: "block",
+      [RewardType$1.UNCLE]: "uncle",
+      [RewardType$1.UNSPECIFIED]: "unknown",
+      [RewardType$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
+};
+const RewardAction = codec.MessageCodec({
+  author: codec.RequiredCodec(Address$1),
+  type: codec.RequiredCodec(RewardType),
+  value: codec.RequiredCodec(U256$1)
+});
+const CallOutput = codec.MessageCodec({
+  gasUsed: codec.RequiredCodec(codec.BigIntCodec),
+  output: codec.RequiredCodec(protocol.BytesFromUint8Array)
+});
+const CreateOutput = codec.MessageCodec({
+  address: codec.RequiredCodec(Address$1),
+  code: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  gasUsed: codec.RequiredCodec(codec.BigIntCodec)
+});
+const Trace = codec.MessageCodec({
+  action: codec.RequiredCodec(
+    codec.OneOfCodec({
+      call: CallAction,
+      create: CreateAction,
+      selfDestruct: SelfDestructAction,
+      reward: RewardAction
+    })
+  ),
+  error: codec.OptionalCodec(codec.StringCodec),
+  output: codec.OptionalCodec(
+    codec.OneOfCodec({
+      callOutput: CallOutput,
+      createOutput: CreateOutput
+    })
+  ),
+  subtraces: codec.RequiredCodec(codec.NumberCodec),
+  traceAddress: codec.ArrayCodec(codec.NumberCodec)
+});
+const TransactionTrace = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(B256$1),
+  traces: codec.ArrayCodec(Trace)
+});
+const Block = codec.MessageCodec({
+  header: codec.RequiredCodec(BlockHeader),
+  withdrawals: codec.ArrayCodec(Withdrawal),
+  transactions: codec.ArrayCodec(Transaction),
+  receipts: codec.ArrayCodec(TransactionReceipt),
+  logs: codec.ArrayCodec(Log),
+  traces: codec.ArrayCodec(TransactionTrace)
+});
+const BlockFromBytes = {
+  encode(x) {
+    const block = Block.encode(x);
+    return Block$1.encode(block).finish();
+  },
+  decode(p) {
+    const block = Block$1.decode(p);
+    return Block.decode(block);
+  }
+};
 
-const OptionalArray = (schema$1) => schema.Schema.optional(schema.Schema.Array(schema$1));
-const HeaderFilter = schema.Schema.transform(
-  schema.Schema.Enums(HeaderFilter$1),
-  schema.Schema.Literal("always", "on_data", "on_data_or_on_new_block", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [HeaderFilter$1.ALWAYS]: "always",
-        [HeaderFilter$1.ON_DATA]: "on_data",
-        [HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK]: "on_data_or_on_new_block",
-        [HeaderFilter$1.UNSPECIFIED]: "unknown",
-        [HeaderFilter$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "always":
-          return HeaderFilter$1.ALWAYS;
-        case "on_data":
-          return HeaderFilter$1.ON_DATA;
-        case "on_data_or_on_new_block":
-          return HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK;
-        default:
-          return HeaderFilter$1.UNSPECIFIED;
-      }
+const HeaderFilter = {
+  encode(x) {
+    switch (x) {
+      case "always":
+        return HeaderFilter$1.ALWAYS;
+      case "on_data":
+        return HeaderFilter$1.ON_DATA;
+      case "on_data_or_on_new_block":
+        return HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK;
+      default:
+        return HeaderFilter$1.UNSPECIFIED;
     }
+  },
+  decode(p) {
+    const enumMap = {
+      [HeaderFilter$1.ALWAYS]: "always",
+      [HeaderFilter$1.ON_DATA]: "on_data",
+      [HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK]: "on_data_or_on_new_block",
+      [HeaderFilter$1.UNSPECIFIED]: "unknown",
+      [HeaderFilter$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const WithdrawalFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  validatorIndex: schema.Schema.optional(schema.Schema.Number),
-  address: schema.Schema.optional(Address$1)
+};
+const WithdrawalFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  validatorIndex: codec.OptionalCodec(codec.NumberCodec),
+  address: codec.OptionalCodec(Address$1)
 });
-const TransactionStatusFilter = schema.Schema.transform(
-  schema.Schema.Enums(TransactionStatusFilter$1),
-  schema.Schema.Literal("succeeded", "reverted", "all", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [TransactionStatusFilter$1.SUCCEEDED]: "succeeded",
-        [TransactionStatusFilter$1.REVERTED]: "reverted",
-        [TransactionStatusFilter$1.ALL]: "all",
-        [TransactionStatusFilter$1.UNSPECIFIED]: "unknown",
-        [TransactionStatusFilter$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "succeeded":
-          return TransactionStatusFilter$1.SUCCEEDED;
-        case "reverted":
-          return TransactionStatusFilter$1.REVERTED;
-        case "all":
-          return TransactionStatusFilter$1.ALL;
-        default:
-          return TransactionStatusFilter$1.UNSPECIFIED;
-      }
+const TransactionStatusFilter = {
+  decode(value) {
+    const enumMap = {
+      [TransactionStatusFilter$1.SUCCEEDED]: "succeeded",
+      [TransactionStatusFilter$1.REVERTED]: "reverted",
+      [TransactionStatusFilter$1.ALL]: "all",
+      [TransactionStatusFilter$1.UNSPECIFIED]: "unknown",
+      [TransactionStatusFilter$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[value] ?? "unknown";
+  },
+  encode(value) {
+    switch (value) {
+      case "succeeded":
+        return TransactionStatusFilter$1.SUCCEEDED;
+      case "reverted":
+        return TransactionStatusFilter$1.REVERTED;
+      case "all":
+        return TransactionStatusFilter$1.ALL;
+      default:
+        return TransactionStatusFilter$1.UNSPECIFIED;
     }
   }
-);
-const Topic = schema.Schema.transform(
-  schema.Schema.Struct({ value: schema.Schema.UndefinedOr(B256Proto) }),
-  schema.Schema.NullOr(B256$1),
-  {
-    decode({ value }) {
-      if (value === void 0) {
-        return null;
-      }
-      return value;
-    },
-    encode(value) {
-      if (value === null) {
-        return { value: void 0 };
-      }
-      return { value };
+};
+const Topic = {
+  encode(x) {
+    if (x === null) {
+      return { value: void 0 };
     }
+    return { value: B256$1.encode(x) };
+  },
+  decode({ value }) {
+    if (value === void 0) {
+      return null;
+    }
+    return B256$1.decode(value);
   }
-);
-const LogFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  address: schema.Schema.optional(Address$1),
-  topics: OptionalArray(Topic),
-  strict: schema.Schema.optional(schema.Schema.Boolean),
-  transactionStatus: schema.Schema.optional(TransactionStatusFilter),
-  includeTransaction: schema.Schema.optional(schema.Schema.Boolean),
-  includeReceipt: schema.Schema.optional(schema.Schema.Boolean)
+};
+const LogFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  address: codec.OptionalCodec(Address$1),
+  topics: codec.OptionalCodec(codec.ArrayCodec(Topic)),
+  strict: codec.OptionalCodec(codec.BooleanCodec),
+  transactionStatus: codec.OptionalCodec(TransactionStatusFilter),
+  includeTransaction: codec.OptionalCodec(codec.BooleanCodec),
+  includeReceipt: codec.OptionalCodec(codec.BooleanCodec),
+  includeTransactionTrace: codec.OptionalCodec(codec.BooleanCodec)
 });
-const TransactionFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  from: schema.Schema.optional(Address$1),
-  to: schema.Schema.optional(Address$1),
-  create: schema.Schema.optional(schema.Schema.Boolean),
-  transactionStatus: schema.Schema.optional(TransactionStatusFilter),
-  includeReceipt: schema.Schema.optional(schema.Schema.Boolean),
-  includeLogs: schema.Schema.optional(schema.Schema.Boolean)
+const TransactionFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  from: codec.OptionalCodec(Address$1),
+  to: codec.OptionalCodec(Address$1),
+  create: codec.OptionalCodec(codec.BooleanCodec),
+  transactionStatus: codec.OptionalCodec(TransactionStatusFilter),
+  includeReceipt: codec.OptionalCodec(codec.BooleanCodec),
+  includeLogs: codec.OptionalCodec(codec.BooleanCodec),
+  includeTransactionTrace: codec.OptionalCodec(codec.BooleanCodec)
 });
-const Filter = schema.Schema.Struct({
-  header: schema.Schema.optional(HeaderFilter),
-  withdrawals: OptionalArray(WithdrawalFilter),
-  transactions: OptionalArray(TransactionFilter),
-  logs: OptionalArray(LogFilter)
+const Filter = codec.MessageCodec({
+  header: codec.OptionalCodec(HeaderFilter),
+  withdrawals: codec.OptionalCodec(codec.ArrayCodec(WithdrawalFilter)),
+  transactions: codec.OptionalCodec(codec.ArrayCodec(TransactionFilter)),
+  logs: codec.OptionalCodec(codec.ArrayCodec(LogFilter))
 });
-const filterToProto = schema.Schema.encodeSync(Filter);
-const filterFromProto = schema.Schema.decodeSync(Filter);
-const FilterFromBytes = schema.Schema.transform(
-  schema.Schema.Uint8ArrayFromSelf,
-  Filter,
-  {
-    strict: false,
-    decode(value) {
-      return Filter$1.decode(value);
-    },
-    encode(value) {
-      return Filter$1.encode(value).finish();
-    }
+const FilterFromBytes = {
+  encode(x) {
+    return Filter$1.encode(Filter.encode(x)).finish();
+  },
+  decode(p) {
+    return Filter.decode(Filter$1.decode(p));
   }
-);
-const filterToBytes = schema.Schema.encodeSync(FilterFromBytes);
-const filterFromBytes = schema.Schema.decodeSync(FilterFromBytes);
+};
 function mergeFilter(a, b) {
   const header = mergeHeaderFilter(a.header, b.header);
   return {
@@ -3295,43 +4429,45 @@ function mergeHeaderFilter(a, b) {
 const EvmStream = new protocol.StreamConfig(
   FilterFromBytes,
   BlockFromBytes,
-  mergeFilter
+  mergeFilter,
+  "evm"
 );
 
 exports.AccessListItem = AccessListItem;
 exports.Address = Address$1;
 exports.B256 = B256$1;
-exports.B256Proto = B256Proto;
 exports.Block = Block;
 exports.BlockFromBytes = BlockFromBytes;
 exports.BlockHeader = BlockHeader;
 exports.Bloom = Bloom;
+exports.CallAction = CallAction;
+exports.CallOutput = CallOutput;
+exports.CallType = CallType;
+exports.CreateAction = CreateAction;
+exports.CreateOutput = CreateOutput;
+exports.CreationMethod = CreationMethod;
 exports.EvmStream = EvmStream;
 exports.Filter = Filter;
 exports.FilterFromBytes = FilterFromBytes;
 exports.HeaderFilter = HeaderFilter;
 exports.Log = Log;
 exports.LogFilter = LogFilter;
+exports.RewardAction = RewardAction;
+exports.RewardType = RewardType;
+exports.SelfDestructAction = SelfDestructAction;
 exports.Signature = Signature;
 exports.Topic = Topic;
+exports.Trace = Trace;
 exports.Transaction = Transaction;
 exports.TransactionFilter = TransactionFilter;
 exports.TransactionReceipt = TransactionReceipt;
 exports.TransactionStatus = TransactionStatus;
 exports.TransactionStatusFilter = TransactionStatusFilter;
+exports.TransactionTrace = TransactionTrace;
 exports.U128 = U128$1;
 exports.U256 = U256$1;
 exports.Withdrawal = Withdrawal;
 exports.WithdrawalFilter = WithdrawalFilter;
-exports.b256FromProto = b256FromProto;
-exports.b256ToProto = b256ToProto;
-exports.filterFromBytes = filterFromBytes;
-exports.filterFromProto = filterFromProto;
-exports.filterToBytes = filterToBytes;
-exports.filterToProto = filterToProto;
 exports.mergeFilter = mergeFilter;
 exports.proto = index;
-exports.u128FromProto = u128FromProto;
-exports.u128ToProto = u128ToProto;
-exports.u256FromProto = u256FromProto;
-exports.u256ToProto = u256ToProto;
+//# sourceMappingURL=index.cjs.map