@injectivelabs/indexer-proto-ts-v2 1.0.0

package/generated/event_provider_api_pb.js

@@ -0,0 +1,1776 @@
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+class GetLatestHeightRequest$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetLatestHeightRequest", []);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetLatestHeightRequest = new GetLatestHeightRequest$Type();
+class GetLatestHeightResponse$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetLatestHeightResponse", [
+      {
+        no: 1,
+        name: "v",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "s",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "e",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 4, name: "data", kind: "message", T: () => LatestBlockHeight }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.v = "";
+    message.s = "";
+    message.e = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string v */
+        1:
+          message.v = reader.string();
+          break;
+        case /* string s */
+        2:
+          message.s = reader.string();
+          break;
+        case /* string e */
+        3:
+          message.e = reader.string();
+          break;
+        case /* event_provider_api.LatestBlockHeight data */
+        4:
+          message.data = LatestBlockHeight.internalBinaryRead(reader, reader.uint32(), options, message.data);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.v !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.v);
+    if (message.s !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.s);
+    if (message.e !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.e);
+    if (message.data)
+      LatestBlockHeight.internalBinaryWrite(message.data, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetLatestHeightResponse = new GetLatestHeightResponse$Type();
+class LatestBlockHeight$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.LatestBlockHeight", [
+      {
+        no: 1,
+        name: "height",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "time",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.height = 0n;
+    message.time = 0n;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* uint64 height */
+        1:
+          message.height = reader.uint64().toBigInt();
+          break;
+        case /* sint64 time */
+        2:
+          message.time = reader.sint64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.height !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.height);
+    if (message.time !== 0n)
+      writer.tag(2, WireType.Varint).sint64(message.time);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const LatestBlockHeight = new LatestBlockHeight$Type();
+class StreamLatestHeightRequest$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.StreamLatestHeightRequest", []);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const StreamLatestHeightRequest = new StreamLatestHeightRequest$Type();
+class StreamLatestHeightResponse$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.StreamLatestHeightResponse", [
+      {
+        no: 1,
+        name: "height",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "time",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.height = 0n;
+    message.time = 0n;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* uint64 height */
+        1:
+          message.height = reader.uint64().toBigInt();
+          break;
+        case /* sint64 time */
+        2:
+          message.time = reader.sint64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.height !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.height);
+    if (message.time !== 0n)
+      writer.tag(2, WireType.Varint).sint64(message.time);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const StreamLatestHeightResponse = new StreamLatestHeightResponse$Type();
+class StreamBlockEventsRequest$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.StreamBlockEventsRequest", [
+      {
+        no: 1,
+        name: "backend",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "height",
+        kind: "scalar",
+        T: 17
+        /*ScalarType.SINT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.backend = "";
+    message.height = 0;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string backend */
+        1:
+          message.backend = reader.string();
+          break;
+        case /* sint32 height */
+        2:
+          message.height = reader.sint32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.backend !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.backend);
+    if (message.height !== 0)
+      writer.tag(2, WireType.Varint).sint32(message.height);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const StreamBlockEventsRequest = new StreamBlockEventsRequest$Type();
+class StreamBlockEventsResponse$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.StreamBlockEventsResponse", [
+      { no: 1, name: "blocks", kind: "message", repeat: 2, T: () => Block }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.blocks = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated event_provider_api.Block blocks */
+        1:
+          message.blocks.push(Block.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.blocks.length; i++)
+      Block.internalBinaryWrite(message.blocks[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const StreamBlockEventsResponse = new StreamBlockEventsResponse$Type();
+class Block$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.Block", [
+      {
+        no: 1,
+        name: "height",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "version",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 3, name: "events", kind: "message", repeat: 2, T: () => BlockEvent },
+      {
+        no: 4,
+        name: "in_sync",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 5,
+        name: "time",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.height = 0n;
+    message.version = "";
+    message.events = [];
+    message.inSync = false;
+    message.time = 0n;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* sint64 height */
+        1:
+          message.height = reader.sint64().toBigInt();
+          break;
+        case /* string version */
+        2:
+          message.version = reader.string();
+          break;
+        case /* repeated event_provider_api.BlockEvent events */
+        3:
+          message.events.push(BlockEvent.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* bool in_sync */
+        4:
+          message.inSync = reader.bool();
+          break;
+        case /* sint64 time */
+        5:
+          message.time = reader.sint64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.height !== 0n)
+      writer.tag(1, WireType.Varint).sint64(message.height);
+    if (message.version !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.version);
+    for (let i = 0; i < message.events.length; i++)
+      BlockEvent.internalBinaryWrite(message.events[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    if (message.inSync !== false)
+      writer.tag(4, WireType.Varint).bool(message.inSync);
+    if (message.time !== 0n)
+      writer.tag(5, WireType.Varint).sint64(message.time);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const Block = new Block$Type();
+class BlockEvent$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.BlockEvent", [
+      {
+        no: 1,
+        name: "type_url",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "value",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 3,
+        name: "tx_hash",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 4,
+        name: "mode",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.typeUrl = "";
+    message.value = new Uint8Array(0);
+    message.txHash = new Uint8Array(0);
+    message.mode = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string type_url */
+        1:
+          message.typeUrl = reader.string();
+          break;
+        case /* bytes value */
+        2:
+          message.value = reader.bytes();
+          break;
+        case /* bytes tx_hash */
+        3:
+          message.txHash = reader.bytes();
+          break;
+        case /* string mode */
+        4:
+          message.mode = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.typeUrl !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.typeUrl);
+    if (message.value.length)
+      writer.tag(2, WireType.LengthDelimited).bytes(message.value);
+    if (message.txHash.length)
+      writer.tag(3, WireType.LengthDelimited).bytes(message.txHash);
+    if (message.mode !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.mode);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const BlockEvent = new BlockEvent$Type();
+class GetBlockEventsRPCRequest$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetBlockEventsRPCRequest", [
+      {
+        no: 1,
+        name: "backend",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "height",
+        kind: "scalar",
+        T: 17
+        /*ScalarType.SINT32*/
+      },
+      {
+        no: 3,
+        name: "human_readable",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.backend = "";
+    message.height = 0;
+    message.humanReadable = false;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string backend */
+        1:
+          message.backend = reader.string();
+          break;
+        case /* sint32 height */
+        2:
+          message.height = reader.sint32();
+          break;
+        case /* bool human_readable */
+        3:
+          message.humanReadable = reader.bool();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.backend !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.backend);
+    if (message.height !== 0)
+      writer.tag(2, WireType.Varint).sint32(message.height);
+    if (message.humanReadable !== false)
+      writer.tag(3, WireType.Varint).bool(message.humanReadable);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetBlockEventsRPCRequest = new GetBlockEventsRPCRequest$Type();
+class GetBlockEventsRPCResponse$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetBlockEventsRPCResponse", [
+      {
+        no: 1,
+        name: "v",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "s",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "e",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 4, name: "data", kind: "message", T: () => BlockEventsRPC },
+      { no: 5, name: "block", kind: "message", T: () => BasicBlockInfo }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.v = "";
+    message.s = "";
+    message.e = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string v */
+        1:
+          message.v = reader.string();
+          break;
+        case /* string s */
+        2:
+          message.s = reader.string();
+          break;
+        case /* string e */
+        3:
+          message.e = reader.string();
+          break;
+        case /* event_provider_api.BlockEventsRPC data */
+        4:
+          message.data = BlockEventsRPC.internalBinaryRead(reader, reader.uint32(), options, message.data);
+          break;
+        case /* event_provider_api.BasicBlockInfo block */
+        5:
+          message.block = BasicBlockInfo.internalBinaryRead(reader, reader.uint32(), options, message.block);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.v !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.v);
+    if (message.s !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.s);
+    if (message.e !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.e);
+    if (message.data)
+      BlockEventsRPC.internalBinaryWrite(message.data, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    if (message.block)
+      BasicBlockInfo.internalBinaryWrite(message.block, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetBlockEventsRPCResponse = new GetBlockEventsRPCResponse$Type();
+class BlockEventsRPC$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.BlockEventsRPC", [
+      {
+        no: 1,
+        name: "types",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "events",
+        kind: "scalar",
+        repeat: 2,
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      { no: 3, name: "tx_hashes", kind: "map", K: 17, V: {
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      } }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.types = [];
+    message.events = [];
+    message.txHashes = {};
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated string types */
+        1:
+          message.types.push(reader.string());
+          break;
+        case /* repeated bytes events */
+        2:
+          message.events.push(reader.bytes());
+          break;
+        case /* map<sint32, bytes> tx_hashes */
+        3:
+          this.binaryReadMap3(message.txHashes, reader, options);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  binaryReadMap3(map, reader, options) {
+    let len = reader.uint32(), end = reader.pos + len, key, val;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          key = reader.sint32();
+          break;
+        case 2:
+          val = reader.bytes();
+          break;
+        default:
+          throw new globalThis.Error("unknown map entry field for event_provider_api.BlockEventsRPC.tx_hashes");
+      }
+    }
+    map[key ?? 0] = val ?? new Uint8Array(0);
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.types.length; i++)
+      writer.tag(1, WireType.LengthDelimited).string(message.types[i]);
+    for (let i = 0; i < message.events.length; i++)
+      writer.tag(2, WireType.LengthDelimited).bytes(message.events[i]);
+    for (let k of globalThis.Object.keys(message.txHashes))
+      writer.tag(3, WireType.LengthDelimited).fork().tag(1, WireType.Varint).sint32(parseInt(k)).tag(2, WireType.LengthDelimited).bytes(message.txHashes[k]).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const BlockEventsRPC = new BlockEventsRPC$Type();
+class BasicBlockInfo$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.BasicBlockInfo", [
+      {
+        no: 1,
+        name: "height",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "timestamp",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "time",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.height = 0n;
+    message.timestamp = 0n;
+    message.time = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* sint64 height */
+        1:
+          message.height = reader.sint64().toBigInt();
+          break;
+        case /* sint64 timestamp */
+        2:
+          message.timestamp = reader.sint64().toBigInt();
+          break;
+        case /* string time */
+        3:
+          message.time = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.height !== 0n)
+      writer.tag(1, WireType.Varint).sint64(message.height);
+    if (message.timestamp !== 0n)
+      writer.tag(2, WireType.Varint).sint64(message.timestamp);
+    if (message.time !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.time);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const BasicBlockInfo = new BasicBlockInfo$Type();
+class GetCustomEventsRPCRequest$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetCustomEventsRPCRequest", [
+      {
+        no: 1,
+        name: "backend",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "height",
+        kind: "scalar",
+        T: 17
+        /*ScalarType.SINT32*/
+      },
+      {
+        no: 3,
+        name: "events",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.backend = "";
+    message.height = 0;
+    message.events = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string backend */
+        1:
+          message.backend = reader.string();
+          break;
+        case /* sint32 height */
+        2:
+          message.height = reader.sint32();
+          break;
+        case /* string events */
+        3:
+          message.events = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.backend !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.backend);
+    if (message.height !== 0)
+      writer.tag(2, WireType.Varint).sint32(message.height);
+    if (message.events !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.events);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetCustomEventsRPCRequest = new GetCustomEventsRPCRequest$Type();
+class GetCustomEventsRPCResponse$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetCustomEventsRPCResponse", [
+      {
+        no: 1,
+        name: "v",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "s",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "e",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 4, name: "data", kind: "message", T: () => BlockEventsRPC },
+      { no: 5, name: "block", kind: "message", T: () => BasicBlockInfo }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.v = "";
+    message.s = "";
+    message.e = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string v */
+        1:
+          message.v = reader.string();
+          break;
+        case /* string s */
+        2:
+          message.s = reader.string();
+          break;
+        case /* string e */
+        3:
+          message.e = reader.string();
+          break;
+        case /* event_provider_api.BlockEventsRPC data */
+        4:
+          message.data = BlockEventsRPC.internalBinaryRead(reader, reader.uint32(), options, message.data);
+          break;
+        case /* event_provider_api.BasicBlockInfo block */
+        5:
+          message.block = BasicBlockInfo.internalBinaryRead(reader, reader.uint32(), options, message.block);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.v !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.v);
+    if (message.s !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.s);
+    if (message.e !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.e);
+    if (message.data)
+      BlockEventsRPC.internalBinaryWrite(message.data, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    if (message.block)
+      BasicBlockInfo.internalBinaryWrite(message.block, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetCustomEventsRPCResponse = new GetCustomEventsRPCResponse$Type();
+class GetABCIBlockEventsRequest$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetABCIBlockEventsRequest", [
+      {
+        no: 1,
+        name: "height",
+        kind: "scalar",
+        T: 17
+        /*ScalarType.SINT32*/
+      },
+      {
+        no: 2,
+        name: "event_types",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.height = 0;
+    message.eventTypes = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* sint32 height */
+        1:
+          message.height = reader.sint32();
+          break;
+        case /* repeated string event_types */
+        2:
+          message.eventTypes.push(reader.string());
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.height !== 0)
+      writer.tag(1, WireType.Varint).sint32(message.height);
+    for (let i = 0; i < message.eventTypes.length; i++)
+      writer.tag(2, WireType.LengthDelimited).string(message.eventTypes[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetABCIBlockEventsRequest = new GetABCIBlockEventsRequest$Type();
+class GetABCIBlockEventsResponse$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetABCIBlockEventsResponse", [
+      {
+        no: 1,
+        name: "v",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "s",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "e",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 4, name: "raw_block", kind: "message", T: () => RawBlock }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.v = "";
+    message.s = "";
+    message.e = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string v */
+        1:
+          message.v = reader.string();
+          break;
+        case /* string s */
+        2:
+          message.s = reader.string();
+          break;
+        case /* string e */
+        3:
+          message.e = reader.string();
+          break;
+        case /* event_provider_api.RawBlock raw_block */
+        4:
+          message.rawBlock = RawBlock.internalBinaryRead(reader, reader.uint32(), options, message.rawBlock);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.v !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.v);
+    if (message.s !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.s);
+    if (message.e !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.e);
+    if (message.rawBlock)
+      RawBlock.internalBinaryWrite(message.rawBlock, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetABCIBlockEventsResponse = new GetABCIBlockEventsResponse$Type();
+class RawBlock$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.RawBlock", [
+      {
+        no: 1,
+        name: "height",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 5,
+        name: "block_time",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "block_timestamp",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 2, name: "txs_results", kind: "message", repeat: 2, T: () => ABCIResponseDeliverTx },
+      { no: 3, name: "begin_block_events", kind: "message", repeat: 2, T: () => ABCIEvent },
+      { no: 4, name: "end_block_events", kind: "message", repeat: 2, T: () => ABCIEvent }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.height = 0n;
+    message.blockTime = "";
+    message.blockTimestamp = 0n;
+    message.txsResults = [];
+    message.beginBlockEvents = [];
+    message.endBlockEvents = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* sint64 height */
+        1:
+          message.height = reader.sint64().toBigInt();
+          break;
+        case /* string block_time */
+        5:
+          message.blockTime = reader.string();
+          break;
+        case /* sint64 block_timestamp */
+        6:
+          message.blockTimestamp = reader.sint64().toBigInt();
+          break;
+        case /* repeated event_provider_api.ABCIResponseDeliverTx txs_results */
+        2:
+          message.txsResults.push(ABCIResponseDeliverTx.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* repeated event_provider_api.ABCIEvent begin_block_events */
+        3:
+          message.beginBlockEvents.push(ABCIEvent.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* repeated event_provider_api.ABCIEvent end_block_events */
+        4:
+          message.endBlockEvents.push(ABCIEvent.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.height !== 0n)
+      writer.tag(1, WireType.Varint).sint64(message.height);
+    for (let i = 0; i < message.txsResults.length; i++)
+      ABCIResponseDeliverTx.internalBinaryWrite(message.txsResults[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.beginBlockEvents.length; i++)
+      ABCIEvent.internalBinaryWrite(message.beginBlockEvents[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.endBlockEvents.length; i++)
+      ABCIEvent.internalBinaryWrite(message.endBlockEvents[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    if (message.blockTime !== "")
+      writer.tag(5, WireType.LengthDelimited).string(message.blockTime);
+    if (message.blockTimestamp !== 0n)
+      writer.tag(6, WireType.Varint).sint64(message.blockTimestamp);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const RawBlock = new RawBlock$Type();
+class ABCIResponseDeliverTx$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.ABCIResponseDeliverTx", [
+      {
+        no: 1,
+        name: "code",
+        kind: "scalar",
+        T: 17
+        /*ScalarType.SINT32*/
+      },
+      {
+        no: 2,
+        name: "log",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "info",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "gas_wanted",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 5,
+        name: "gas_used",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 6, name: "events", kind: "message", repeat: 2, T: () => ABCIEvent },
+      {
+        no: 7,
+        name: "codespace",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "tx_hash",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.code = 0;
+    message.log = "";
+    message.info = "";
+    message.gasWanted = 0n;
+    message.gasUsed = 0n;
+    message.events = [];
+    message.codespace = "";
+    message.txHash = new Uint8Array(0);
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* sint32 code */
+        1:
+          message.code = reader.sint32();
+          break;
+        case /* string log */
+        2:
+          message.log = reader.string();
+          break;
+        case /* string info */
+        3:
+          message.info = reader.string();
+          break;
+        case /* sint64 gas_wanted */
+        4:
+          message.gasWanted = reader.sint64().toBigInt();
+          break;
+        case /* sint64 gas_used */
+        5:
+          message.gasUsed = reader.sint64().toBigInt();
+          break;
+        case /* repeated event_provider_api.ABCIEvent events */
+        6:
+          message.events.push(ABCIEvent.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* string codespace */
+        7:
+          message.codespace = reader.string();
+          break;
+        case /* bytes tx_hash */
+        8:
+          message.txHash = reader.bytes();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.code !== 0)
+      writer.tag(1, WireType.Varint).sint32(message.code);
+    if (message.log !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.log);
+    if (message.info !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.info);
+    if (message.gasWanted !== 0n)
+      writer.tag(4, WireType.Varint).sint64(message.gasWanted);
+    if (message.gasUsed !== 0n)
+      writer.tag(5, WireType.Varint).sint64(message.gasUsed);
+    for (let i = 0; i < message.events.length; i++)
+      ABCIEvent.internalBinaryWrite(message.events[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+    if (message.codespace !== "")
+      writer.tag(7, WireType.LengthDelimited).string(message.codespace);
+    if (message.txHash.length)
+      writer.tag(8, WireType.LengthDelimited).bytes(message.txHash);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const ABCIResponseDeliverTx = new ABCIResponseDeliverTx$Type();
+class ABCIEvent$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.ABCIEvent", [
+      {
+        no: 1,
+        name: "type",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "attributes", kind: "message", repeat: 2, T: () => ABCIAttribute }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.type = "";
+    message.attributes = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string type */
+        1:
+          message.type = reader.string();
+          break;
+        case /* repeated event_provider_api.ABCIAttribute attributes */
+        2:
+          message.attributes.push(ABCIAttribute.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.type !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.type);
+    for (let i = 0; i < message.attributes.length; i++)
+      ABCIAttribute.internalBinaryWrite(message.attributes[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const ABCIEvent = new ABCIEvent$Type();
+class ABCIAttribute$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.ABCIAttribute", [
+      {
+        no: 1,
+        name: "key",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "value",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.key = "";
+    message.value = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string key */
+        1:
+          message.key = reader.string();
+          break;
+        case /* string value */
+        2:
+          message.value = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.key !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.key);
+    if (message.value !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.value);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const ABCIAttribute = new ABCIAttribute$Type();
+class GetABCIBlockEventsAtHeightRequest$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetABCIBlockEventsAtHeightRequest", [
+      {
+        no: 1,
+        name: "height",
+        kind: "scalar",
+        T: 17
+        /*ScalarType.SINT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.height = 0;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* sint32 height */
+        1:
+          message.height = reader.sint32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.height !== 0)
+      writer.tag(1, WireType.Varint).sint32(message.height);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetABCIBlockEventsAtHeightRequest = new GetABCIBlockEventsAtHeightRequest$Type();
+class GetABCIBlockEventsAtHeightResponse$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.GetABCIBlockEventsAtHeightResponse", [
+      {
+        no: 1,
+        name: "v",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "s",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "e",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 4, name: "raw_block", kind: "message", T: () => RawBlock }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.v = "";
+    message.s = "";
+    message.e = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string v */
+        1:
+          message.v = reader.string();
+          break;
+        case /* string s */
+        2:
+          message.s = reader.string();
+          break;
+        case /* string e */
+        3:
+          message.e = reader.string();
+          break;
+        case /* event_provider_api.RawBlock raw_block */
+        4:
+          message.rawBlock = RawBlock.internalBinaryRead(reader, reader.uint32(), options, message.rawBlock);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.v !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.v);
+    if (message.s !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.s);
+    if (message.e !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.e);
+    if (message.rawBlock)
+      RawBlock.internalBinaryWrite(message.rawBlock, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetABCIBlockEventsAtHeightResponse = new GetABCIBlockEventsAtHeightResponse$Type();
+const EventProviderAPI = new ServiceType("event_provider_api.EventProviderAPI", [
+  { name: "GetLatestHeight", options: {}, I: GetLatestHeightRequest, O: GetLatestHeightResponse },
+  { name: "StreamLatestHeight", serverStreaming: true, options: {}, I: StreamLatestHeightRequest, O: StreamLatestHeightResponse },
+  { name: "StreamBlockEvents", serverStreaming: true, options: {}, I: StreamBlockEventsRequest, O: StreamBlockEventsResponse },
+  { name: "GetBlockEventsRPC", options: {}, I: GetBlockEventsRPCRequest, O: GetBlockEventsRPCResponse },
+  { name: "GetCustomEventsRPC", options: {}, I: GetCustomEventsRPCRequest, O: GetCustomEventsRPCResponse },
+  { name: "GetABCIBlockEvents", options: {}, I: GetABCIBlockEventsRequest, O: GetABCIBlockEventsResponse },
+  { name: "GetABCIBlockEventsAtHeight", options: {}, I: GetABCIBlockEventsAtHeightRequest, O: GetABCIBlockEventsAtHeightResponse }
+]);
+export {
+  ABCIAttribute,
+  ABCIEvent,
+  ABCIResponseDeliverTx,
+  BasicBlockInfo,
+  Block,
+  BlockEvent,
+  BlockEventsRPC,
+  EventProviderAPI,
+  GetABCIBlockEventsAtHeightRequest,
+  GetABCIBlockEventsAtHeightResponse,
+  GetABCIBlockEventsRequest,
+  GetABCIBlockEventsResponse,
+  GetBlockEventsRPCRequest,
+  GetBlockEventsRPCResponse,
+  GetCustomEventsRPCRequest,
+  GetCustomEventsRPCResponse,
+  GetLatestHeightRequest,
+  GetLatestHeightResponse,
+  LatestBlockHeight,
+  RawBlock,
+  StreamBlockEventsRequest,
+  StreamBlockEventsResponse,
+  StreamLatestHeightRequest,
+  StreamLatestHeightResponse
+};