@injectivelabs/indexer-proto-ts-v2 1.0.0

package/generated/injective_meta_rpc_pb.d.ts

@@ -0,0 +1,825 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "injective_meta_rpc.proto" (package "injective_meta_rpc", syntax proto3)
+// tslint:disable
+//
+// Code generated with goa v3.7.0, DO NOT EDIT.
+//
+// InjectiveMetaRPC 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 injective_meta_rpc.PingRequest
+ */
+export interface PingRequest {
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.PingResponse
+ */
+export interface PingResponse {
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.VersionRequest
+ */
+export interface VersionRequest {
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.VersionResponse
+ */
+export interface VersionResponse {
+    /**
+     * injective-exchange code version.
+     *
+     * @generated from protobuf field: string version = 1
+     */
+    version: string;
+    /**
+     * Additional build meta info.
+     *
+     * @generated from protobuf field: map<string, string> build = 2
+     */
+    build: {
+        [key: string]: string;
+    };
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.InfoRequest
+ */
+export interface InfoRequest {
+    /**
+     * Provide current system UNIX timestamp in millis
+     *
+     * @generated from protobuf field: sint64 timestamp = 1
+     */
+    timestamp: bigint;
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.InfoResponse
+ */
+export interface InfoResponse {
+    /**
+     * The original timestamp value in millis.
+     *
+     * @generated from protobuf field: sint64 timestamp = 1
+     */
+    timestamp: bigint;
+    /**
+     * UNIX time on the server in millis.
+     *
+     * @generated from protobuf field: sint64 server_time = 2
+     */
+    serverTime: bigint;
+    /**
+     * injective-exchange code version.
+     *
+     * @generated from protobuf field: string version = 3
+     */
+    version: string;
+    /**
+     * Additional build meta info.
+     *
+     * @generated from protobuf field: map<string, string> build = 4
+     */
+    build: {
+        [key: string]: string;
+    };
+    /**
+     * Server's location region
+     *
+     * @generated from protobuf field: string region = 5
+     */
+    region: string;
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.StreamKeepaliveRequest
+ */
+export interface StreamKeepaliveRequest {
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.StreamKeepaliveResponse
+ */
+export interface StreamKeepaliveResponse {
+    /**
+     * Server event
+     *
+     * @generated from protobuf field: string event = 1
+     */
+    event: string;
+    /**
+     * New conection endpoint for the gRPC API
+     *
+     * @generated from protobuf field: string new_endpoint = 2
+     */
+    newEndpoint: string;
+    /**
+     * Operation timestamp in UNIX millis.
+     *
+     * @generated from protobuf field: sint64 timestamp = 3
+     */
+    timestamp: bigint;
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.TokenMetadataRequest
+ */
+export interface TokenMetadataRequest {
+    /**
+     * @generated from protobuf field: repeated string denoms = 1
+     */
+    denoms: string[];
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.TokenMetadataResponse
+ */
+export interface TokenMetadataResponse {
+    /**
+     * tokens and their metadata list
+     *
+     * @generated from protobuf field: repeated injective_meta_rpc.TokenMetadataElement tokens = 1
+     */
+    tokens: TokenMetadataElement[];
+}
+/**
+ * @generated from protobuf message injective_meta_rpc.TokenMetadataElement
+ */
+export interface TokenMetadataElement {
+    /**
+     * Token's Ethereum address, not all token have this information
+     *
+     * @generated from protobuf field: string ethereum_address = 1
+     */
+    ethereumAddress: string;
+    /**
+     * Token's CoinGecko id for price references
+     *
+     * @generated from protobuf field: string coingecko_id = 2
+     */
+    coingeckoId: string;
+    /**
+     * Token's denom on injective chain
+     *
+     * @generated from protobuf field: string denom = 3
+     */
+    denom: string;
+    /**
+     * Token name
+     *
+     * @generated from protobuf field: string name = 4
+     */
+    name: string;
+    /**
+     * Token symbol
+     *
+     * @generated from protobuf field: string symbol = 5
+     */
+    symbol: string;
+    /**
+     * Number of decimal places used to represent the token's smallest unit
+     *
+     * @generated from protobuf field: sint32 decimals = 6
+     */
+    decimals: number;
+    /**
+     * Token logo URL
+     *
+     * @generated from protobuf field: string logo = 7
+     */
+    logo: string;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class PingRequest$Type extends MessageType<PingRequest> {
+    constructor() {
+        super("injective_meta_rpc.PingRequest", []);
+    }
+    create(value?: PartialMessage<PingRequest>): PingRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<PingRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PingRequest): PingRequest {
+        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: PingRequest, 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 injective_meta_rpc.PingRequest
+ */
+export const PingRequest = new PingRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PingResponse$Type extends MessageType<PingResponse> {
+    constructor() {
+        super("injective_meta_rpc.PingResponse", []);
+    }
+    create(value?: PartialMessage<PingResponse>): PingResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<PingResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PingResponse): PingResponse {
+        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: PingResponse, 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 injective_meta_rpc.PingResponse
+ */
+export const PingResponse = new PingResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class VersionRequest$Type extends MessageType<VersionRequest> {
+    constructor() {
+        super("injective_meta_rpc.VersionRequest", []);
+    }
+    create(value?: PartialMessage<VersionRequest>): VersionRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<VersionRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: VersionRequest): VersionRequest {
+        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: VersionRequest, 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 injective_meta_rpc.VersionRequest
+ */
+export const VersionRequest = new VersionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class VersionResponse$Type extends MessageType<VersionResponse> {
+    constructor() {
+        super("injective_meta_rpc.VersionResponse", [
+            { no: 1, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "build", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } }
+        ]);
+    }
+    create(value?: PartialMessage<VersionResponse>): VersionResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.version = "";
+        message.build = {};
+        if (value !== undefined)
+            reflectionMergePartial<VersionResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: VersionResponse): VersionResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string version */ 1:
+                    message.version = reader.string();
+                    break;
+                case /* map<string, string> build */ 2:
+                    this.binaryReadMap2(message.build, 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 binaryReadMap2(map: VersionResponse["build"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof VersionResponse["build"] | undefined, val: VersionResponse["build"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = reader.string();
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for injective_meta_rpc.VersionResponse.build");
+            }
+        }
+        map[key ?? ""] = val ?? "";
+    }
+    internalBinaryWrite(message: VersionResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string version = 1; */
+        if (message.version !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.version);
+        /* map<string, string> build = 2; */
+        for (let k of globalThis.Object.keys(message.build))
+            writer.tag(2, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.build[k]).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message injective_meta_rpc.VersionResponse
+ */
+export const VersionResponse = new VersionResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InfoRequest$Type extends MessageType<InfoRequest> {
+    constructor() {
+        super("injective_meta_rpc.InfoRequest", [
+            { no: 1, name: "timestamp", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value?: PartialMessage<InfoRequest>): InfoRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.timestamp = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<InfoRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: InfoRequest): InfoRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sint64 timestamp */ 1:
+                    message.timestamp = 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: InfoRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sint64 timestamp = 1; */
+        if (message.timestamp !== 0n)
+            writer.tag(1, WireType.Varint).sint64(message.timestamp);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message injective_meta_rpc.InfoRequest
+ */
+export const InfoRequest = new InfoRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InfoResponse$Type extends MessageType<InfoResponse> {
+    constructor() {
+        super("injective_meta_rpc.InfoResponse", [
+            { no: 1, name: "timestamp", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "server_time", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "build", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } },
+            { no: 5, name: "region", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<InfoResponse>): InfoResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.timestamp = 0n;
+        message.serverTime = 0n;
+        message.version = "";
+        message.build = {};
+        message.region = "";
+        if (value !== undefined)
+            reflectionMergePartial<InfoResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: InfoResponse): InfoResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sint64 timestamp */ 1:
+                    message.timestamp = reader.sint64().toBigInt();
+                    break;
+                case /* sint64 server_time */ 2:
+                    message.serverTime = reader.sint64().toBigInt();
+                    break;
+                case /* string version */ 3:
+                    message.version = reader.string();
+                    break;
+                case /* map<string, string> build */ 4:
+                    this.binaryReadMap4(message.build, reader, options);
+                    break;
+                case /* string region */ 5:
+                    message.region = 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;
+    }
+    private binaryReadMap4(map: InfoResponse["build"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof InfoResponse["build"] | undefined, val: InfoResponse["build"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = reader.string();
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for injective_meta_rpc.InfoResponse.build");
+            }
+        }
+        map[key ?? ""] = val ?? "";
+    }
+    internalBinaryWrite(message: InfoResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sint64 timestamp = 1; */
+        if (message.timestamp !== 0n)
+            writer.tag(1, WireType.Varint).sint64(message.timestamp);
+        /* sint64 server_time = 2; */
+        if (message.serverTime !== 0n)
+            writer.tag(2, WireType.Varint).sint64(message.serverTime);
+        /* string version = 3; */
+        if (message.version !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.version);
+        /* map<string, string> build = 4; */
+        for (let k of globalThis.Object.keys(message.build))
+            writer.tag(4, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.build[k]).join();
+        /* string region = 5; */
+        if (message.region !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.region);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message injective_meta_rpc.InfoResponse
+ */
+export const InfoResponse = new InfoResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamKeepaliveRequest$Type extends MessageType<StreamKeepaliveRequest> {
+    constructor() {
+        super("injective_meta_rpc.StreamKeepaliveRequest", []);
+    }
+    create(value?: PartialMessage<StreamKeepaliveRequest>): StreamKeepaliveRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<StreamKeepaliveRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamKeepaliveRequest): StreamKeepaliveRequest {
+        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: StreamKeepaliveRequest, 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 injective_meta_rpc.StreamKeepaliveRequest
+ */
+export const StreamKeepaliveRequest = new StreamKeepaliveRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamKeepaliveResponse$Type extends MessageType<StreamKeepaliveResponse> {
+    constructor() {
+        super("injective_meta_rpc.StreamKeepaliveResponse", [
+            { no: 1, name: "event", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "new_endpoint", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "timestamp", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value?: PartialMessage<StreamKeepaliveResponse>): StreamKeepaliveResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.event = "";
+        message.newEndpoint = "";
+        message.timestamp = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<StreamKeepaliveResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamKeepaliveResponse): StreamKeepaliveResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string event */ 1:
+                    message.event = reader.string();
+                    break;
+                case /* string new_endpoint */ 2:
+                    message.newEndpoint = reader.string();
+                    break;
+                case /* sint64 timestamp */ 3:
+                    message.timestamp = 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: StreamKeepaliveResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string event = 1; */
+        if (message.event !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.event);
+        /* string new_endpoint = 2; */
+        if (message.newEndpoint !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.newEndpoint);
+        /* sint64 timestamp = 3; */
+        if (message.timestamp !== 0n)
+            writer.tag(3, WireType.Varint).sint64(message.timestamp);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message injective_meta_rpc.StreamKeepaliveResponse
+ */
+export const StreamKeepaliveResponse = new StreamKeepaliveResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TokenMetadataRequest$Type extends MessageType<TokenMetadataRequest> {
+    constructor() {
+        super("injective_meta_rpc.TokenMetadataRequest", [
+            { no: 1, name: "denoms", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<TokenMetadataRequest>): TokenMetadataRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.denoms = [];
+        if (value !== undefined)
+            reflectionMergePartial<TokenMetadataRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TokenMetadataRequest): TokenMetadataRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated string denoms */ 1:
+                    message.denoms.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: TokenMetadataRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated string denoms = 1; */
+        for (let i = 0; i < message.denoms.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.denoms[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message injective_meta_rpc.TokenMetadataRequest
+ */
+export const TokenMetadataRequest = new TokenMetadataRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TokenMetadataResponse$Type extends MessageType<TokenMetadataResponse> {
+    constructor() {
+        super("injective_meta_rpc.TokenMetadataResponse", [
+            { no: 1, name: "tokens", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TokenMetadataElement }
+        ]);
+    }
+    create(value?: PartialMessage<TokenMetadataResponse>): TokenMetadataResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.tokens = [];
+        if (value !== undefined)
+            reflectionMergePartial<TokenMetadataResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TokenMetadataResponse): TokenMetadataResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated injective_meta_rpc.TokenMetadataElement tokens */ 1:
+                    message.tokens.push(TokenMetadataElement.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: TokenMetadataResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated injective_meta_rpc.TokenMetadataElement tokens = 1; */
+        for (let i = 0; i < message.tokens.length; i++)
+            TokenMetadataElement.internalBinaryWrite(message.tokens[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 injective_meta_rpc.TokenMetadataResponse
+ */
+export const TokenMetadataResponse = new TokenMetadataResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TokenMetadataElement$Type extends MessageType<TokenMetadataElement> {
+    constructor() {
+        super("injective_meta_rpc.TokenMetadataElement", [
+            { no: 1, name: "ethereum_address", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "coingecko_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "denom", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "symbol", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "decimals", kind: "scalar", T: 17 /*ScalarType.SINT32*/ },
+            { no: 7, name: "logo", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<TokenMetadataElement>): TokenMetadataElement {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.ethereumAddress = "";
+        message.coingeckoId = "";
+        message.denom = "";
+        message.name = "";
+        message.symbol = "";
+        message.decimals = 0;
+        message.logo = "";
+        if (value !== undefined)
+            reflectionMergePartial<TokenMetadataElement>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TokenMetadataElement): TokenMetadataElement {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string ethereum_address */ 1:
+                    message.ethereumAddress = reader.string();
+                    break;
+                case /* string coingecko_id */ 2:
+                    message.coingeckoId = reader.string();
+                    break;
+                case /* string denom */ 3:
+                    message.denom = reader.string();
+                    break;
+                case /* string name */ 4:
+                    message.name = reader.string();
+                    break;
+                case /* string symbol */ 5:
+                    message.symbol = reader.string();
+                    break;
+                case /* sint32 decimals */ 6:
+                    message.decimals = reader.sint32();
+                    break;
+                case /* string logo */ 7:
+                    message.logo = 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: TokenMetadataElement, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string ethereum_address = 1; */
+        if (message.ethereumAddress !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.ethereumAddress);
+        /* string coingecko_id = 2; */
+        if (message.coingeckoId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.coingeckoId);
+        /* string denom = 3; */
+        if (message.denom !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.denom);
+        /* string name = 4; */
+        if (message.name !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.name);
+        /* string symbol = 5; */
+        if (message.symbol !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.symbol);
+        /* sint32 decimals = 6; */
+        if (message.decimals !== 0)
+            writer.tag(6, WireType.Varint).sint32(message.decimals);
+        /* string logo = 7; */
+        if (message.logo !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.logo);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message injective_meta_rpc.TokenMetadataElement
+ */
+export const TokenMetadataElement = new TokenMetadataElement$Type();
+/**
+ * @generated ServiceType for protobuf service injective_meta_rpc.InjectiveMetaRPC
+ */
+export const InjectiveMetaRPC = new ServiceType("injective_meta_rpc.InjectiveMetaRPC", [
+    { name: "Ping", options: {}, I: PingRequest, O: PingResponse },
+    { name: "Version", options: {}, I: VersionRequest, O: VersionResponse },
+    { name: "Info", options: {}, I: InfoRequest, O: InfoResponse },
+    { name: "StreamKeepalive", serverStreaming: true, options: {}, I: StreamKeepaliveRequest, O: StreamKeepaliveResponse },
+    { name: "TokenMetadata", options: {}, I: TokenMetadataRequest, O: TokenMetadataResponse }
+]);