@apibara/evm 2.0.0

package/dist/index.cjs

@@ -0,0 +1,2994 @@
+'use strict';
+
+const protocol = require('@apibara/protocol');
+const schema = require('@effect/schema');
+const viem = require('viem');
+const Long = require('long');
+const _m0 = require('protobufjs/minimal');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+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}`;
+  },
+  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 };
+  }
+});
+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);
+    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 };
+  }
+});
+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;
+  },
+  encode(value) {
+    const x0 = value >> 8n * 8n & MAX_U64;
+    const x1 = value & MAX_U64;
+    return { x0, x1 };
+  }
+});
+const u128ToProto = schema.Schema.encodeSync(U128$1);
+const u128FromProto = schema.Schema.decodeSync(U128$1);
+
+const protobufPackage$2 = "evm.v2";
+function createBaseAddress() {
+  return { x0: BigInt("0"), x1: BigInt("0"), x2: 0 };
+}
+const Address = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.x0 !== void 0 && message.x0 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x0) !== message.x0) {
+        throw new globalThis.Error("value provided for field message.x0 of type fixed64 too large");
+      }
+      writer.uint32(9).fixed64(message.x0.toString());
+    }
+    if (message.x1 !== void 0 && message.x1 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x1) !== message.x1) {
+        throw new globalThis.Error("value provided for field message.x1 of type fixed64 too large");
+      }
+      writer.uint32(17).fixed64(message.x1.toString());
+    }
+    if (message.x2 !== void 0 && message.x2 !== 0) {
+      writer.uint32(29).fixed32(message.x2);
+    }
+    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 = createBaseAddress();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 9) {
+            break;
+          }
+          message.x0 = longToBigint$3(reader.fixed64());
+          continue;
+        case 2:
+          if (tag !== 17) {
+            break;
+          }
+          message.x1 = longToBigint$3(reader.fixed64());
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
+          message.x2 = reader.fixed32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      x0: isSet$3(object.x0) ? BigInt(object.x0) : BigInt("0"),
+      x1: isSet$3(object.x1) ? BigInt(object.x1) : BigInt("0"),
+      x2: isSet$3(object.x2) ? globalThis.Number(object.x2) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.x0 !== void 0 && message.x0 !== BigInt("0")) {
+      obj.x0 = message.x0.toString();
+    }
+    if (message.x1 !== void 0 && message.x1 !== BigInt("0")) {
+      obj.x1 = message.x1.toString();
+    }
+    if (message.x2 !== void 0 && message.x2 !== 0) {
+      obj.x2 = Math.round(message.x2);
+    }
+    return obj;
+  },
+  create(base) {
+    return Address.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseAddress();
+    message.x0 = object.x0 ?? BigInt("0");
+    message.x1 = object.x1 ?? BigInt("0");
+    message.x2 = object.x2 ?? 0;
+    return message;
+  }
+};
+function createBaseBloom() {
+  return { value: new Uint8Array(0) };
+}
+const Bloom$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.value !== void 0 && message.value.length !== 0) {
+      writer.uint32(10).bytes(message.value);
+    }
+    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 = createBaseBloom();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.value = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { value: isSet$3(object.value) ? bytesFromBase64$1(object.value) : new Uint8Array(0) };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.value !== void 0 && message.value.length !== 0) {
+      obj.value = base64FromBytes$1(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return Bloom$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseBloom();
+    message.value = object.value ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseU128() {
+  return { x0: BigInt("0"), x1: BigInt("0") };
+}
+const U128 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.x0 !== void 0 && message.x0 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x0) !== message.x0) {
+        throw new globalThis.Error("value provided for field message.x0 of type fixed64 too large");
+      }
+      writer.uint32(9).fixed64(message.x0.toString());
+    }
+    if (message.x1 !== void 0 && message.x1 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x1) !== message.x1) {
+        throw new globalThis.Error("value provided for field message.x1 of type fixed64 too large");
+      }
+      writer.uint32(17).fixed64(message.x1.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 = createBaseU128();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 9) {
+            break;
+          }
+          message.x0 = longToBigint$3(reader.fixed64());
+          continue;
+        case 2:
+          if (tag !== 17) {
+            break;
+          }
+          message.x1 = longToBigint$3(reader.fixed64());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      x0: isSet$3(object.x0) ? BigInt(object.x0) : BigInt("0"),
+      x1: isSet$3(object.x1) ? BigInt(object.x1) : BigInt("0")
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.x0 !== void 0 && message.x0 !== BigInt("0")) {
+      obj.x0 = message.x0.toString();
+    }
+    if (message.x1 !== void 0 && message.x1 !== BigInt("0")) {
+      obj.x1 = message.x1.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return U128.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseU128();
+    message.x0 = object.x0 ?? BigInt("0");
+    message.x1 = object.x1 ?? BigInt("0");
+    return message;
+  }
+};
+function createBaseU256() {
+  return { x0: BigInt("0"), x1: BigInt("0"), x2: BigInt("0"), x3: BigInt("0") };
+}
+const U256 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.x0 !== void 0 && message.x0 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x0) !== message.x0) {
+        throw new globalThis.Error("value provided for field message.x0 of type fixed64 too large");
+      }
+      writer.uint32(9).fixed64(message.x0.toString());
+    }
+    if (message.x1 !== void 0 && message.x1 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x1) !== message.x1) {
+        throw new globalThis.Error("value provided for field message.x1 of type fixed64 too large");
+      }
+      writer.uint32(17).fixed64(message.x1.toString());
+    }
+    if (message.x2 !== void 0 && message.x2 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x2) !== message.x2) {
+        throw new globalThis.Error("value provided for field message.x2 of type fixed64 too large");
+      }
+      writer.uint32(25).fixed64(message.x2.toString());
+    }
+    if (message.x3 !== void 0 && message.x3 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x3) !== message.x3) {
+        throw new globalThis.Error("value provided for field message.x3 of type fixed64 too large");
+      }
+      writer.uint32(33).fixed64(message.x3.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 = createBaseU256();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 9) {
+            break;
+          }
+          message.x0 = longToBigint$3(reader.fixed64());
+          continue;
+        case 2:
+          if (tag !== 17) {
+            break;
+          }
+          message.x1 = longToBigint$3(reader.fixed64());
+          continue;
+        case 3:
+          if (tag !== 25) {
+            break;
+          }
+          message.x2 = longToBigint$3(reader.fixed64());
+          continue;
+        case 4:
+          if (tag !== 33) {
+            break;
+          }
+          message.x3 = longToBigint$3(reader.fixed64());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      x0: isSet$3(object.x0) ? BigInt(object.x0) : BigInt("0"),
+      x1: isSet$3(object.x1) ? BigInt(object.x1) : BigInt("0"),
+      x2: isSet$3(object.x2) ? BigInt(object.x2) : BigInt("0"),
+      x3: isSet$3(object.x3) ? BigInt(object.x3) : BigInt("0")
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.x0 !== void 0 && message.x0 !== BigInt("0")) {
+      obj.x0 = message.x0.toString();
+    }
+    if (message.x1 !== void 0 && message.x1 !== BigInt("0")) {
+      obj.x1 = message.x1.toString();
+    }
+    if (message.x2 !== void 0 && message.x2 !== BigInt("0")) {
+      obj.x2 = message.x2.toString();
+    }
+    if (message.x3 !== void 0 && message.x3 !== BigInt("0")) {
+      obj.x3 = message.x3.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return U256.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseU256();
+    message.x0 = object.x0 ?? BigInt("0");
+    message.x1 = object.x1 ?? BigInt("0");
+    message.x2 = object.x2 ?? BigInt("0");
+    message.x3 = object.x3 ?? BigInt("0");
+    return message;
+  }
+};
+function createBaseB256() {
+  return { x0: BigInt("0"), x1: BigInt("0"), x2: BigInt("0"), x3: BigInt("0") };
+}
+const B256 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.x0 !== void 0 && message.x0 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x0) !== message.x0) {
+        throw new globalThis.Error("value provided for field message.x0 of type fixed64 too large");
+      }
+      writer.uint32(9).fixed64(message.x0.toString());
+    }
+    if (message.x1 !== void 0 && message.x1 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x1) !== message.x1) {
+        throw new globalThis.Error("value provided for field message.x1 of type fixed64 too large");
+      }
+      writer.uint32(17).fixed64(message.x1.toString());
+    }
+    if (message.x2 !== void 0 && message.x2 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x2) !== message.x2) {
+        throw new globalThis.Error("value provided for field message.x2 of type fixed64 too large");
+      }
+      writer.uint32(25).fixed64(message.x2.toString());
+    }
+    if (message.x3 !== void 0 && message.x3 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x3) !== message.x3) {
+        throw new globalThis.Error("value provided for field message.x3 of type fixed64 too large");
+      }
+      writer.uint32(33).fixed64(message.x3.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 = createBaseB256();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 9) {
+            break;
+          }
+          message.x0 = longToBigint$3(reader.fixed64());
+          continue;
+        case 2:
+          if (tag !== 17) {
+            break;
+          }
+          message.x1 = longToBigint$3(reader.fixed64());
+          continue;
+        case 3:
+          if (tag !== 25) {
+            break;
+          }
+          message.x2 = longToBigint$3(reader.fixed64());
+          continue;
+        case 4:
+          if (tag !== 33) {
+            break;
+          }
+          message.x3 = longToBigint$3(reader.fixed64());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      x0: isSet$3(object.x0) ? BigInt(object.x0) : BigInt("0"),
+      x1: isSet$3(object.x1) ? BigInt(object.x1) : BigInt("0"),
+      x2: isSet$3(object.x2) ? BigInt(object.x2) : BigInt("0"),
+      x3: isSet$3(object.x3) ? BigInt(object.x3) : BigInt("0")
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.x0 !== void 0 && message.x0 !== BigInt("0")) {
+      obj.x0 = message.x0.toString();
+    }
+    if (message.x1 !== void 0 && message.x1 !== BigInt("0")) {
+      obj.x1 = message.x1.toString();
+    }
+    if (message.x2 !== void 0 && message.x2 !== BigInt("0")) {
+      obj.x2 = message.x2.toString();
+    }
+    if (message.x3 !== void 0 && message.x3 !== BigInt("0")) {
+      obj.x3 = message.x3.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return B256.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseB256();
+    message.x0 = object.x0 ?? BigInt("0");
+    message.x1 = object.x1 ?? BigInt("0");
+    message.x2 = object.x2 ?? BigInt("0");
+    message.x3 = object.x3 ?? BigInt("0");
+    return message;
+  }
+};
+function bytesFromBase64$1(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$1(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 longToBigint$3(long) {
+  return BigInt(long.toString());
+}
+if (_m0__default.util.Long !== Long__default) {
+  _m0__default.util.Long = Long__default;
+  _m0__default.configure();
+}
+function isSet$3(value) {
+  return value !== null && value !== void 0;
+}
+
+const common = {
+  __proto__: null,
+  Address: Address,
+  B256: B256,
+  Bloom: Bloom$1,
+  U128: U128,
+  U256: U256,
+  protobufPackage: protobufPackage$2
+};
+
+function createBaseTimestamp() {
+  return { seconds: BigInt("0"), nanos: 0 };
+}
+const Timestamp = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.seconds !== void 0 && message.seconds !== BigInt("0")) {
+      if (BigInt.asIntN(64, message.seconds) !== message.seconds) {
+        throw new globalThis.Error("value provided for field message.seconds of type int64 too large");
+      }
+      writer.uint32(8).int64(message.seconds.toString());
+    }
+    if (message.nanos !== void 0 && message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    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 = createBaseTimestamp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+          message.seconds = longToBigint$2(reader.int64());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.nanos = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      seconds: isSet$2(object.seconds) ? BigInt(object.seconds) : BigInt("0"),
+      nanos: isSet$2(object.nanos) ? globalThis.Number(object.nanos) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.seconds !== void 0 && message.seconds !== BigInt("0")) {
+      obj.seconds = message.seconds.toString();
+    }
+    if (message.nanos !== void 0 && message.nanos !== 0) {
+      obj.nanos = Math.round(message.nanos);
+    }
+    return obj;
+  },
+  create(base) {
+    return Timestamp.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTimestamp();
+    message.seconds = object.seconds ?? BigInt("0");
+    message.nanos = object.nanos ?? 0;
+    return message;
+  }
+};
+function longToBigint$2(long) {
+  return BigInt(long.toString());
+}
+if (_m0__default.util.Long !== Long__default) {
+  _m0__default.util.Long = Long__default;
+  _m0__default.configure();
+}
+function isSet$2(value) {
+  return value !== null && value !== void 0;
+}
+
+const protobufPackage$1 = "evm.v2";
+function createBaseBlock() {
+  return { header: void 0, withdrawals: [], transactions: [], receipts: [], logs: [] };
+}
+const Block$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.header !== void 0) {
+      BlockHeader$1.encode(message.header, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.withdrawals !== void 0 && message.withdrawals.length !== 0) {
+      for (const v of message.withdrawals) {
+        Withdrawal$1.encode(v, writer.uint32(18).fork()).ldelim();
+      }
+    }
+    if (message.transactions !== void 0 && message.transactions.length !== 0) {
+      for (const v of message.transactions) {
+        Transaction$1.encode(v, writer.uint32(26).fork()).ldelim();
+      }
+    }
+    if (message.receipts !== void 0 && message.receipts.length !== 0) {
+      for (const v of message.receipts) {
+        TransactionReceipt$1.encode(v, writer.uint32(34).fork()).ldelim();
+      }
+    }
+    if (message.logs !== void 0 && message.logs.length !== 0) {
+      for (const v of message.logs) {
+        Log$1.encode(v, writer.uint32(42).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 = createBaseBlock();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.header = BlockHeader$1.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.withdrawals.push(Withdrawal$1.decode(reader, reader.uint32()));
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.transactions.push(Transaction$1.decode(reader, reader.uint32()));
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.receipts.push(TransactionReceipt$1.decode(reader, reader.uint32()));
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.logs.push(Log$1.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      header: isSet$1(object.header) ? BlockHeader$1.fromJSON(object.header) : void 0,
+      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)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.header !== void 0) {
+      obj.header = BlockHeader$1.toJSON(message.header);
+    }
+    if (message.withdrawals?.length) {
+      obj.withdrawals = message.withdrawals.map((e) => Withdrawal$1.toJSON(e));
+    }
+    if (message.transactions?.length) {
+      obj.transactions = message.transactions.map((e) => Transaction$1.toJSON(e));
+    }
+    if (message.receipts?.length) {
+      obj.receipts = message.receipts.map((e) => TransactionReceipt$1.toJSON(e));
+    }
+    if (message.logs?.length) {
+      obj.logs = message.logs.map((e) => Log$1.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return Block$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseBlock();
+    message.header = object.header !== void 0 && object.header !== null ? BlockHeader$1.fromPartial(object.header) : void 0;
+    message.withdrawals = object.withdrawals?.map((e) => Withdrawal$1.fromPartial(e)) || [];
+    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)) || [];
+    return message;
+  }
+};
+function createBaseBlockHeader() {
+  return {
+    number: BigInt("0"),
+    hash: void 0,
+    parentHash: void 0,
+    unclesHash: void 0,
+    miner: void 0,
+    stateRoot: void 0,
+    transactionsRoot: void 0,
+    receiptsRoot: void 0,
+    logsBloom: void 0,
+    difficulty: void 0,
+    gasLimit: void 0,
+    gasUsed: void 0,
+    timestamp: void 0,
+    extraData: new Uint8Array(0),
+    mixHash: void 0,
+    nonce: BigInt("0"),
+    baseFeePerGas: void 0,
+    withdrawalsRoot: void 0,
+    totalDifficulty: void 0,
+    uncles: [],
+    size: void 0,
+    blobGasUsed: BigInt("0"),
+    excessBlobGas: BigInt("0"),
+    parentBeaconBlockRoot: void 0
+  };
+}
+const BlockHeader$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.number !== void 0 && message.number !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.number) !== message.number) {
+        throw new globalThis.Error("value provided for field message.number of type uint64 too large");
+      }
+      writer.uint32(8).uint64(message.number.toString());
+    }
+    if (message.hash !== void 0) {
+      B256.encode(message.hash, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.parentHash !== void 0) {
+      B256.encode(message.parentHash, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.unclesHash !== void 0) {
+      B256.encode(message.unclesHash, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.miner !== void 0) {
+      Address.encode(message.miner, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.stateRoot !== void 0) {
+      B256.encode(message.stateRoot, writer.uint32(50).fork()).ldelim();
+    }
+    if (message.transactionsRoot !== void 0) {
+      B256.encode(message.transactionsRoot, writer.uint32(58).fork()).ldelim();
+    }
+    if (message.receiptsRoot !== void 0) {
+      B256.encode(message.receiptsRoot, writer.uint32(66).fork()).ldelim();
+    }
+    if (message.logsBloom !== void 0) {
+      Bloom$1.encode(message.logsBloom, writer.uint32(74).fork()).ldelim();
+    }
+    if (message.difficulty !== void 0) {
+      U256.encode(message.difficulty, writer.uint32(82).fork()).ldelim();
+    }
+    if (message.gasLimit !== void 0) {
+      U256.encode(message.gasLimit, writer.uint32(90).fork()).ldelim();
+    }
+    if (message.gasUsed !== void 0) {
+      U256.encode(message.gasUsed, writer.uint32(98).fork()).ldelim();
+    }
+    if (message.timestamp !== void 0) {
+      Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(106).fork()).ldelim();
+    }
+    if (message.extraData !== void 0 && message.extraData.length !== 0) {
+      writer.uint32(114).bytes(message.extraData);
+    }
+    if (message.mixHash !== void 0) {
+      B256.encode(message.mixHash, writer.uint32(122).fork()).ldelim();
+    }
+    if (message.nonce !== void 0 && message.nonce !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.nonce) !== message.nonce) {
+        throw new globalThis.Error("value provided for field message.nonce of type uint64 too large");
+      }
+      writer.uint32(128).uint64(message.nonce.toString());
+    }
+    if (message.baseFeePerGas !== void 0) {
+      U256.encode(message.baseFeePerGas, writer.uint32(138).fork()).ldelim();
+    }
+    if (message.withdrawalsRoot !== void 0) {
+      B256.encode(message.withdrawalsRoot, writer.uint32(146).fork()).ldelim();
+    }
+    if (message.totalDifficulty !== void 0) {
+      U256.encode(message.totalDifficulty, writer.uint32(154).fork()).ldelim();
+    }
+    if (message.uncles !== void 0 && message.uncles.length !== 0) {
+      for (const v of message.uncles) {
+        B256.encode(v, writer.uint32(162).fork()).ldelim();
+      }
+    }
+    if (message.size !== void 0) {
+      U256.encode(message.size, writer.uint32(170).fork()).ldelim();
+    }
+    if (message.blobGasUsed !== void 0 && message.blobGasUsed !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.blobGasUsed) !== message.blobGasUsed) {
+        throw new globalThis.Error("value provided for field message.blobGasUsed of type uint64 too large");
+      }
+      writer.uint32(176).uint64(message.blobGasUsed.toString());
+    }
+    if (message.excessBlobGas !== void 0 && message.excessBlobGas !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.excessBlobGas) !== message.excessBlobGas) {
+        throw new globalThis.Error("value provided for field message.excessBlobGas of type uint64 too large");
+      }
+      writer.uint32(184).uint64(message.excessBlobGas.toString());
+    }
+    if (message.parentBeaconBlockRoot !== void 0) {
+      B256.encode(message.parentBeaconBlockRoot, writer.uint32(194).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 = createBaseBlockHeader();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+          message.number = longToBigint$1(reader.uint64());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.hash = B256.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.parentHash = B256.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.unclesHash = B256.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.miner = Address.decode(reader, reader.uint32());
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.stateRoot = B256.decode(reader, reader.uint32());
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+          message.transactionsRoot = B256.decode(reader, reader.uint32());
+          continue;
+        case 8:
+          if (tag !== 66) {
+            break;
+          }
+          message.receiptsRoot = B256.decode(reader, reader.uint32());
+          continue;
+        case 9:
+          if (tag !== 74) {
+            break;
+          }
+          message.logsBloom = Bloom$1.decode(reader, reader.uint32());
+          continue;
+        case 10:
+          if (tag !== 82) {
+            break;
+          }
+          message.difficulty = U256.decode(reader, reader.uint32());
+          continue;
+        case 11:
+          if (tag !== 90) {
+            break;
+          }
+          message.gasLimit = U256.decode(reader, reader.uint32());
+          continue;
+        case 12:
+          if (tag !== 98) {
+            break;
+          }
+          message.gasUsed = U256.decode(reader, reader.uint32());
+          continue;
+        case 13:
+          if (tag !== 106) {
+            break;
+          }
+          message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        case 14:
+          if (tag !== 114) {
+            break;
+          }
+          message.extraData = reader.bytes();
+          continue;
+        case 15:
+          if (tag !== 122) {
+            break;
+          }
+          message.mixHash = B256.decode(reader, reader.uint32());
+          continue;
+        case 16:
+          if (tag !== 128) {
+            break;
+          }
+          message.nonce = longToBigint$1(reader.uint64());
+          continue;
+        case 17:
+          if (tag !== 138) {
+            break;
+          }
+          message.baseFeePerGas = U256.decode(reader, reader.uint32());
+          continue;
+        case 18:
+          if (tag !== 146) {
+            break;
+          }
+          message.withdrawalsRoot = B256.decode(reader, reader.uint32());
+          continue;
+        case 19:
+          if (tag !== 154) {
+            break;
+          }
+          message.totalDifficulty = U256.decode(reader, reader.uint32());
+          continue;
+        case 20:
+          if (tag !== 162) {
+            break;
+          }
+          message.uncles.push(B256.decode(reader, reader.uint32()));
+          continue;
+        case 21:
+          if (tag !== 170) {
+            break;
+          }
+          message.size = U256.decode(reader, reader.uint32());
+          continue;
+        case 22:
+          if (tag !== 176) {
+            break;
+          }
+          message.blobGasUsed = longToBigint$1(reader.uint64());
+          continue;
+        case 23:
+          if (tag !== 184) {
+            break;
+          }
+          message.excessBlobGas = longToBigint$1(reader.uint64());
+          continue;
+        case 24:
+          if (tag !== 194) {
+            break;
+          }
+          message.parentBeaconBlockRoot = B256.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      number: isSet$1(object.number) ? BigInt(object.number) : BigInt("0"),
+      hash: isSet$1(object.hash) ? B256.fromJSON(object.hash) : void 0,
+      parentHash: isSet$1(object.parentHash) ? B256.fromJSON(object.parentHash) : void 0,
+      unclesHash: isSet$1(object.unclesHash) ? B256.fromJSON(object.unclesHash) : void 0,
+      miner: isSet$1(object.miner) ? Address.fromJSON(object.miner) : void 0,
+      stateRoot: isSet$1(object.stateRoot) ? B256.fromJSON(object.stateRoot) : void 0,
+      transactionsRoot: isSet$1(object.transactionsRoot) ? B256.fromJSON(object.transactionsRoot) : void 0,
+      receiptsRoot: isSet$1(object.receiptsRoot) ? B256.fromJSON(object.receiptsRoot) : void 0,
+      logsBloom: isSet$1(object.logsBloom) ? Bloom$1.fromJSON(object.logsBloom) : void 0,
+      difficulty: isSet$1(object.difficulty) ? U256.fromJSON(object.difficulty) : void 0,
+      gasLimit: isSet$1(object.gasLimit) ? U256.fromJSON(object.gasLimit) : void 0,
+      gasUsed: isSet$1(object.gasUsed) ? U256.fromJSON(object.gasUsed) : void 0,
+      timestamp: isSet$1(object.timestamp) ? fromJsonTimestamp(object.timestamp) : void 0,
+      extraData: isSet$1(object.extraData) ? bytesFromBase64(object.extraData) : new Uint8Array(0),
+      mixHash: isSet$1(object.mixHash) ? B256.fromJSON(object.mixHash) : void 0,
+      nonce: isSet$1(object.nonce) ? BigInt(object.nonce) : BigInt("0"),
+      baseFeePerGas: isSet$1(object.baseFeePerGas) ? U256.fromJSON(object.baseFeePerGas) : void 0,
+      withdrawalsRoot: isSet$1(object.withdrawalsRoot) ? B256.fromJSON(object.withdrawalsRoot) : void 0,
+      totalDifficulty: isSet$1(object.totalDifficulty) ? U256.fromJSON(object.totalDifficulty) : void 0,
+      uncles: globalThis.Array.isArray(object?.uncles) ? object.uncles.map((e) => B256.fromJSON(e)) : [],
+      size: isSet$1(object.size) ? U256.fromJSON(object.size) : void 0,
+      blobGasUsed: isSet$1(object.blobGasUsed) ? BigInt(object.blobGasUsed) : BigInt("0"),
+      excessBlobGas: isSet$1(object.excessBlobGas) ? BigInt(object.excessBlobGas) : BigInt("0"),
+      parentBeaconBlockRoot: isSet$1(object.parentBeaconBlockRoot) ? B256.fromJSON(object.parentBeaconBlockRoot) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.number !== void 0 && message.number !== BigInt("0")) {
+      obj.number = message.number.toString();
+    }
+    if (message.hash !== void 0) {
+      obj.hash = B256.toJSON(message.hash);
+    }
+    if (message.parentHash !== void 0) {
+      obj.parentHash = B256.toJSON(message.parentHash);
+    }
+    if (message.unclesHash !== void 0) {
+      obj.unclesHash = B256.toJSON(message.unclesHash);
+    }
+    if (message.miner !== void 0) {
+      obj.miner = Address.toJSON(message.miner);
+    }
+    if (message.stateRoot !== void 0) {
+      obj.stateRoot = B256.toJSON(message.stateRoot);
+    }
+    if (message.transactionsRoot !== void 0) {
+      obj.transactionsRoot = B256.toJSON(message.transactionsRoot);
+    }
+    if (message.receiptsRoot !== void 0) {
+      obj.receiptsRoot = B256.toJSON(message.receiptsRoot);
+    }
+    if (message.logsBloom !== void 0) {
+      obj.logsBloom = Bloom$1.toJSON(message.logsBloom);
+    }
+    if (message.difficulty !== void 0) {
+      obj.difficulty = U256.toJSON(message.difficulty);
+    }
+    if (message.gasLimit !== void 0) {
+      obj.gasLimit = U256.toJSON(message.gasLimit);
+    }
+    if (message.gasUsed !== void 0) {
+      obj.gasUsed = U256.toJSON(message.gasUsed);
+    }
+    if (message.timestamp !== void 0) {
+      obj.timestamp = message.timestamp.toISOString();
+    }
+    if (message.extraData !== void 0 && message.extraData.length !== 0) {
+      obj.extraData = base64FromBytes(message.extraData);
+    }
+    if (message.mixHash !== void 0) {
+      obj.mixHash = B256.toJSON(message.mixHash);
+    }
+    if (message.nonce !== void 0 && message.nonce !== BigInt("0")) {
+      obj.nonce = message.nonce.toString();
+    }
+    if (message.baseFeePerGas !== void 0) {
+      obj.baseFeePerGas = U256.toJSON(message.baseFeePerGas);
+    }
+    if (message.withdrawalsRoot !== void 0) {
+      obj.withdrawalsRoot = B256.toJSON(message.withdrawalsRoot);
+    }
+    if (message.totalDifficulty !== void 0) {
+      obj.totalDifficulty = U256.toJSON(message.totalDifficulty);
+    }
+    if (message.uncles?.length) {
+      obj.uncles = message.uncles.map((e) => B256.toJSON(e));
+    }
+    if (message.size !== void 0) {
+      obj.size = U256.toJSON(message.size);
+    }
+    if (message.blobGasUsed !== void 0 && message.blobGasUsed !== BigInt("0")) {
+      obj.blobGasUsed = message.blobGasUsed.toString();
+    }
+    if (message.excessBlobGas !== void 0 && message.excessBlobGas !== BigInt("0")) {
+      obj.excessBlobGas = message.excessBlobGas.toString();
+    }
+    if (message.parentBeaconBlockRoot !== void 0) {
+      obj.parentBeaconBlockRoot = B256.toJSON(message.parentBeaconBlockRoot);
+    }
+    return obj;
+  },
+  create(base) {
+    return BlockHeader$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseBlockHeader();
+    message.number = object.number ?? BigInt("0");
+    message.hash = object.hash !== void 0 && object.hash !== null ? B256.fromPartial(object.hash) : void 0;
+    message.parentHash = object.parentHash !== void 0 && object.parentHash !== null ? B256.fromPartial(object.parentHash) : void 0;
+    message.unclesHash = object.unclesHash !== void 0 && object.unclesHash !== null ? B256.fromPartial(object.unclesHash) : void 0;
+    message.miner = object.miner !== void 0 && object.miner !== null ? Address.fromPartial(object.miner) : void 0;
+    message.stateRoot = object.stateRoot !== void 0 && object.stateRoot !== null ? B256.fromPartial(object.stateRoot) : void 0;
+    message.transactionsRoot = object.transactionsRoot !== void 0 && object.transactionsRoot !== null ? B256.fromPartial(object.transactionsRoot) : void 0;
+    message.receiptsRoot = object.receiptsRoot !== void 0 && object.receiptsRoot !== null ? B256.fromPartial(object.receiptsRoot) : void 0;
+    message.logsBloom = object.logsBloom !== void 0 && object.logsBloom !== null ? Bloom$1.fromPartial(object.logsBloom) : void 0;
+    message.difficulty = object.difficulty !== void 0 && object.difficulty !== null ? U256.fromPartial(object.difficulty) : void 0;
+    message.gasLimit = object.gasLimit !== void 0 && object.gasLimit !== null ? U256.fromPartial(object.gasLimit) : void 0;
+    message.gasUsed = object.gasUsed !== void 0 && object.gasUsed !== null ? U256.fromPartial(object.gasUsed) : void 0;
+    message.timestamp = object.timestamp ?? void 0;
+    message.extraData = object.extraData ?? new Uint8Array(0);
+    message.mixHash = object.mixHash !== void 0 && object.mixHash !== null ? B256.fromPartial(object.mixHash) : void 0;
+    message.nonce = object.nonce ?? BigInt("0");
+    message.baseFeePerGas = object.baseFeePerGas !== void 0 && object.baseFeePerGas !== null ? U256.fromPartial(object.baseFeePerGas) : void 0;
+    message.withdrawalsRoot = object.withdrawalsRoot !== void 0 && object.withdrawalsRoot !== null ? B256.fromPartial(object.withdrawalsRoot) : void 0;
+    message.totalDifficulty = object.totalDifficulty !== void 0 && object.totalDifficulty !== null ? U256.fromPartial(object.totalDifficulty) : void 0;
+    message.uncles = object.uncles?.map((e) => B256.fromPartial(e)) || [];
+    message.size = object.size !== void 0 && object.size !== null ? U256.fromPartial(object.size) : void 0;
+    message.blobGasUsed = object.blobGasUsed ?? BigInt("0");
+    message.excessBlobGas = object.excessBlobGas ?? BigInt("0");
+    message.parentBeaconBlockRoot = object.parentBeaconBlockRoot !== void 0 && object.parentBeaconBlockRoot !== null ? B256.fromPartial(object.parentBeaconBlockRoot) : void 0;
+    return message;
+  }
+};
+function createBaseWithdrawal() {
+  return {
+    index: BigInt("0"),
+    validatorIndex: BigInt("0"),
+    withdrawalIndex: BigInt("0"),
+    address: void 0,
+    amount: void 0
+  };
+}
+const Withdrawal$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.index !== void 0 && message.index !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.index) !== message.index) {
+        throw new globalThis.Error("value provided for field message.index of type uint64 too large");
+      }
+      writer.uint32(8).uint64(message.index.toString());
+    }
+    if (message.validatorIndex !== void 0 && message.validatorIndex !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.validatorIndex) !== message.validatorIndex) {
+        throw new globalThis.Error("value provided for field message.validatorIndex of type uint64 too large");
+      }
+      writer.uint32(16).uint64(message.validatorIndex.toString());
+    }
+    if (message.withdrawalIndex !== void 0 && message.withdrawalIndex !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.withdrawalIndex) !== message.withdrawalIndex) {
+        throw new globalThis.Error("value provided for field message.withdrawalIndex of type uint64 too large");
+      }
+      writer.uint32(24).uint64(message.withdrawalIndex.toString());
+    }
+    if (message.address !== void 0) {
+      Address.encode(message.address, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.amount !== void 0) {
+      U256.encode(message.amount, writer.uint32(42).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 = createBaseWithdrawal();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+          message.index = longToBigint$1(reader.uint64());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.validatorIndex = longToBigint$1(reader.uint64());
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+          message.withdrawalIndex = longToBigint$1(reader.uint64());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.address = Address.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.amount = U256.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      index: isSet$1(object.index) ? BigInt(object.index) : BigInt("0"),
+      validatorIndex: isSet$1(object.validatorIndex) ? BigInt(object.validatorIndex) : BigInt("0"),
+      withdrawalIndex: isSet$1(object.withdrawalIndex) ? BigInt(object.withdrawalIndex) : BigInt("0"),
+      address: isSet$1(object.address) ? Address.fromJSON(object.address) : void 0,
+      amount: isSet$1(object.amount) ? U256.fromJSON(object.amount) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.index !== void 0 && message.index !== BigInt("0")) {
+      obj.index = message.index.toString();
+    }
+    if (message.validatorIndex !== void 0 && message.validatorIndex !== BigInt("0")) {
+      obj.validatorIndex = message.validatorIndex.toString();
+    }
+    if (message.withdrawalIndex !== void 0 && message.withdrawalIndex !== BigInt("0")) {
+      obj.withdrawalIndex = message.withdrawalIndex.toString();
+    }
+    if (message.address !== void 0) {
+      obj.address = Address.toJSON(message.address);
+    }
+    if (message.amount !== void 0) {
+      obj.amount = U256.toJSON(message.amount);
+    }
+    return obj;
+  },
+  create(base) {
+    return Withdrawal$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseWithdrawal();
+    message.index = object.index ?? BigInt("0");
+    message.validatorIndex = object.validatorIndex ?? BigInt("0");
+    message.withdrawalIndex = object.withdrawalIndex ?? BigInt("0");
+    message.address = object.address !== void 0 && object.address !== null ? Address.fromPartial(object.address) : void 0;
+    message.amount = object.amount !== void 0 && object.amount !== null ? U256.fromPartial(object.amount) : void 0;
+    return message;
+  }
+};
+function createBaseTransaction() {
+  return {
+    hash: void 0,
+    nonce: BigInt("0"),
+    transactionIndex: BigInt("0"),
+    from: void 0,
+    to: void 0,
+    value: void 0,
+    gasPrice: void 0,
+    gas: void 0,
+    maxFeePerGas: void 0,
+    maxPriorityFeePerGas: void 0,
+    input: new Uint8Array(0),
+    signature: void 0,
+    chainId: BigInt("0"),
+    accessList: [],
+    transactionType: BigInt("0"),
+    maxFeePerBlobGas: void 0,
+    blobVersionedHashes: []
+  };
+}
+const Transaction$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.hash !== void 0) {
+      B256.encode(message.hash, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.nonce !== void 0 && message.nonce !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.nonce) !== message.nonce) {
+        throw new globalThis.Error("value provided for field message.nonce of type uint64 too large");
+      }
+      writer.uint32(16).uint64(message.nonce.toString());
+    }
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.transactionIndex) !== message.transactionIndex) {
+        throw new globalThis.Error("value provided for field message.transactionIndex of type uint64 too large");
+      }
+      writer.uint32(24).uint64(message.transactionIndex.toString());
+    }
+    if (message.from !== void 0) {
+      Address.encode(message.from, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.to !== void 0) {
+      Address.encode(message.to, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.value !== void 0) {
+      U256.encode(message.value, writer.uint32(50).fork()).ldelim();
+    }
+    if (message.gasPrice !== void 0) {
+      U128.encode(message.gasPrice, writer.uint32(58).fork()).ldelim();
+    }
+    if (message.gas !== void 0) {
+      U256.encode(message.gas, writer.uint32(66).fork()).ldelim();
+    }
+    if (message.maxFeePerGas !== void 0) {
+      U128.encode(message.maxFeePerGas, writer.uint32(74).fork()).ldelim();
+    }
+    if (message.maxPriorityFeePerGas !== void 0) {
+      U128.encode(message.maxPriorityFeePerGas, writer.uint32(82).fork()).ldelim();
+    }
+    if (message.input !== void 0 && message.input.length !== 0) {
+      writer.uint32(90).bytes(message.input);
+    }
+    if (message.signature !== void 0) {
+      Signature$1.encode(message.signature, writer.uint32(98).fork()).ldelim();
+    }
+    if (message.chainId !== void 0 && message.chainId !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.chainId) !== message.chainId) {
+        throw new globalThis.Error("value provided for field message.chainId of type uint64 too large");
+      }
+      writer.uint32(104).uint64(message.chainId.toString());
+    }
+    if (message.accessList !== void 0 && message.accessList.length !== 0) {
+      for (const v of message.accessList) {
+        AccessListItem$1.encode(v, writer.uint32(114).fork()).ldelim();
+      }
+    }
+    if (message.transactionType !== void 0 && message.transactionType !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.transactionType) !== message.transactionType) {
+        throw new globalThis.Error("value provided for field message.transactionType of type uint64 too large");
+      }
+      writer.uint32(120).uint64(message.transactionType.toString());
+    }
+    if (message.maxFeePerBlobGas !== void 0) {
+      U128.encode(message.maxFeePerBlobGas, writer.uint32(130).fork()).ldelim();
+    }
+    if (message.blobVersionedHashes !== void 0 && message.blobVersionedHashes.length !== 0) {
+      for (const v of message.blobVersionedHashes) {
+        B256.encode(v, writer.uint32(138).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 = createBaseTransaction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.hash = B256.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.nonce = longToBigint$1(reader.uint64());
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+          message.transactionIndex = longToBigint$1(reader.uint64());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.from = Address.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.to = Address.decode(reader, reader.uint32());
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.value = U256.decode(reader, reader.uint32());
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+          message.gasPrice = U128.decode(reader, reader.uint32());
+          continue;
+        case 8:
+          if (tag !== 66) {
+            break;
+          }
+          message.gas = U256.decode(reader, reader.uint32());
+          continue;
+        case 9:
+          if (tag !== 74) {
+            break;
+          }
+          message.maxFeePerGas = U128.decode(reader, reader.uint32());
+          continue;
+        case 10:
+          if (tag !== 82) {
+            break;
+          }
+          message.maxPriorityFeePerGas = U128.decode(reader, reader.uint32());
+          continue;
+        case 11:
+          if (tag !== 90) {
+            break;
+          }
+          message.input = reader.bytes();
+          continue;
+        case 12:
+          if (tag !== 98) {
+            break;
+          }
+          message.signature = Signature$1.decode(reader, reader.uint32());
+          continue;
+        case 13:
+          if (tag !== 104) {
+            break;
+          }
+          message.chainId = longToBigint$1(reader.uint64());
+          continue;
+        case 14:
+          if (tag !== 114) {
+            break;
+          }
+          message.accessList.push(AccessListItem$1.decode(reader, reader.uint32()));
+          continue;
+        case 15:
+          if (tag !== 120) {
+            break;
+          }
+          message.transactionType = longToBigint$1(reader.uint64());
+          continue;
+        case 16:
+          if (tag !== 130) {
+            break;
+          }
+          message.maxFeePerBlobGas = U128.decode(reader, reader.uint32());
+          continue;
+        case 17:
+          if (tag !== 138) {
+            break;
+          }
+          message.blobVersionedHashes.push(B256.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      hash: isSet$1(object.hash) ? B256.fromJSON(object.hash) : void 0,
+      nonce: isSet$1(object.nonce) ? BigInt(object.nonce) : BigInt("0"),
+      transactionIndex: isSet$1(object.transactionIndex) ? BigInt(object.transactionIndex) : BigInt("0"),
+      from: isSet$1(object.from) ? Address.fromJSON(object.from) : void 0,
+      to: isSet$1(object.to) ? Address.fromJSON(object.to) : void 0,
+      value: isSet$1(object.value) ? U256.fromJSON(object.value) : void 0,
+      gasPrice: isSet$1(object.gasPrice) ? U128.fromJSON(object.gasPrice) : void 0,
+      gas: isSet$1(object.gas) ? U256.fromJSON(object.gas) : void 0,
+      maxFeePerGas: isSet$1(object.maxFeePerGas) ? U128.fromJSON(object.maxFeePerGas) : void 0,
+      maxPriorityFeePerGas: isSet$1(object.maxPriorityFeePerGas) ? U128.fromJSON(object.maxPriorityFeePerGas) : void 0,
+      input: isSet$1(object.input) ? bytesFromBase64(object.input) : new Uint8Array(0),
+      signature: isSet$1(object.signature) ? Signature$1.fromJSON(object.signature) : void 0,
+      chainId: isSet$1(object.chainId) ? BigInt(object.chainId) : BigInt("0"),
+      accessList: globalThis.Array.isArray(object?.accessList) ? object.accessList.map((e) => AccessListItem$1.fromJSON(e)) : [],
+      transactionType: isSet$1(object.transactionType) ? BigInt(object.transactionType) : BigInt("0"),
+      maxFeePerBlobGas: isSet$1(object.maxFeePerBlobGas) ? U128.fromJSON(object.maxFeePerBlobGas) : void 0,
+      blobVersionedHashes: globalThis.Array.isArray(object?.blobVersionedHashes) ? object.blobVersionedHashes.map((e) => B256.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.hash !== void 0) {
+      obj.hash = B256.toJSON(message.hash);
+    }
+    if (message.nonce !== void 0 && message.nonce !== BigInt("0")) {
+      obj.nonce = message.nonce.toString();
+    }
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== BigInt("0")) {
+      obj.transactionIndex = message.transactionIndex.toString();
+    }
+    if (message.from !== void 0) {
+      obj.from = Address.toJSON(message.from);
+    }
+    if (message.to !== void 0) {
+      obj.to = Address.toJSON(message.to);
+    }
+    if (message.value !== void 0) {
+      obj.value = U256.toJSON(message.value);
+    }
+    if (message.gasPrice !== void 0) {
+      obj.gasPrice = U128.toJSON(message.gasPrice);
+    }
+    if (message.gas !== void 0) {
+      obj.gas = U256.toJSON(message.gas);
+    }
+    if (message.maxFeePerGas !== void 0) {
+      obj.maxFeePerGas = U128.toJSON(message.maxFeePerGas);
+    }
+    if (message.maxPriorityFeePerGas !== void 0) {
+      obj.maxPriorityFeePerGas = U128.toJSON(message.maxPriorityFeePerGas);
+    }
+    if (message.input !== void 0 && message.input.length !== 0) {
+      obj.input = base64FromBytes(message.input);
+    }
+    if (message.signature !== void 0) {
+      obj.signature = Signature$1.toJSON(message.signature);
+    }
+    if (message.chainId !== void 0 && message.chainId !== BigInt("0")) {
+      obj.chainId = message.chainId.toString();
+    }
+    if (message.accessList?.length) {
+      obj.accessList = message.accessList.map((e) => AccessListItem$1.toJSON(e));
+    }
+    if (message.transactionType !== void 0 && message.transactionType !== BigInt("0")) {
+      obj.transactionType = message.transactionType.toString();
+    }
+    if (message.maxFeePerBlobGas !== void 0) {
+      obj.maxFeePerBlobGas = U128.toJSON(message.maxFeePerBlobGas);
+    }
+    if (message.blobVersionedHashes?.length) {
+      obj.blobVersionedHashes = message.blobVersionedHashes.map((e) => B256.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return Transaction$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTransaction();
+    message.hash = object.hash !== void 0 && object.hash !== null ? B256.fromPartial(object.hash) : void 0;
+    message.nonce = object.nonce ?? BigInt("0");
+    message.transactionIndex = object.transactionIndex ?? BigInt("0");
+    message.from = object.from !== void 0 && object.from !== null ? Address.fromPartial(object.from) : void 0;
+    message.to = object.to !== void 0 && object.to !== null ? Address.fromPartial(object.to) : void 0;
+    message.value = object.value !== void 0 && object.value !== null ? U256.fromPartial(object.value) : void 0;
+    message.gasPrice = object.gasPrice !== void 0 && object.gasPrice !== null ? U128.fromPartial(object.gasPrice) : void 0;
+    message.gas = object.gas !== void 0 && object.gas !== null ? U256.fromPartial(object.gas) : void 0;
+    message.maxFeePerGas = object.maxFeePerGas !== void 0 && object.maxFeePerGas !== null ? U128.fromPartial(object.maxFeePerGas) : void 0;
+    message.maxPriorityFeePerGas = object.maxPriorityFeePerGas !== void 0 && object.maxPriorityFeePerGas !== null ? U128.fromPartial(object.maxPriorityFeePerGas) : void 0;
+    message.input = object.input ?? new Uint8Array(0);
+    message.signature = object.signature !== void 0 && object.signature !== null ? Signature$1.fromPartial(object.signature) : void 0;
+    message.chainId = object.chainId ?? BigInt("0");
+    message.accessList = object.accessList?.map((e) => AccessListItem$1.fromPartial(e)) || [];
+    message.transactionType = object.transactionType ?? BigInt("0");
+    message.maxFeePerBlobGas = object.maxFeePerBlobGas !== void 0 && object.maxFeePerBlobGas !== null ? U128.fromPartial(object.maxFeePerBlobGas) : void 0;
+    message.blobVersionedHashes = object.blobVersionedHashes?.map((e) => B256.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseTransactionReceipt() {
+  return {
+    transactionHash: void 0,
+    transactionIndex: BigInt("0"),
+    cumulativeGasUsed: void 0,
+    gasUsed: void 0,
+    effectiveGasPrice: void 0,
+    from: void 0,
+    to: void 0,
+    contractAddress: void 0,
+    logsBloom: void 0,
+    statusCode: BigInt("0"),
+    transactionType: BigInt("0"),
+    blobGasUsed: void 0,
+    blobGasPrice: void 0
+  };
+}
+const TransactionReceipt$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.transactionHash !== void 0) {
+      B256.encode(message.transactionHash, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.transactionIndex) !== message.transactionIndex) {
+        throw new globalThis.Error("value provided for field message.transactionIndex of type uint64 too large");
+      }
+      writer.uint32(16).uint64(message.transactionIndex.toString());
+    }
+    if (message.cumulativeGasUsed !== void 0) {
+      U256.encode(message.cumulativeGasUsed, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.gasUsed !== void 0) {
+      U256.encode(message.gasUsed, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.effectiveGasPrice !== void 0) {
+      U128.encode(message.effectiveGasPrice, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.from !== void 0) {
+      Address.encode(message.from, writer.uint32(50).fork()).ldelim();
+    }
+    if (message.to !== void 0) {
+      Address.encode(message.to, writer.uint32(58).fork()).ldelim();
+    }
+    if (message.contractAddress !== void 0) {
+      Address.encode(message.contractAddress, writer.uint32(66).fork()).ldelim();
+    }
+    if (message.logsBloom !== void 0) {
+      Bloom$1.encode(message.logsBloom, writer.uint32(74).fork()).ldelim();
+    }
+    if (message.statusCode !== void 0 && message.statusCode !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.statusCode) !== message.statusCode) {
+        throw new globalThis.Error("value provided for field message.statusCode of type uint64 too large");
+      }
+      writer.uint32(80).uint64(message.statusCode.toString());
+    }
+    if (message.transactionType !== void 0 && message.transactionType !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.transactionType) !== message.transactionType) {
+        throw new globalThis.Error("value provided for field message.transactionType of type uint64 too large");
+      }
+      writer.uint32(88).uint64(message.transactionType.toString());
+    }
+    if (message.blobGasUsed !== void 0) {
+      U128.encode(message.blobGasUsed, writer.uint32(98).fork()).ldelim();
+    }
+    if (message.blobGasPrice !== void 0) {
+      U128.encode(message.blobGasPrice, writer.uint32(106).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 = createBaseTransactionReceipt();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.transactionHash = B256.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.transactionIndex = longToBigint$1(reader.uint64());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.cumulativeGasUsed = U256.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.gasUsed = U256.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.effectiveGasPrice = U128.decode(reader, reader.uint32());
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.from = Address.decode(reader, reader.uint32());
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+          message.to = Address.decode(reader, reader.uint32());
+          continue;
+        case 8:
+          if (tag !== 66) {
+            break;
+          }
+          message.contractAddress = Address.decode(reader, reader.uint32());
+          continue;
+        case 9:
+          if (tag !== 74) {
+            break;
+          }
+          message.logsBloom = Bloom$1.decode(reader, reader.uint32());
+          continue;
+        case 10:
+          if (tag !== 80) {
+            break;
+          }
+          message.statusCode = longToBigint$1(reader.uint64());
+          continue;
+        case 11:
+          if (tag !== 88) {
+            break;
+          }
+          message.transactionType = longToBigint$1(reader.uint64());
+          continue;
+        case 12:
+          if (tag !== 98) {
+            break;
+          }
+          message.blobGasUsed = U128.decode(reader, reader.uint32());
+          continue;
+        case 13:
+          if (tag !== 106) {
+            break;
+          }
+          message.blobGasPrice = U128.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      transactionHash: isSet$1(object.transactionHash) ? B256.fromJSON(object.transactionHash) : void 0,
+      transactionIndex: isSet$1(object.transactionIndex) ? BigInt(object.transactionIndex) : BigInt("0"),
+      cumulativeGasUsed: isSet$1(object.cumulativeGasUsed) ? U256.fromJSON(object.cumulativeGasUsed) : void 0,
+      gasUsed: isSet$1(object.gasUsed) ? U256.fromJSON(object.gasUsed) : void 0,
+      effectiveGasPrice: isSet$1(object.effectiveGasPrice) ? U128.fromJSON(object.effectiveGasPrice) : void 0,
+      from: isSet$1(object.from) ? Address.fromJSON(object.from) : void 0,
+      to: isSet$1(object.to) ? Address.fromJSON(object.to) : void 0,
+      contractAddress: isSet$1(object.contractAddress) ? Address.fromJSON(object.contractAddress) : void 0,
+      logsBloom: isSet$1(object.logsBloom) ? Bloom$1.fromJSON(object.logsBloom) : void 0,
+      statusCode: isSet$1(object.statusCode) ? BigInt(object.statusCode) : BigInt("0"),
+      transactionType: isSet$1(object.transactionType) ? BigInt(object.transactionType) : BigInt("0"),
+      blobGasUsed: isSet$1(object.blobGasUsed) ? U128.fromJSON(object.blobGasUsed) : void 0,
+      blobGasPrice: isSet$1(object.blobGasPrice) ? U128.fromJSON(object.blobGasPrice) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.transactionHash !== void 0) {
+      obj.transactionHash = B256.toJSON(message.transactionHash);
+    }
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== BigInt("0")) {
+      obj.transactionIndex = message.transactionIndex.toString();
+    }
+    if (message.cumulativeGasUsed !== void 0) {
+      obj.cumulativeGasUsed = U256.toJSON(message.cumulativeGasUsed);
+    }
+    if (message.gasUsed !== void 0) {
+      obj.gasUsed = U256.toJSON(message.gasUsed);
+    }
+    if (message.effectiveGasPrice !== void 0) {
+      obj.effectiveGasPrice = U128.toJSON(message.effectiveGasPrice);
+    }
+    if (message.from !== void 0) {
+      obj.from = Address.toJSON(message.from);
+    }
+    if (message.to !== void 0) {
+      obj.to = Address.toJSON(message.to);
+    }
+    if (message.contractAddress !== void 0) {
+      obj.contractAddress = Address.toJSON(message.contractAddress);
+    }
+    if (message.logsBloom !== void 0) {
+      obj.logsBloom = Bloom$1.toJSON(message.logsBloom);
+    }
+    if (message.statusCode !== void 0 && message.statusCode !== BigInt("0")) {
+      obj.statusCode = message.statusCode.toString();
+    }
+    if (message.transactionType !== void 0 && message.transactionType !== BigInt("0")) {
+      obj.transactionType = message.transactionType.toString();
+    }
+    if (message.blobGasUsed !== void 0) {
+      obj.blobGasUsed = U128.toJSON(message.blobGasUsed);
+    }
+    if (message.blobGasPrice !== void 0) {
+      obj.blobGasPrice = U128.toJSON(message.blobGasPrice);
+    }
+    return obj;
+  },
+  create(base) {
+    return TransactionReceipt$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTransactionReceipt();
+    message.transactionHash = object.transactionHash !== void 0 && object.transactionHash !== null ? B256.fromPartial(object.transactionHash) : void 0;
+    message.transactionIndex = object.transactionIndex ?? BigInt("0");
+    message.cumulativeGasUsed = object.cumulativeGasUsed !== void 0 && object.cumulativeGasUsed !== null ? U256.fromPartial(object.cumulativeGasUsed) : void 0;
+    message.gasUsed = object.gasUsed !== void 0 && object.gasUsed !== null ? U256.fromPartial(object.gasUsed) : void 0;
+    message.effectiveGasPrice = object.effectiveGasPrice !== void 0 && object.effectiveGasPrice !== null ? U128.fromPartial(object.effectiveGasPrice) : void 0;
+    message.from = object.from !== void 0 && object.from !== null ? Address.fromPartial(object.from) : void 0;
+    message.to = object.to !== void 0 && object.to !== null ? Address.fromPartial(object.to) : void 0;
+    message.contractAddress = object.contractAddress !== void 0 && object.contractAddress !== null ? Address.fromPartial(object.contractAddress) : void 0;
+    message.logsBloom = object.logsBloom !== void 0 && object.logsBloom !== null ? Bloom$1.fromPartial(object.logsBloom) : void 0;
+    message.statusCode = object.statusCode ?? BigInt("0");
+    message.transactionType = object.transactionType ?? BigInt("0");
+    message.blobGasUsed = object.blobGasUsed !== void 0 && object.blobGasUsed !== null ? U128.fromPartial(object.blobGasUsed) : void 0;
+    message.blobGasPrice = object.blobGasPrice !== void 0 && object.blobGasPrice !== null ? U128.fromPartial(object.blobGasPrice) : void 0;
+    return message;
+  }
+};
+function createBaseLog() {
+  return {
+    address: void 0,
+    topics: [],
+    data: new Uint8Array(0),
+    logIndex: BigInt("0"),
+    transactionIndex: BigInt("0"),
+    transactionHash: void 0
+  };
+}
+const Log$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.address !== void 0) {
+      Address.encode(message.address, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.topics !== void 0 && message.topics.length !== 0) {
+      for (const v of message.topics) {
+        B256.encode(v, writer.uint32(18).fork()).ldelim();
+      }
+    }
+    if (message.data !== void 0 && message.data.length !== 0) {
+      writer.uint32(26).bytes(message.data);
+    }
+    if (message.logIndex !== void 0 && message.logIndex !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.logIndex) !== message.logIndex) {
+        throw new globalThis.Error("value provided for field message.logIndex of type uint64 too large");
+      }
+      writer.uint32(32).uint64(message.logIndex.toString());
+    }
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.transactionIndex) !== message.transactionIndex) {
+        throw new globalThis.Error("value provided for field message.transactionIndex of type uint64 too large");
+      }
+      writer.uint32(40).uint64(message.transactionIndex.toString());
+    }
+    if (message.transactionHash !== void 0) {
+      B256.encode(message.transactionHash, 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 = createBaseLog();
+    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.topics.push(B256.decode(reader, reader.uint32()));
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.data = reader.bytes();
+          continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+          message.logIndex = longToBigint$1(reader.uint64());
+          continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+          message.transactionIndex = longToBigint$1(reader.uint64());
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.transactionHash = B256.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,
+      topics: globalThis.Array.isArray(object?.topics) ? object.topics.map((e) => B256.fromJSON(e)) : [],
+      data: isSet$1(object.data) ? bytesFromBase64(object.data) : new Uint8Array(0),
+      logIndex: isSet$1(object.logIndex) ? BigInt(object.logIndex) : BigInt("0"),
+      transactionIndex: isSet$1(object.transactionIndex) ? BigInt(object.transactionIndex) : BigInt("0"),
+      transactionHash: isSet$1(object.transactionHash) ? B256.fromJSON(object.transactionHash) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.address !== void 0) {
+      obj.address = Address.toJSON(message.address);
+    }
+    if (message.topics?.length) {
+      obj.topics = message.topics.map((e) => B256.toJSON(e));
+    }
+    if (message.data !== void 0 && message.data.length !== 0) {
+      obj.data = base64FromBytes(message.data);
+    }
+    if (message.logIndex !== void 0 && message.logIndex !== BigInt("0")) {
+      obj.logIndex = message.logIndex.toString();
+    }
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== BigInt("0")) {
+      obj.transactionIndex = message.transactionIndex.toString();
+    }
+    if (message.transactionHash !== void 0) {
+      obj.transactionHash = B256.toJSON(message.transactionHash);
+    }
+    return obj;
+  },
+  create(base) {
+    return Log$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseLog();
+    message.address = object.address !== void 0 && object.address !== null ? Address.fromPartial(object.address) : void 0;
+    message.topics = object.topics?.map((e) => B256.fromPartial(e)) || [];
+    message.data = object.data ?? new Uint8Array(0);
+    message.logIndex = object.logIndex ?? BigInt("0");
+    message.transactionIndex = object.transactionIndex ?? BigInt("0");
+    message.transactionHash = object.transactionHash !== void 0 && object.transactionHash !== null ? B256.fromPartial(object.transactionHash) : void 0;
+    return message;
+  }
+};
+function createBaseSignature() {
+  return { r: void 0, s: void 0, v: void 0, yParity: false };
+}
+const Signature$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.r !== void 0) {
+      U256.encode(message.r, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.s !== void 0) {
+      U256.encode(message.s, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.v !== void 0) {
+      U256.encode(message.v, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.yParity !== void 0 && message.yParity !== false) {
+      writer.uint32(32).bool(message.yParity);
+    }
+    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 = createBaseSignature();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.r = U256.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.s = U256.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.v = U256.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+          message.yParity = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      r: isSet$1(object.r) ? U256.fromJSON(object.r) : void 0,
+      s: isSet$1(object.s) ? U256.fromJSON(object.s) : void 0,
+      v: isSet$1(object.v) ? U256.fromJSON(object.v) : void 0,
+      yParity: isSet$1(object.yParity) ? globalThis.Boolean(object.yParity) : false
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.r !== void 0) {
+      obj.r = U256.toJSON(message.r);
+    }
+    if (message.s !== void 0) {
+      obj.s = U256.toJSON(message.s);
+    }
+    if (message.v !== void 0) {
+      obj.v = U256.toJSON(message.v);
+    }
+    if (message.yParity !== void 0 && message.yParity !== false) {
+      obj.yParity = message.yParity;
+    }
+    return obj;
+  },
+  create(base) {
+    return Signature$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSignature();
+    message.r = object.r !== void 0 && object.r !== null ? U256.fromPartial(object.r) : void 0;
+    message.s = object.s !== void 0 && object.s !== null ? U256.fromPartial(object.s) : void 0;
+    message.v = object.v !== void 0 && object.v !== null ? U256.fromPartial(object.v) : void 0;
+    message.yParity = object.yParity ?? false;
+    return message;
+  }
+};
+function createBaseAccessListItem() {
+  return { address: void 0, storageKeys: [] };
+}
+const AccessListItem$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.address !== void 0) {
+      Address.encode(message.address, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.storageKeys !== void 0 && message.storageKeys.length !== 0) {
+      for (const v of message.storageKeys) {
+        B256.encode(v, writer.uint32(18).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 = createBaseAccessListItem();
+    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.storageKeys.push(B256.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,
+      storageKeys: globalThis.Array.isArray(object?.storageKeys) ? object.storageKeys.map((e) => B256.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.address !== void 0) {
+      obj.address = Address.toJSON(message.address);
+    }
+    if (message.storageKeys?.length) {
+      obj.storageKeys = message.storageKeys.map((e) => B256.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return AccessListItem$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseAccessListItem();
+    message.address = object.address !== void 0 && object.address !== null ? Address.fromPartial(object.address) : void 0;
+    message.storageKeys = object.storageKeys?.map((e) => B256.fromPartial(e)) || [];
+    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$1(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,
+  Withdrawal: Withdrawal$1,
+  protobufPackage: protobufPackage$1
+};
+
+const protobufPackage = "evm.v2";
+function createBaseFilter() {
+  return { header: void 0, withdrawals: [], transactions: [], logs: [] };
+}
+const Filter$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.header !== void 0) {
+      HeaderFilter$1.encode(message.header, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.withdrawals !== void 0 && message.withdrawals.length !== 0) {
+      for (const v of message.withdrawals) {
+        WithdrawalFilter$1.encode(v, writer.uint32(18).fork()).ldelim();
+      }
+    }
+    if (message.transactions !== void 0 && message.transactions.length !== 0) {
+      for (const v of message.transactions) {
+        TransactionFilter$1.encode(v, writer.uint32(26).fork()).ldelim();
+      }
+    }
+    if (message.logs !== void 0 && message.logs.length !== 0) {
+      for (const v of message.logs) {
+        LogFilter$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 = createBaseFilter();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.header = HeaderFilter$1.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.withdrawals.push(WithdrawalFilter$1.decode(reader, reader.uint32()));
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.transactions.push(TransactionFilter$1.decode(reader, reader.uint32()));
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.logs.push(LogFilter$1.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      header: isSet(object.header) ? HeaderFilter$1.fromJSON(object.header) : void 0,
+      withdrawals: globalThis.Array.isArray(object?.withdrawals) ? object.withdrawals.map((e) => WithdrawalFilter$1.fromJSON(e)) : [],
+      transactions: globalThis.Array.isArray(object?.transactions) ? object.transactions.map((e) => TransactionFilter$1.fromJSON(e)) : [],
+      logs: globalThis.Array.isArray(object?.logs) ? object.logs.map((e) => LogFilter$1.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.header !== void 0) {
+      obj.header = HeaderFilter$1.toJSON(message.header);
+    }
+    if (message.withdrawals?.length) {
+      obj.withdrawals = message.withdrawals.map((e) => WithdrawalFilter$1.toJSON(e));
+    }
+    if (message.transactions?.length) {
+      obj.transactions = message.transactions.map((e) => TransactionFilter$1.toJSON(e));
+    }
+    if (message.logs?.length) {
+      obj.logs = message.logs.map((e) => LogFilter$1.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return Filter$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFilter();
+    message.header = object.header !== void 0 && object.header !== null ? HeaderFilter$1.fromPartial(object.header) : void 0;
+    message.withdrawals = object.withdrawals?.map((e) => WithdrawalFilter$1.fromPartial(e)) || [];
+    message.transactions = object.transactions?.map((e) => TransactionFilter$1.fromPartial(e)) || [];
+    message.logs = object.logs?.map((e) => LogFilter$1.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseHeaderFilter() {
+  return { always: void 0 };
+}
+const HeaderFilter$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.always !== void 0) {
+      writer.uint32(8).bool(message.always);
+    }
+    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 = createBaseHeaderFilter();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+          message.always = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { always: isSet(object.always) ? globalThis.Boolean(object.always) : void 0 };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.always !== void 0) {
+      obj.always = message.always;
+    }
+    return obj;
+  },
+  create(base) {
+    return HeaderFilter$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseHeaderFilter();
+    message.always = object.always ?? void 0;
+    return message;
+  }
+};
+function createBaseWithdrawalFilter() {
+  return { validatorIndex: void 0, address: void 0 };
+}
+const WithdrawalFilter$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.validatorIndex !== void 0) {
+      if (BigInt.asUintN(64, message.validatorIndex) !== message.validatorIndex) {
+        throw new globalThis.Error("value provided for field message.validatorIndex of type uint64 too large");
+      }
+      writer.uint32(8).uint64(message.validatorIndex.toString());
+    }
+    if (message.address !== void 0) {
+      Address.encode(message.address, writer.uint32(18).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 = createBaseWithdrawalFilter();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+          message.validatorIndex = longToBigint(reader.uint64());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.address = Address.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      validatorIndex: isSet(object.validatorIndex) ? BigInt(object.validatorIndex) : void 0,
+      address: isSet(object.address) ? Address.fromJSON(object.address) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.validatorIndex !== void 0) {
+      obj.validatorIndex = message.validatorIndex.toString();
+    }
+    if (message.address !== void 0) {
+      obj.address = Address.toJSON(message.address);
+    }
+    return obj;
+  },
+  create(base) {
+    return WithdrawalFilter$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseWithdrawalFilter();
+    message.validatorIndex = object.validatorIndex ?? void 0;
+    message.address = object.address !== void 0 && object.address !== null ? Address.fromPartial(object.address) : void 0;
+    return message;
+  }
+};
+function createBaseTransactionFilter() {
+  return { from: void 0, to: void 0, includeReceipt: void 0, includeLogs: void 0 };
+}
+const TransactionFilter$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.from !== void 0) {
+      Address.encode(message.from, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.to !== void 0) {
+      Address.encode(message.to, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.includeReceipt !== void 0) {
+      writer.uint32(24).bool(message.includeReceipt);
+    }
+    if (message.includeLogs !== void 0) {
+      writer.uint32(32).bool(message.includeLogs);
+    }
+    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 = createBaseTransactionFilter();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.from = Address.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.to = Address.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+          message.includeReceipt = reader.bool();
+          continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+          message.includeLogs = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      from: isSet(object.from) ? Address.fromJSON(object.from) : void 0,
+      to: isSet(object.to) ? Address.fromJSON(object.to) : void 0,
+      includeReceipt: isSet(object.includeReceipt) ? globalThis.Boolean(object.includeReceipt) : void 0,
+      includeLogs: isSet(object.includeLogs) ? globalThis.Boolean(object.includeLogs) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.from !== void 0) {
+      obj.from = Address.toJSON(message.from);
+    }
+    if (message.to !== void 0) {
+      obj.to = Address.toJSON(message.to);
+    }
+    if (message.includeReceipt !== void 0) {
+      obj.includeReceipt = message.includeReceipt;
+    }
+    if (message.includeLogs !== void 0) {
+      obj.includeLogs = message.includeLogs;
+    }
+    return obj;
+  },
+  create(base) {
+    return TransactionFilter$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTransactionFilter();
+    message.from = object.from !== void 0 && object.from !== null ? Address.fromPartial(object.from) : void 0;
+    message.to = object.to !== void 0 && object.to !== null ? Address.fromPartial(object.to) : void 0;
+    message.includeReceipt = object.includeReceipt ?? void 0;
+    message.includeLogs = object.includeLogs ?? void 0;
+    return message;
+  }
+};
+function createBaseLogFilter() {
+  return {
+    address: void 0,
+    topics: [],
+    strict: void 0,
+    includeTransaction: void 0,
+    includeReceipt: void 0
+  };
+}
+const LogFilter$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.address !== void 0) {
+      Address.encode(message.address, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.topics !== void 0 && message.topics.length !== 0) {
+      for (const v of message.topics) {
+        Topic$1.encode(v, writer.uint32(18).fork()).ldelim();
+      }
+    }
+    if (message.strict !== void 0) {
+      writer.uint32(24).bool(message.strict);
+    }
+    if (message.includeTransaction !== void 0) {
+      writer.uint32(32).bool(message.includeTransaction);
+    }
+    if (message.includeReceipt !== void 0) {
+      writer.uint32(40).bool(message.includeReceipt);
+    }
+    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 = createBaseLogFilter();
+    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.topics.push(Topic$1.decode(reader, reader.uint32()));
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+          message.strict = reader.bool();
+          continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+          message.includeTransaction = reader.bool();
+          continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+          message.includeReceipt = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      address: isSet(object.address) ? Address.fromJSON(object.address) : void 0,
+      topics: globalThis.Array.isArray(object?.topics) ? object.topics.map((e) => Topic$1.fromJSON(e)) : [],
+      strict: isSet(object.strict) ? globalThis.Boolean(object.strict) : void 0,
+      includeTransaction: isSet(object.includeTransaction) ? globalThis.Boolean(object.includeTransaction) : void 0,
+      includeReceipt: isSet(object.includeReceipt) ? globalThis.Boolean(object.includeReceipt) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.address !== void 0) {
+      obj.address = Address.toJSON(message.address);
+    }
+    if (message.topics?.length) {
+      obj.topics = message.topics.map((e) => Topic$1.toJSON(e));
+    }
+    if (message.strict !== void 0) {
+      obj.strict = message.strict;
+    }
+    if (message.includeTransaction !== void 0) {
+      obj.includeTransaction = message.includeTransaction;
+    }
+    if (message.includeReceipt !== void 0) {
+      obj.includeReceipt = message.includeReceipt;
+    }
+    return obj;
+  },
+  create(base) {
+    return LogFilter$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseLogFilter();
+    message.address = object.address !== void 0 && object.address !== null ? Address.fromPartial(object.address) : void 0;
+    message.topics = object.topics?.map((e) => Topic$1.fromPartial(e)) || [];
+    message.strict = object.strict ?? void 0;
+    message.includeTransaction = object.includeTransaction ?? void 0;
+    message.includeReceipt = object.includeReceipt ?? void 0;
+    return message;
+  }
+};
+function createBaseTopic() {
+  return { value: void 0 };
+}
+const Topic$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.value !== void 0) {
+      B256.encode(message.value, writer.uint32(10).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 = createBaseTopic();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.value = B256.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { value: isSet(object.value) ? B256.fromJSON(object.value) : void 0 };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.value !== void 0) {
+      obj.value = B256.toJSON(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return Topic$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTopic();
+    message.value = object.value !== void 0 && object.value !== null ? B256.fromPartial(object.value) : void 0;
+    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(value) {
+  return value !== null && value !== void 0;
+}
+
+const filter = {
+  __proto__: null,
+  Filter: Filter$1,
+  HeaderFilter: HeaderFilter$1,
+  LogFilter: LogFilter$1,
+  Topic: Topic$1,
+  TransactionFilter: TransactionFilter$1,
+  WithdrawalFilter: WithdrawalFilter$1,
+  protobufPackage: protobufPackage
+};
+
+const index = {
+  __proto__: null,
+  common: common,
+  data: data,
+  filter: filter
+};
+
+const HexData = schema.Schema.transform(
+  schema.Schema.Struct({
+    value: protocol.BytesFromUint8Array
+  }),
+  protocol.Bytes,
+  {
+    strict: false,
+    encode(value) {
+      throw new Error("Not implemented");
+    },
+    decode({ value }) {
+      throw new Error("Not implemented");
+    }
+  }
+);
+const Bloom = schema.Schema.transform(
+  schema.Schema.Struct({
+    value: protocol.BytesFromUint8Array
+  }),
+  protocol.Bytes,
+  {
+    strict: false,
+    encode(value) {
+      throw new Error("Not implemented");
+    },
+    decode({ value }) {
+      throw new Error("Not implemented");
+    }
+  }
+);
+const BlockHeader = schema.Schema.Struct({
+  number: schema.Schema.BigIntFromSelf,
+  hash: schema.Schema.optional(B256$1),
+  parentHash: schema.Schema.optional(B256$1),
+  uncleHash: schema.Schema.optional(B256$1),
+  miner: schema.Schema.optional(Address$1),
+  stateRoot: schema.Schema.optional(B256$1),
+  transactionRoot: schema.Schema.optional(B256$1),
+  receiptRoot: schema.Schema.optional(B256$1),
+  logsBloom: schema.Schema.optional(Bloom),
+  difficulty: schema.Schema.optional(U256$1),
+  gasLimit: schema.Schema.optional(U256$1),
+  gasUsed: schema.Schema.optional(U256$1),
+  timestamp: schema.Schema.optional(schema.Schema.DateFromSelf),
+  // extraData: Schema.optional(HexData),
+  mixHash: schema.Schema.optional(B256$1),
+  nonce: schema.Schema.BigIntFromSelf,
+  baseFeePerGas: schema.Schema.optional(U256$1),
+  withdrawalsRoot: schema.Schema.optional(B256$1),
+  totalDifficulty: schema.Schema.optional(U256$1),
+  uncles: schema.Schema.Array(B256$1),
+  size: schema.Schema.optional(U256$1),
+  blobGasUsed: schema.Schema.BigIntFromSelf,
+  excessBlobGas: schema.Schema.BigIntFromSelf,
+  parentBeaconBlockRoot: schema.Schema.optional(B256$1)
+});
+const Withdrawal = schema.Schema.Struct({
+  index: schema.Schema.BigIntFromSelf,
+  validatorIndex: schema.Schema.BigIntFromSelf,
+  withdrawalIndex: schema.Schema.BigIntFromSelf,
+  address: schema.Schema.optional(Address$1),
+  amount: schema.Schema.optional(U256$1)
+});
+const AccessListItem = schema.Schema.Struct({
+  address: schema.Schema.optional(Address$1),
+  storageKeys: schema.Schema.Array(B256$1)
+});
+const Signature = schema.Schema.Struct({
+  r: schema.Schema.optional(U256$1),
+  s: schema.Schema.optional(U256$1),
+  v: schema.Schema.optional(U256$1),
+  YParity: schema.Schema.optional(schema.Schema.Boolean)
+});
+const Transaction = schema.Schema.Struct({
+  hash: schema.Schema.optional(B256$1),
+  nonce: schema.Schema.BigIntFromSelf,
+  transactionIndex: schema.Schema.BigIntFromSelf,
+  from: schema.Schema.optional(Address$1),
+  to: schema.Schema.optional(Address$1),
+  value: schema.Schema.optional(U256$1),
+  gasPrice: schema.Schema.optional(U128$1),
+  gas: schema.Schema.optional(U256$1),
+  maxFeePerGas: schema.Schema.optional(U128$1),
+  maxPriorityFeePerGas: schema.Schema.optional(U128$1),
+  // TODO
+  // input: Schema.optional(HexData),
+  signature: schema.Schema.optional(Signature),
+  chainId: schema.Schema.BigIntFromSelf,
+  accessList: schema.Schema.Array(AccessListItem),
+  transactionType: schema.Schema.BigIntFromSelf,
+  maxFeePerBlobGas: schema.Schema.optional(U128$1),
+  blobVersionedHashes: schema.Schema.Array(B256$1)
+});
+const TransactionReceipt = schema.Schema.Struct({
+  transactionHash: schema.Schema.optional(B256$1),
+  transactionIndex: schema.Schema.BigIntFromSelf,
+  cumulativeGasUsed: schema.Schema.optional(U256$1),
+  gasUsed: schema.Schema.optional(U256$1),
+  effectiveGasPrice: schema.Schema.optional(U128$1),
+  from: schema.Schema.optional(Address$1),
+  to: schema.Schema.optional(Address$1),
+  contractAddress: schema.Schema.optional(Address$1),
+  logsBloom: schema.Schema.optional(Bloom),
+  statusCode: schema.Schema.BigIntFromSelf,
+  transactionType: schema.Schema.BigIntFromSelf,
+  blobGasUsed: schema.Schema.optional(U128$1),
+  blobGasPrice: schema.Schema.optional(U128$1)
+});
+const Log = schema.Schema.Struct({
+  address: schema.Schema.optional(Address$1),
+  topics: schema.Schema.Array(B256$1),
+  // TODO
+  // data: Bytes,
+  logIndex: schema.Schema.BigIntFromSelf,
+  transactionIndex: schema.Schema.BigIntFromSelf,
+  transactionHash: schema.Schema.optional(B256$1)
+});
+const Block = schema.Schema.Struct({
+  header: schema.Schema.optional(BlockHeader),
+  withdrawals: schema.Schema.Array(Withdrawal),
+  transactions: schema.Schema.Array(Transaction),
+  receipts: schema.Schema.Array(TransactionReceipt),
+  logs: schema.Schema.Array(Log)
+});
+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 OptionalArray = (schema$1) => schema.Schema.optional(schema.Schema.Array(schema$1));
+const HeaderFilter = schema.Schema.Struct({
+  always: schema.Schema.optional(schema.Schema.Boolean)
+});
+const WithdrawalFilter = schema.Schema.Struct({
+  validatorIndex: schema.Schema.optional(schema.Schema.BigIntFromSelf),
+  address: schema.Schema.optional(Address$1)
+});
+const Topic = schema.Schema.transform(
+  schema.Schema.Struct({ value: schema.Schema.UndefinedOr(B256$1) }),
+  schema.Schema.NullOr(B256$1),
+  {
+    strict: false,
+    decode({ value }) {
+      if (value === void 0) {
+        return null;
+      }
+      return b256ToProto(value);
+    },
+    encode(value) {
+      if (value === null) {
+        return { value: void 0 };
+      }
+      return { value: b256FromProto(value) };
+    }
+  }
+);
+const LogFilter = schema.Schema.Struct({
+  address: schema.Schema.optional(Address$1),
+  topics: OptionalArray(Topic),
+  strict: schema.Schema.optional(schema.Schema.Boolean),
+  includeTransaction: schema.Schema.optional(schema.Schema.Boolean),
+  includeReceipt: schema.Schema.optional(schema.Schema.Boolean)
+});
+const TransactionFilter = schema.Schema.Struct({
+  from: schema.Schema.optional(Address$1),
+  to: schema.Schema.optional(Address$1),
+  includeReceipt: schema.Schema.optional(schema.Schema.Boolean),
+  includeLogs: schema.Schema.optional(schema.Schema.Boolean)
+});
+const Filter = schema.Schema.Struct({
+  header: schema.Schema.optional(HeaderFilter),
+  withdrawals: OptionalArray(WithdrawalFilter),
+  logs: OptionalArray(LogFilter),
+  transactions: OptionalArray(TransactionFilter)
+});
+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 filterToBytes = schema.Schema.encodeSync(FilterFromBytes);
+const filterFromBytes = schema.Schema.decodeSync(FilterFromBytes);
+function mergeFilter(a, b) {
+  const header = mergeHeaderFilter(a.header, b.header);
+  return {
+    header,
+    withdrawals: [...a.withdrawals ?? [], ...b.withdrawals ?? []],
+    logs: [...a.logs ?? [], ...b.logs ?? []],
+    transactions: [...a.transactions ?? [], ...b.transactions ?? []]
+  };
+}
+function mergeHeaderFilter(a, b) {
+  if (a === void 0) {
+    return b;
+  }
+  if (b === void 0) {
+    return a;
+  }
+  return {
+    always: a.always || b.always
+  };
+}
+
+const EvmStream = new protocol.StreamConfig(
+  FilterFromBytes,
+  BlockFromBytes,
+  mergeFilter
+);
+
+exports.AccessListItem = AccessListItem;
+exports.Address = Address$1;
+exports.B256 = B256$1;
+exports.Block = Block;
+exports.BlockFromBytes = BlockFromBytes;
+exports.BlockHeader = BlockHeader;
+exports.Bloom = Bloom;
+exports.EvmStream = EvmStream;
+exports.Filter = Filter;
+exports.FilterFromBytes = FilterFromBytes;
+exports.HeaderFilter = HeaderFilter;
+exports.HexData = HexData;
+exports.Log = Log;
+exports.LogFilter = LogFilter;
+exports.Signature = Signature;
+exports.Topic = Topic;
+exports.Transaction = Transaction;
+exports.TransactionFilter = TransactionFilter;
+exports.TransactionReceipt = TransactionReceipt;
+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;