@injectivelabs/indexer-proto-ts-v2 1.18.20 → 1.18.22

package/generated/event_provider_api_pb.client.d.ts

@@ -12,6 +12,8 @@
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
 import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
 import { EventProviderAPI } from "./event_provider_api_pb";
+import type { StreamABCIEventsResponse } from "./event_provider_api_pb";
+import type { StreamABCIEventsRequest } from "./event_provider_api_pb";
 import type { GetABCIBlockEventsAtHeightResponse } from "./event_provider_api_pb";
 import type { GetABCIBlockEventsAtHeightRequest } from "./event_provider_api_pb";
 import type { GetABCIBlockEventsResponse } from "./event_provider_api_pb";
@@ -78,6 +80,12 @@ export interface IEventProviderAPIClient {
      * @generated from protobuf rpc: GetABCIBlockEventsAtHeight
      */
     getABCIBlockEventsAtHeight(input: GetABCIBlockEventsAtHeightRequest, options?: RpcOptions): UnaryCall<GetABCIBlockEventsAtHeightRequest, GetABCIBlockEventsAtHeightResponse>;
+    /**
+     * Stream raw block events for selected height
+     *
+     * @generated from protobuf rpc: StreamABCIEvents
+     */
+    streamABCIEvents(input: StreamABCIEventsRequest, options?: RpcOptions): ServerStreamingCall<StreamABCIEventsRequest, StreamABCIEventsResponse>;
 }
 /**
  * EventProviderAPI provides processed block events for different backends.
@@ -153,4 +161,13 @@ export class EventProviderAPIClient implements IEventProviderAPIClient, ServiceI
         const method = this.methods[6], opt = this._transport.mergeOptions(options);
         return stackIntercept<GetABCIBlockEventsAtHeightRequest, GetABCIBlockEventsAtHeightResponse>("unary", this._transport, method, opt, input);
     }
+    /**
+     * Stream raw block events for selected height
+     *
+     * @generated from protobuf rpc: StreamABCIEvents
+     */
+    streamABCIEvents(input: StreamABCIEventsRequest, options?: RpcOptions): ServerStreamingCall<StreamABCIEventsRequest, StreamABCIEventsResponse> {
+        const method = this.methods[7], opt = this._transport.mergeOptions(options);
+        return stackIntercept<StreamABCIEventsRequest, StreamABCIEventsResponse>("serverStreaming", this._transport, method, opt, input);
+    }
 }

package/generated/event_provider_api_pb.client.js

@@ -70,6 +70,15 @@ class EventProviderAPIClient {
     const method = this.methods[6], opt = this._transport.mergeOptions(options);
     return stackIntercept("unary", this._transport, method, opt, input);
   }
+  /**
+   * Stream raw block events for selected height
+   *
+   * @generated from protobuf rpc: StreamABCIEvents
+   */
+  streamABCIEvents(input, options) {
+    const method = this.methods[7], opt = this._transport.mergeOptions(options);
+    return stackIntercept("serverStreaming", this._transport, method, opt, input);
+  }
 }
 export {
   EventProviderAPIClient

package/generated/event_provider_api_pb.d.ts

@@ -500,6 +500,83 @@ export interface GetABCIBlockEventsAtHeightResponse {
      */
     rawBlock?: RawBlock;
 }
+/**
+ * @generated from protobuf message event_provider_api.StreamABCIEventsRequest
+ */
+export interface StreamABCIEventsRequest {
+    /**
+     * @generated from protobuf field: sint32 height = 1
+     */
+    height: number;
+    /**
+     * Array of event types
+     *
+     * @generated from protobuf field: repeated string event_types = 2
+     */
+    eventTypes: string[];
+    /**
+     * Number of blocks to include in each stream response. The service will have a
+     * cap on the batch size, and default to it if it's greater. Once the stream is
+     * in sync, the batch size
+     *
+     * @generated from protobuf field: uint32 batch_size = 3
+     */
+    batchSize: number;
+    /**
+     * Number of parallel fetchers. The service will have a cap on the number of
+     * fetchers, and default to it. The service may chose to throttle the fetchers
+     * based on the current load.
+     *
+     * @generated from protobuf field: uint32 fetchers = 4
+     */
+    fetchers: number;
+}
+/**
+ * @generated from protobuf message event_provider_api.StreamABCIEventsResponse
+ */
+export interface StreamABCIEventsResponse {
+    /**
+     * @generated from protobuf field: repeated event_provider_api.StreamedRawBlock blocks = 1
+     */
+    blocks: StreamedRawBlock[];
+}
+/**
+ * @generated from protobuf message event_provider_api.StreamedRawBlock
+ */
+export interface StreamedRawBlock {
+    /**
+     * Indicates whether the block is the latest one available in the event provider
+     *
+     * @generated from protobuf field: bool in_sync = 20
+     */
+    inSync: boolean;
+    /**
+     * @generated from protobuf field: sint64 height = 1
+     */
+    height: bigint;
+    /**
+     * @generated from protobuf field: string block_time = 5
+     */
+    blockTime: string;
+    /**
+     * Block timestamp in UNIX millis.
+     *
+     * @generated from protobuf field: sint64 block_timestamp = 6
+     */
+    blockTimestamp: bigint;
+    /**
+     * @generated from protobuf field: repeated event_provider_api.ABCIResponseDeliverTx txs_results = 2
+     */
+    txsResults: ABCIResponseDeliverTx[];
+    /**
+     * @generated from protobuf field: repeated event_provider_api.ABCIEvent begin_block_events = 3
+     */
+    beginBlockEvents: ABCIEvent[];
+    /**
+     * @generated from protobuf field: repeated event_provider_api.ABCIEvent end_block_events = 4
+     */
+    endBlockEvents: ABCIEvent[];
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class GetLatestHeightRequest$Type extends MessageType<GetLatestHeightRequest> {
     constructor() {
@@ -1980,6 +2057,219 @@ class GetABCIBlockEventsAtHeightResponse$Type extends MessageType<GetABCIBlockEv
  * @generated MessageType for protobuf message event_provider_api.GetABCIBlockEventsAtHeightResponse
  */
 export const GetABCIBlockEventsAtHeightResponse = new GetABCIBlockEventsAtHeightResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamABCIEventsRequest$Type extends MessageType<StreamABCIEventsRequest> {
+    constructor() {
+        super("event_provider_api.StreamABCIEventsRequest", [
+            { no: 1, name: "height", kind: "scalar", T: 17 /*ScalarType.SINT32*/ },
+            { no: 2, name: "event_types", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "batch_size", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 4, name: "fetchers", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+    create(value?: PartialMessage<StreamABCIEventsRequest>): StreamABCIEventsRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.height = 0;
+        message.eventTypes = [];
+        message.batchSize = 0;
+        message.fetchers = 0;
+        if (value !== undefined)
+            reflectionMergePartial<StreamABCIEventsRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamABCIEventsRequest): StreamABCIEventsRequest {
+        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;
+                case /* uint32 batch_size */ 3:
+                    message.batchSize = reader.uint32();
+                    break;
+                case /* uint32 fetchers */ 4:
+                    message.fetchers = reader.uint32();
+                    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: StreamABCIEventsRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sint32 height = 1; */
+        if (message.height !== 0)
+            writer.tag(1, WireType.Varint).sint32(message.height);
+        /* repeated string event_types = 2; */
+        for (let i = 0; i < message.eventTypes.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.eventTypes[i]);
+        /* uint32 batch_size = 3; */
+        if (message.batchSize !== 0)
+            writer.tag(3, WireType.Varint).uint32(message.batchSize);
+        /* uint32 fetchers = 4; */
+        if (message.fetchers !== 0)
+            writer.tag(4, WireType.Varint).uint32(message.fetchers);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.StreamABCIEventsRequest
+ */
+export const StreamABCIEventsRequest = new StreamABCIEventsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamABCIEventsResponse$Type extends MessageType<StreamABCIEventsResponse> {
+    constructor() {
+        super("event_provider_api.StreamABCIEventsResponse", [
+            { no: 1, name: "blocks", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => StreamedRawBlock }
+        ]);
+    }
+    create(value?: PartialMessage<StreamABCIEventsResponse>): StreamABCIEventsResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.blocks = [];
+        if (value !== undefined)
+            reflectionMergePartial<StreamABCIEventsResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamABCIEventsResponse): StreamABCIEventsResponse {
+        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.StreamedRawBlock blocks */ 1:
+                    message.blocks.push(StreamedRawBlock.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: StreamABCIEventsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated event_provider_api.StreamedRawBlock blocks = 1; */
+        for (let i = 0; i < message.blocks.length; i++)
+            StreamedRawBlock.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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.StreamABCIEventsResponse
+ */
+export const StreamABCIEventsResponse = new StreamABCIEventsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamedRawBlock$Type extends MessageType<StreamedRawBlock> {
+    constructor() {
+        super("event_provider_api.StreamedRawBlock", [
+            { no: 20, name: "in_sync", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 1, name: "height", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 5, name: "block_time", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "block_timestamp", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "txs_results", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ABCIResponseDeliverTx },
+            { no: 3, name: "begin_block_events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ABCIEvent },
+            { no: 4, name: "end_block_events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ABCIEvent }
+        ]);
+    }
+    create(value?: PartialMessage<StreamedRawBlock>): StreamedRawBlock {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.inSync = false;
+        message.height = 0n;
+        message.blockTime = "";
+        message.blockTimestamp = 0n;
+        message.txsResults = [];
+        message.beginBlockEvents = [];
+        message.endBlockEvents = [];
+        if (value !== undefined)
+            reflectionMergePartial<StreamedRawBlock>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamedRawBlock): StreamedRawBlock {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool in_sync */ 20:
+                    message.inSync = reader.bool();
+                    break;
+                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: StreamedRawBlock, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sint64 height = 1; */
+        if (message.height !== 0n)
+            writer.tag(1, WireType.Varint).sint64(message.height);
+        /* repeated event_provider_api.ABCIResponseDeliverTx txs_results = 2; */
+        for (let i = 0; i < message.txsResults.length; i++)
+            ABCIResponseDeliverTx.internalBinaryWrite(message.txsResults[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* repeated event_provider_api.ABCIEvent begin_block_events = 3; */
+        for (let i = 0; i < message.beginBlockEvents.length; i++)
+            ABCIEvent.internalBinaryWrite(message.beginBlockEvents[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated event_provider_api.ABCIEvent end_block_events = 4; */
+        for (let i = 0; i < message.endBlockEvents.length; i++)
+            ABCIEvent.internalBinaryWrite(message.endBlockEvents[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* string block_time = 5; */
+        if (message.blockTime !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.blockTime);
+        /* sint64 block_timestamp = 6; */
+        if (message.blockTimestamp !== 0n)
+            writer.tag(6, WireType.Varint).sint64(message.blockTimestamp);
+        /* bool in_sync = 20; */
+        if (message.inSync !== false)
+            writer.tag(20, WireType.Varint).bool(message.inSync);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.StreamedRawBlock
+ */
+export const StreamedRawBlock = new StreamedRawBlock$Type();
 /**
  * @generated ServiceType for protobuf service event_provider_api.EventProviderAPI
  */
@@ -1990,5 +2280,6 @@ export const EventProviderAPI = new ServiceType("event_provider_api.EventProvide
     { 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 }
+    { name: "GetABCIBlockEventsAtHeight", options: {}, I: GetABCIBlockEventsAtHeightRequest, O: GetABCIBlockEventsAtHeightResponse },
+    { name: "StreamABCIEvents", serverStreaming: true, options: {}, I: StreamABCIEventsRequest, O: StreamABCIEventsResponse }
 ]);

package/generated/event_provider_api_pb.js

@@ -1753,6 +1753,258 @@ class GetABCIBlockEventsAtHeightResponse$Type extends MessageType {
   }
 }
 const GetABCIBlockEventsAtHeightResponse = new GetABCIBlockEventsAtHeightResponse$Type();
+class StreamABCIEventsRequest$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.StreamABCIEventsRequest", [
+      {
+        no: 1,
+        name: "height",
+        kind: "scalar",
+        T: 17
+        /*ScalarType.SINT32*/
+      },
+      {
+        no: 2,
+        name: "event_types",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "batch_size",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 4,
+        name: "fetchers",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.height = 0;
+    message.eventTypes = [];
+    message.batchSize = 0;
+    message.fetchers = 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;
+        case /* repeated string event_types */
+        2:
+          message.eventTypes.push(reader.string());
+          break;
+        case /* uint32 batch_size */
+        3:
+          message.batchSize = reader.uint32();
+          break;
+        case /* uint32 fetchers */
+        4:
+          message.fetchers = reader.uint32();
+          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]);
+    if (message.batchSize !== 0)
+      writer.tag(3, WireType.Varint).uint32(message.batchSize);
+    if (message.fetchers !== 0)
+      writer.tag(4, WireType.Varint).uint32(message.fetchers);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const StreamABCIEventsRequest = new StreamABCIEventsRequest$Type();
+class StreamABCIEventsResponse$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.StreamABCIEventsResponse", [
+      { no: 1, name: "blocks", kind: "message", repeat: 2, T: () => StreamedRawBlock }
+    ]);
+  }
+  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.StreamedRawBlock blocks */
+        1:
+          message.blocks.push(StreamedRawBlock.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++)
+      StreamedRawBlock.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 StreamABCIEventsResponse = new StreamABCIEventsResponse$Type();
+class StreamedRawBlock$Type extends MessageType {
+  constructor() {
+    super("event_provider_api.StreamedRawBlock", [
+      {
+        no: 20,
+        name: "in_sync",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        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.inSync = false;
+    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 /* bool in_sync */
+        20:
+          message.inSync = reader.bool();
+          break;
+        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);
+    if (message.inSync !== false)
+      writer.tag(20, WireType.Varint).bool(message.inSync);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const StreamedRawBlock = new StreamedRawBlock$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 },
@@ -1760,7 +2012,8 @@ const EventProviderAPI = new ServiceType("event_provider_api.EventProviderAPI",
   { 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 }
+  { name: "GetABCIBlockEventsAtHeight", options: {}, I: GetABCIBlockEventsAtHeightRequest, O: GetABCIBlockEventsAtHeightResponse },
+  { name: "StreamABCIEvents", serverStreaming: true, options: {}, I: StreamABCIEventsRequest, O: StreamABCIEventsResponse }
 ]);
 export {
   ABCIAttribute,
@@ -1783,8 +2036,11 @@ export {
   GetLatestHeightResponse,
   LatestBlockHeight,
   RawBlock,
+  StreamABCIEventsRequest,
+  StreamABCIEventsResponse,
   StreamBlockEventsRequest,
   StreamBlockEventsResponse,
   StreamLatestHeightRequest,
-  StreamLatestHeightResponse
+  StreamLatestHeightResponse,
+  StreamedRawBlock
 };