@injectivelabs/indexer-proto-ts-v2 1.0.0

package/generated/event_provider_api_pb.d.ts

@@ -0,0 +1,1980 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "event_provider_api.proto" (package "event_provider_api", syntax proto3)
+// tslint:disable
+//
+// Code generated with goa v3.7.0, DO NOT EDIT.
+//
+// EventProviderAPI protocol buffer definition
+//
+// Command:
+// $ goa gen github.com/InjectiveLabs/injective-indexer/api/design -o ../
+//
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * @generated from protobuf message event_provider_api.GetLatestHeightRequest
+ */
+export interface GetLatestHeightRequest {
+}
+/**
+ * @generated from protobuf message event_provider_api.GetLatestHeightResponse
+ */
+export interface GetLatestHeightResponse {
+    /**
+     * Response version.
+     *
+     * @generated from protobuf field: string v = 1
+     */
+    v: string;
+    /**
+     * Status of the response.
+     *
+     * @generated from protobuf field: string s = 2
+     */
+    s: string;
+    /**
+     * Error message.
+     *
+     * @generated from protobuf field: string e = 3
+     */
+    e: string;
+    /**
+     * @generated from protobuf field: event_provider_api.LatestBlockHeight data = 4
+     */
+    data?: LatestBlockHeight;
+}
+/**
+ * Latest block height from event provider db
+ *
+ * @generated from protobuf message event_provider_api.LatestBlockHeight
+ */
+export interface LatestBlockHeight {
+    /**
+     * @generated from protobuf field: uint64 height = 1
+     */
+    height: bigint;
+    /**
+     * @generated from protobuf field: sint64 time = 2
+     */
+    time: bigint;
+}
+/**
+ * @generated from protobuf message event_provider_api.StreamLatestHeightRequest
+ */
+export interface StreamLatestHeightRequest {
+}
+/**
+ * @generated from protobuf message event_provider_api.StreamLatestHeightResponse
+ */
+export interface StreamLatestHeightResponse {
+    /**
+     * @generated from protobuf field: uint64 height = 1
+     */
+    height: bigint;
+    /**
+     * @generated from protobuf field: sint64 time = 2
+     */
+    time: bigint;
+}
+/**
+ * @generated from protobuf message event_provider_api.StreamBlockEventsRequest
+ */
+export interface StreamBlockEventsRequest {
+    /**
+     * Select backend processor
+     *
+     * @generated from protobuf field: string backend = 1
+     */
+    backend: string;
+    /**
+     * @generated from protobuf field: sint32 height = 2
+     */
+    height: number;
+}
+/**
+ * @generated from protobuf message event_provider_api.StreamBlockEventsResponse
+ */
+export interface StreamBlockEventsResponse {
+    /**
+     * @generated from protobuf field: repeated event_provider_api.Block blocks = 1
+     */
+    blocks: Block[];
+}
+/**
+ * @generated from protobuf message event_provider_api.Block
+ */
+export interface Block {
+    /**
+     * @generated from protobuf field: sint64 height = 1
+     */
+    height: bigint;
+    /**
+     * @generated from protobuf field: string version = 2
+     */
+    version: string;
+    /**
+     * Processed block events in the block
+     *
+     * @generated from protobuf field: repeated event_provider_api.BlockEvent events = 3
+     */
+    events: BlockEvent[];
+    /**
+     * Indicates whether the block is the latest one available in the event provider
+     *
+     * @generated from protobuf field: bool in_sync = 4
+     */
+    inSync: boolean;
+    /**
+     * Block timestamp in UNIX millis.
+     *
+     * @generated from protobuf field: sint64 time = 5
+     */
+    time: bigint;
+}
+/**
+ * @generated from protobuf message event_provider_api.BlockEvent
+ */
+export interface BlockEvent {
+    /**
+     * Event type
+     *
+     * @generated from protobuf field: string type_url = 1
+     */
+    typeUrl: string;
+    /**
+     * Event data
+     *
+     * @generated from protobuf field: bytes value = 2
+     */
+    value: Uint8Array;
+    /**
+     * TX hash
+     *
+     * @generated from protobuf field: bytes tx_hash = 3
+     */
+    txHash: Uint8Array;
+    /**
+     * Set only if it's a BeginBlock or EndBlock event
+     *
+     * @generated from protobuf field: string mode = 4
+     */
+    mode: string;
+}
+/**
+ * @generated from protobuf message event_provider_api.GetBlockEventsRPCRequest
+ */
+export interface GetBlockEventsRPCRequest {
+    /**
+     * Select backend processor
+     *
+     * @generated from protobuf field: string backend = 1
+     */
+    backend: string;
+    /**
+     * @generated from protobuf field: sint32 height = 2
+     */
+    height: number;
+    /**
+     * @generated from protobuf field: bool human_readable = 3
+     */
+    humanReadable: boolean;
+}
+/**
+ * @generated from protobuf message event_provider_api.GetBlockEventsRPCResponse
+ */
+export interface GetBlockEventsRPCResponse {
+    /**
+     * Response version.
+     *
+     * @generated from protobuf field: string v = 1
+     */
+    v: string;
+    /**
+     * Status of the response.
+     *
+     * @generated from protobuf field: string s = 2
+     */
+    s: string;
+    /**
+     * Error message.
+     *
+     * @generated from protobuf field: string e = 3
+     */
+    e: string;
+    /**
+     * @generated from protobuf field: event_provider_api.BlockEventsRPC data = 4
+     */
+    data?: BlockEventsRPC;
+    /**
+     * @generated from protobuf field: event_provider_api.BasicBlockInfo block = 5
+     */
+    block?: BasicBlockInfo;
+}
+/**
+ * Processed block events for backend processor to consume
+ *
+ * @generated from protobuf message event_provider_api.BlockEventsRPC
+ */
+export interface BlockEventsRPC {
+    /**
+     * Array of event types
+     *
+     * @generated from protobuf field: repeated string types = 1
+     */
+    types: string[];
+    /**
+     * Array of parsed events
+     *
+     * @generated from protobuf field: repeated bytes events = 2
+     */
+    events: Uint8Array[];
+    /**
+     * Map of event index - tx hash
+     *
+     * @generated from protobuf field: map<sint32, bytes> tx_hashes = 3
+     */
+    txHashes: {
+        [key: number]: Uint8Array;
+    };
+}
+/**
+ * Block info
+ *
+ * @generated from protobuf message event_provider_api.BasicBlockInfo
+ */
+export interface BasicBlockInfo {
+    /**
+     * Block height
+     *
+     * @generated from protobuf field: sint64 height = 1
+     */
+    height: bigint;
+    /**
+     * Block timestamp in UNIX millis.
+     *
+     * @generated from protobuf field: sint64 timestamp = 2
+     */
+    timestamp: bigint;
+    /**
+     * Block time in RFC3339 format.
+     *
+     * @generated from protobuf field: string time = 3
+     */
+    time: string;
+}
+/**
+ * @generated from protobuf message event_provider_api.GetCustomEventsRPCRequest
+ */
+export interface GetCustomEventsRPCRequest {
+    /**
+     * Select backend processor
+     *
+     * @generated from protobuf field: string backend = 1
+     */
+    backend: string;
+    /**
+     * @generated from protobuf field: sint32 height = 2
+     */
+    height: number;
+    /**
+     * Specify custom events to get
+     *
+     * @generated from protobuf field: string events = 3
+     */
+    events: string;
+}
+/**
+ * @generated from protobuf message event_provider_api.GetCustomEventsRPCResponse
+ */
+export interface GetCustomEventsRPCResponse {
+    /**
+     * Response version.
+     *
+     * @generated from protobuf field: string v = 1
+     */
+    v: string;
+    /**
+     * Status of the response.
+     *
+     * @generated from protobuf field: string s = 2
+     */
+    s: string;
+    /**
+     * Error message.
+     *
+     * @generated from protobuf field: string e = 3
+     */
+    e: string;
+    /**
+     * @generated from protobuf field: event_provider_api.BlockEventsRPC data = 4
+     */
+    data?: BlockEventsRPC;
+    /**
+     * @generated from protobuf field: event_provider_api.BasicBlockInfo block = 5
+     */
+    block?: BasicBlockInfo;
+}
+/**
+ * @generated from protobuf message event_provider_api.GetABCIBlockEventsRequest
+ */
+export interface GetABCIBlockEventsRequest {
+    /**
+     * @generated from protobuf field: sint32 height = 1
+     */
+    height: number;
+    /**
+     * Array of event types
+     *
+     * @generated from protobuf field: repeated string event_types = 2
+     */
+    eventTypes: string[];
+}
+/**
+ * @generated from protobuf message event_provider_api.GetABCIBlockEventsResponse
+ */
+export interface GetABCIBlockEventsResponse {
+    /**
+     * Response version.
+     *
+     * @generated from protobuf field: string v = 1
+     */
+    v: string;
+    /**
+     * Status of the response.
+     *
+     * @generated from protobuf field: string s = 2
+     */
+    s: string;
+    /**
+     * Error message.
+     *
+     * @generated from protobuf field: string e = 3
+     */
+    e: string;
+    /**
+     * @generated from protobuf field: event_provider_api.RawBlock raw_block = 4
+     */
+    rawBlock?: RawBlock;
+}
+/**
+ * @generated from protobuf message event_provider_api.RawBlock
+ */
+export interface RawBlock {
+    /**
+     * @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 from protobuf message event_provider_api.ABCIResponseDeliverTx
+ */
+export interface ABCIResponseDeliverTx {
+    /**
+     * @generated from protobuf field: sint32 code = 1
+     */
+    code: number;
+    /**
+     * @generated from protobuf field: string log = 2
+     */
+    log: string;
+    /**
+     * @generated from protobuf field: string info = 3
+     */
+    info: string;
+    /**
+     * @generated from protobuf field: sint64 gas_wanted = 4
+     */
+    gasWanted: bigint;
+    /**
+     * @generated from protobuf field: sint64 gas_used = 5
+     */
+    gasUsed: bigint;
+    /**
+     * @generated from protobuf field: repeated event_provider_api.ABCIEvent events = 6
+     */
+    events: ABCIEvent[];
+    /**
+     * @generated from protobuf field: string codespace = 7
+     */
+    codespace: string;
+    /**
+     * @generated from protobuf field: bytes tx_hash = 8
+     */
+    txHash: Uint8Array;
+}
+/**
+ * @generated from protobuf message event_provider_api.ABCIEvent
+ */
+export interface ABCIEvent {
+    /**
+     * @generated from protobuf field: string type = 1
+     */
+    type: string;
+    /**
+     * @generated from protobuf field: repeated event_provider_api.ABCIAttribute attributes = 2
+     */
+    attributes: ABCIAttribute[];
+}
+/**
+ * @generated from protobuf message event_provider_api.ABCIAttribute
+ */
+export interface ABCIAttribute {
+    /**
+     * @generated from protobuf field: string key = 1
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: string value = 2
+     */
+    value: string;
+}
+/**
+ * @generated from protobuf message event_provider_api.GetABCIBlockEventsAtHeightRequest
+ */
+export interface GetABCIBlockEventsAtHeightRequest {
+    /**
+     * @generated from protobuf field: sint32 height = 1
+     */
+    height: number;
+}
+/**
+ * @generated from protobuf message event_provider_api.GetABCIBlockEventsAtHeightResponse
+ */
+export interface GetABCIBlockEventsAtHeightResponse {
+    /**
+     * Response version.
+     *
+     * @generated from protobuf field: string v = 1
+     */
+    v: string;
+    /**
+     * Status of the response.
+     *
+     * @generated from protobuf field: string s = 2
+     */
+    s: string;
+    /**
+     * Error message.
+     *
+     * @generated from protobuf field: string e = 3
+     */
+    e: string;
+    /**
+     * @generated from protobuf field: event_provider_api.RawBlock raw_block = 4
+     */
+    rawBlock?: RawBlock;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class GetLatestHeightRequest$Type extends MessageType<GetLatestHeightRequest> {
+    constructor() {
+        super("event_provider_api.GetLatestHeightRequest", []);
+    }
+    create(value?: PartialMessage<GetLatestHeightRequest>): GetLatestHeightRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<GetLatestHeightRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetLatestHeightRequest): GetLatestHeightRequest {
+        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: GetLatestHeightRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        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.GetLatestHeightRequest
+ */
+export const GetLatestHeightRequest = new GetLatestHeightRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetLatestHeightResponse$Type extends MessageType<GetLatestHeightResponse> {
+    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?: PartialMessage<GetLatestHeightResponse>): GetLatestHeightResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.v = "";
+        message.s = "";
+        message.e = "";
+        if (value !== undefined)
+            reflectionMergePartial<GetLatestHeightResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetLatestHeightResponse): GetLatestHeightResponse {
+        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: GetLatestHeightResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string v = 1; */
+        if (message.v !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.v);
+        /* string s = 2; */
+        if (message.s !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.s);
+        /* string e = 3; */
+        if (message.e !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.e);
+        /* event_provider_api.LatestBlockHeight data = 4; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.GetLatestHeightResponse
+ */
+export const GetLatestHeightResponse = new GetLatestHeightResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LatestBlockHeight$Type extends MessageType<LatestBlockHeight> {
+    constructor() {
+        super("event_provider_api.LatestBlockHeight", [
+            { no: 1, name: "height", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "time", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value?: PartialMessage<LatestBlockHeight>): LatestBlockHeight {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.height = 0n;
+        message.time = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<LatestBlockHeight>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LatestBlockHeight): LatestBlockHeight {
+        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: LatestBlockHeight, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint64 height = 1; */
+        if (message.height !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.height);
+        /* sint64 time = 2; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.LatestBlockHeight
+ */
+export const LatestBlockHeight = new LatestBlockHeight$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamLatestHeightRequest$Type extends MessageType<StreamLatestHeightRequest> {
+    constructor() {
+        super("event_provider_api.StreamLatestHeightRequest", []);
+    }
+    create(value?: PartialMessage<StreamLatestHeightRequest>): StreamLatestHeightRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<StreamLatestHeightRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamLatestHeightRequest): StreamLatestHeightRequest {
+        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: StreamLatestHeightRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        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.StreamLatestHeightRequest
+ */
+export const StreamLatestHeightRequest = new StreamLatestHeightRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamLatestHeightResponse$Type extends MessageType<StreamLatestHeightResponse> {
+    constructor() {
+        super("event_provider_api.StreamLatestHeightResponse", [
+            { no: 1, name: "height", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "time", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value?: PartialMessage<StreamLatestHeightResponse>): StreamLatestHeightResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.height = 0n;
+        message.time = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<StreamLatestHeightResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamLatestHeightResponse): StreamLatestHeightResponse {
+        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: StreamLatestHeightResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint64 height = 1; */
+        if (message.height !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.height);
+        /* sint64 time = 2; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.StreamLatestHeightResponse
+ */
+export const StreamLatestHeightResponse = new StreamLatestHeightResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamBlockEventsRequest$Type extends MessageType<StreamBlockEventsRequest> {
+    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?: PartialMessage<StreamBlockEventsRequest>): StreamBlockEventsRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.backend = "";
+        message.height = 0;
+        if (value !== undefined)
+            reflectionMergePartial<StreamBlockEventsRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamBlockEventsRequest): StreamBlockEventsRequest {
+        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: StreamBlockEventsRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string backend = 1; */
+        if (message.backend !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.backend);
+        /* sint32 height = 2; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.StreamBlockEventsRequest
+ */
+export const StreamBlockEventsRequest = new StreamBlockEventsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamBlockEventsResponse$Type extends MessageType<StreamBlockEventsResponse> {
+    constructor() {
+        super("event_provider_api.StreamBlockEventsResponse", [
+            { no: 1, name: "blocks", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Block }
+        ]);
+    }
+    create(value?: PartialMessage<StreamBlockEventsResponse>): StreamBlockEventsResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.blocks = [];
+        if (value !== undefined)
+            reflectionMergePartial<StreamBlockEventsResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamBlockEventsResponse): StreamBlockEventsResponse {
+        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: StreamBlockEventsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated event_provider_api.Block blocks = 1; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.StreamBlockEventsResponse
+ */
+export const StreamBlockEventsResponse = new StreamBlockEventsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Block$Type extends MessageType<Block> {
+    constructor() {
+        super("event_provider_api.Block", [
+            { no: 1, name: "height", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => BlockEvent },
+            { no: 4, name: "in_sync", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "time", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Block>): Block {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.height = 0n;
+        message.version = "";
+        message.events = [];
+        message.inSync = false;
+        message.time = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<Block>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Block): Block {
+        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: Block, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sint64 height = 1; */
+        if (message.height !== 0n)
+            writer.tag(1, WireType.Varint).sint64(message.height);
+        /* string version = 2; */
+        if (message.version !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.version);
+        /* repeated event_provider_api.BlockEvent events = 3; */
+        for (let i = 0; i < message.events.length; i++)
+            BlockEvent.internalBinaryWrite(message.events[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* bool in_sync = 4; */
+        if (message.inSync !== false)
+            writer.tag(4, WireType.Varint).bool(message.inSync);
+        /* sint64 time = 5; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.Block
+ */
+export const Block = new Block$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BlockEvent$Type extends MessageType<BlockEvent> {
+    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?: PartialMessage<BlockEvent>): BlockEvent {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.typeUrl = "";
+        message.value = new Uint8Array(0);
+        message.txHash = new Uint8Array(0);
+        message.mode = "";
+        if (value !== undefined)
+            reflectionMergePartial<BlockEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BlockEvent): BlockEvent {
+        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: BlockEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string type_url = 1; */
+        if (message.typeUrl !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.typeUrl);
+        /* bytes value = 2; */
+        if (message.value.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.value);
+        /* bytes tx_hash = 3; */
+        if (message.txHash.length)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.txHash);
+        /* string mode = 4; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.BlockEvent
+ */
+export const BlockEvent = new BlockEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetBlockEventsRPCRequest$Type extends MessageType<GetBlockEventsRPCRequest> {
+    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?: PartialMessage<GetBlockEventsRPCRequest>): GetBlockEventsRPCRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.backend = "";
+        message.height = 0;
+        message.humanReadable = false;
+        if (value !== undefined)
+            reflectionMergePartial<GetBlockEventsRPCRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetBlockEventsRPCRequest): GetBlockEventsRPCRequest {
+        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: GetBlockEventsRPCRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string backend = 1; */
+        if (message.backend !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.backend);
+        /* sint32 height = 2; */
+        if (message.height !== 0)
+            writer.tag(2, WireType.Varint).sint32(message.height);
+        /* bool human_readable = 3; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.GetBlockEventsRPCRequest
+ */
+export const GetBlockEventsRPCRequest = new GetBlockEventsRPCRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetBlockEventsRPCResponse$Type extends MessageType<GetBlockEventsRPCResponse> {
+    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?: PartialMessage<GetBlockEventsRPCResponse>): GetBlockEventsRPCResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.v = "";
+        message.s = "";
+        message.e = "";
+        if (value !== undefined)
+            reflectionMergePartial<GetBlockEventsRPCResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetBlockEventsRPCResponse): GetBlockEventsRPCResponse {
+        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: GetBlockEventsRPCResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string v = 1; */
+        if (message.v !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.v);
+        /* string s = 2; */
+        if (message.s !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.s);
+        /* string e = 3; */
+        if (message.e !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.e);
+        /* event_provider_api.BlockEventsRPC data = 4; */
+        if (message.data)
+            BlockEventsRPC.internalBinaryWrite(message.data, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* event_provider_api.BasicBlockInfo block = 5; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.GetBlockEventsRPCResponse
+ */
+export const GetBlockEventsRPCResponse = new GetBlockEventsRPCResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BlockEventsRPC$Type extends MessageType<BlockEventsRPC> {
+    constructor() {
+        super("event_provider_api.BlockEventsRPC", [
+            { no: 1, name: "types", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "events", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "tx_hashes", kind: "map", K: 17 /*ScalarType.SINT32*/, V: { kind: "scalar", T: 12 /*ScalarType.BYTES*/ } }
+        ]);
+    }
+    create(value?: PartialMessage<BlockEventsRPC>): BlockEventsRPC {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.types = [];
+        message.events = [];
+        message.txHashes = {};
+        if (value !== undefined)
+            reflectionMergePartial<BlockEventsRPC>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BlockEventsRPC): BlockEventsRPC {
+        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;
+    }
+    private binaryReadMap3(map: BlockEventsRPC["txHashes"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof BlockEventsRPC["txHashes"] | undefined, val: BlockEventsRPC["txHashes"][any] | undefined;
+        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: BlockEventsRPC, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated string types = 1; */
+        for (let i = 0; i < message.types.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.types[i]);
+        /* repeated bytes events = 2; */
+        for (let i = 0; i < message.events.length; i++)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.events[i]);
+        /* map<sint32, bytes> tx_hashes = 3; */
+        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 as any]).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.BlockEventsRPC
+ */
+export const BlockEventsRPC = new BlockEventsRPC$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BasicBlockInfo$Type extends MessageType<BasicBlockInfo> {
+    constructor() {
+        super("event_provider_api.BasicBlockInfo", [
+            { no: 1, name: "height", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "timestamp", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "time", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<BasicBlockInfo>): BasicBlockInfo {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.height = 0n;
+        message.timestamp = 0n;
+        message.time = "";
+        if (value !== undefined)
+            reflectionMergePartial<BasicBlockInfo>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BasicBlockInfo): BasicBlockInfo {
+        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: BasicBlockInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sint64 height = 1; */
+        if (message.height !== 0n)
+            writer.tag(1, WireType.Varint).sint64(message.height);
+        /* sint64 timestamp = 2; */
+        if (message.timestamp !== 0n)
+            writer.tag(2, WireType.Varint).sint64(message.timestamp);
+        /* string time = 3; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.BasicBlockInfo
+ */
+export const BasicBlockInfo = new BasicBlockInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetCustomEventsRPCRequest$Type extends MessageType<GetCustomEventsRPCRequest> {
+    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?: PartialMessage<GetCustomEventsRPCRequest>): GetCustomEventsRPCRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.backend = "";
+        message.height = 0;
+        message.events = "";
+        if (value !== undefined)
+            reflectionMergePartial<GetCustomEventsRPCRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetCustomEventsRPCRequest): GetCustomEventsRPCRequest {
+        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: GetCustomEventsRPCRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string backend = 1; */
+        if (message.backend !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.backend);
+        /* sint32 height = 2; */
+        if (message.height !== 0)
+            writer.tag(2, WireType.Varint).sint32(message.height);
+        /* string events = 3; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.GetCustomEventsRPCRequest
+ */
+export const GetCustomEventsRPCRequest = new GetCustomEventsRPCRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetCustomEventsRPCResponse$Type extends MessageType<GetCustomEventsRPCResponse> {
+    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?: PartialMessage<GetCustomEventsRPCResponse>): GetCustomEventsRPCResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.v = "";
+        message.s = "";
+        message.e = "";
+        if (value !== undefined)
+            reflectionMergePartial<GetCustomEventsRPCResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetCustomEventsRPCResponse): GetCustomEventsRPCResponse {
+        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: GetCustomEventsRPCResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string v = 1; */
+        if (message.v !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.v);
+        /* string s = 2; */
+        if (message.s !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.s);
+        /* string e = 3; */
+        if (message.e !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.e);
+        /* event_provider_api.BlockEventsRPC data = 4; */
+        if (message.data)
+            BlockEventsRPC.internalBinaryWrite(message.data, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* event_provider_api.BasicBlockInfo block = 5; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.GetCustomEventsRPCResponse
+ */
+export const GetCustomEventsRPCResponse = new GetCustomEventsRPCResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetABCIBlockEventsRequest$Type extends MessageType<GetABCIBlockEventsRequest> {
+    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 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<GetABCIBlockEventsRequest>): GetABCIBlockEventsRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.height = 0;
+        message.eventTypes = [];
+        if (value !== undefined)
+            reflectionMergePartial<GetABCIBlockEventsRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetABCIBlockEventsRequest): GetABCIBlockEventsRequest {
+        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: GetABCIBlockEventsRequest, 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]);
+        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.GetABCIBlockEventsRequest
+ */
+export const GetABCIBlockEventsRequest = new GetABCIBlockEventsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetABCIBlockEventsResponse$Type extends MessageType<GetABCIBlockEventsResponse> {
+    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?: PartialMessage<GetABCIBlockEventsResponse>): GetABCIBlockEventsResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.v = "";
+        message.s = "";
+        message.e = "";
+        if (value !== undefined)
+            reflectionMergePartial<GetABCIBlockEventsResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetABCIBlockEventsResponse): GetABCIBlockEventsResponse {
+        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: GetABCIBlockEventsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string v = 1; */
+        if (message.v !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.v);
+        /* string s = 2; */
+        if (message.s !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.s);
+        /* string e = 3; */
+        if (message.e !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.e);
+        /* event_provider_api.RawBlock raw_block = 4; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.GetABCIBlockEventsResponse
+ */
+export const GetABCIBlockEventsResponse = new GetABCIBlockEventsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RawBlock$Type extends MessageType<RawBlock> {
+    constructor() {
+        super("event_provider_api.RawBlock", [
+            { 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<RawBlock>): RawBlock {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.height = 0n;
+        message.blockTime = "";
+        message.blockTimestamp = 0n;
+        message.txsResults = [];
+        message.beginBlockEvents = [];
+        message.endBlockEvents = [];
+        if (value !== undefined)
+            reflectionMergePartial<RawBlock>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RawBlock): RawBlock {
+        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: RawBlock, 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);
+        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.RawBlock
+ */
+export const RawBlock = new RawBlock$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ABCIResponseDeliverTx$Type extends MessageType<ABCIResponseDeliverTx> {
+    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 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 5, name: "gas_used", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 6, name: "events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, 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?: PartialMessage<ABCIResponseDeliverTx>): ABCIResponseDeliverTx {
+        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 !== undefined)
+            reflectionMergePartial<ABCIResponseDeliverTx>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ABCIResponseDeliverTx): ABCIResponseDeliverTx {
+        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: ABCIResponseDeliverTx, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sint32 code = 1; */
+        if (message.code !== 0)
+            writer.tag(1, WireType.Varint).sint32(message.code);
+        /* string log = 2; */
+        if (message.log !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.log);
+        /* string info = 3; */
+        if (message.info !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.info);
+        /* sint64 gas_wanted = 4; */
+        if (message.gasWanted !== 0n)
+            writer.tag(4, WireType.Varint).sint64(message.gasWanted);
+        /* sint64 gas_used = 5; */
+        if (message.gasUsed !== 0n)
+            writer.tag(5, WireType.Varint).sint64(message.gasUsed);
+        /* repeated event_provider_api.ABCIEvent events = 6; */
+        for (let i = 0; i < message.events.length; i++)
+            ABCIEvent.internalBinaryWrite(message.events[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* string codespace = 7; */
+        if (message.codespace !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.codespace);
+        /* bytes tx_hash = 8; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.ABCIResponseDeliverTx
+ */
+export const ABCIResponseDeliverTx = new ABCIResponseDeliverTx$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ABCIEvent$Type extends MessageType<ABCIEvent> {
+    constructor() {
+        super("event_provider_api.ABCIEvent", [
+            { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "attributes", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ABCIAttribute }
+        ]);
+    }
+    create(value?: PartialMessage<ABCIEvent>): ABCIEvent {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.type = "";
+        message.attributes = [];
+        if (value !== undefined)
+            reflectionMergePartial<ABCIEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ABCIEvent): ABCIEvent {
+        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: ABCIEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string type = 1; */
+        if (message.type !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.type);
+        /* repeated event_provider_api.ABCIAttribute attributes = 2; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.ABCIEvent
+ */
+export const ABCIEvent = new ABCIEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ABCIAttribute$Type extends MessageType<ABCIAttribute> {
+    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?: PartialMessage<ABCIAttribute>): ABCIAttribute {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.value = "";
+        if (value !== undefined)
+            reflectionMergePartial<ABCIAttribute>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ABCIAttribute): ABCIAttribute {
+        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: ABCIAttribute, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* string value = 2; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.ABCIAttribute
+ */
+export const ABCIAttribute = new ABCIAttribute$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetABCIBlockEventsAtHeightRequest$Type extends MessageType<GetABCIBlockEventsAtHeightRequest> {
+    constructor() {
+        super("event_provider_api.GetABCIBlockEventsAtHeightRequest", [
+            { no: 1, name: "height", kind: "scalar", T: 17 /*ScalarType.SINT32*/ }
+        ]);
+    }
+    create(value?: PartialMessage<GetABCIBlockEventsAtHeightRequest>): GetABCIBlockEventsAtHeightRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.height = 0;
+        if (value !== undefined)
+            reflectionMergePartial<GetABCIBlockEventsAtHeightRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetABCIBlockEventsAtHeightRequest): GetABCIBlockEventsAtHeightRequest {
+        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: GetABCIBlockEventsAtHeightRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sint32 height = 1; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.GetABCIBlockEventsAtHeightRequest
+ */
+export const GetABCIBlockEventsAtHeightRequest = new GetABCIBlockEventsAtHeightRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetABCIBlockEventsAtHeightResponse$Type extends MessageType<GetABCIBlockEventsAtHeightResponse> {
+    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?: PartialMessage<GetABCIBlockEventsAtHeightResponse>): GetABCIBlockEventsAtHeightResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.v = "";
+        message.s = "";
+        message.e = "";
+        if (value !== undefined)
+            reflectionMergePartial<GetABCIBlockEventsAtHeightResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetABCIBlockEventsAtHeightResponse): GetABCIBlockEventsAtHeightResponse {
+        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: GetABCIBlockEventsAtHeightResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string v = 1; */
+        if (message.v !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.v);
+        /* string s = 2; */
+        if (message.s !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.s);
+        /* string e = 3; */
+        if (message.e !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.e);
+        /* event_provider_api.RawBlock raw_block = 4; */
+        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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message event_provider_api.GetABCIBlockEventsAtHeightResponse
+ */
+export const GetABCIBlockEventsAtHeightResponse = new GetABCIBlockEventsAtHeightResponse$Type();
+/**
+ * @generated ServiceType for protobuf service event_provider_api.EventProviderAPI
+ */
+export 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 }
+]);