@bandprotocol/bandchain.js/esm/codegen/band/feeds/v1beta1/query.js

TypeScript library for Cosmos SDK and BandChain

//@ts-nocheck
import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
import { CurrentFeedWithDeviations, Price, ReferenceSourceConfig, Signal, ValidatorPrice } from "./feeds";
import { Params } from "./params";
import { BinaryReader, BinaryWriter } from "../../../binary";
function createBaseQueryCurrentFeedsRequest() {
    return {};
}
export const QueryCurrentFeedsRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryCurrentFeedsRequest",
    encode(_, writer = BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryCurrentFeedsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseQueryCurrentFeedsRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseQueryCurrentFeedsRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return QueryCurrentFeedsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryCurrentFeedsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryCurrentFeedsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryCurrentFeedsRequest",
            value: QueryCurrentFeedsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryCurrentFeedsResponse() {
    return {
        currentFeeds: CurrentFeedWithDeviations.fromPartial({})
    };
}
export const QueryCurrentFeedsResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryCurrentFeedsResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.currentFeeds !== undefined) {
            CurrentFeedWithDeviations.encode(message.currentFeeds, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryCurrentFeedsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.currentFeeds = CurrentFeedWithDeviations.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryCurrentFeedsResponse();
        message.currentFeeds = object.currentFeeds !== undefined && object.currentFeeds !== null ? CurrentFeedWithDeviations.fromPartial(object.currentFeeds) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryCurrentFeedsResponse();
        if (object.current_feeds !== undefined && object.current_feeds !== null) {
            message.currentFeeds = CurrentFeedWithDeviations.fromAmino(object.current_feeds);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.current_feeds = message.currentFeeds ? CurrentFeedWithDeviations.toAmino(message.currentFeeds) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryCurrentFeedsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryCurrentFeedsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryCurrentFeedsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryCurrentFeedsResponse",
            value: QueryCurrentFeedsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryIsFeederRequest() {
    return {
        validator: "",
        feeder: ""
    };
}
export const QueryIsFeederRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryIsFeederRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.validator !== "") {
            writer.uint32(10).string(message.validator);
        }
        if (message.feeder !== "") {
            writer.uint32(18).string(message.feeder);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryIsFeederRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validator = reader.string();
                    break;
                case 2:
                    message.feeder = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryIsFeederRequest();
        message.validator = object.validator ?? "";
        message.feeder = object.feeder ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryIsFeederRequest();
        if (object.validator !== undefined && object.validator !== null) {
            message.validator = object.validator;
        }
        if (object.feeder !== undefined && object.feeder !== null) {
            message.feeder = object.feeder;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.validator = message.validator === "" ? undefined : message.validator;
        obj.feeder = message.feeder === "" ? undefined : message.feeder;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryIsFeederRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryIsFeederRequest.decode(message.value);
    },
    toProto(message) {
        return QueryIsFeederRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryIsFeederRequest",
            value: QueryIsFeederRequest.encode(message).finish()
        };
    }
};
function createBaseQueryIsFeederResponse() {
    return {
        isFeeder: false
    };
}
export const QueryIsFeederResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryIsFeederResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.isFeeder === true) {
            writer.uint32(8).bool(message.isFeeder);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryIsFeederResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.isFeeder = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryIsFeederResponse();
        message.isFeeder = object.isFeeder ?? false;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryIsFeederResponse();
        if (object.is_feeder !== undefined && object.is_feeder !== null) {
            message.isFeeder = object.is_feeder;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.is_feeder = message.isFeeder === false ? undefined : message.isFeeder;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryIsFeederResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryIsFeederResponse.decode(message.value);
    },
    toProto(message) {
        return QueryIsFeederResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryIsFeederResponse",
            value: QueryIsFeederResponse.encode(message).finish()
        };
    }
};
function createBaseQueryParamsRequest() {
    return {};
}
export const QueryParamsRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryParamsRequest",
    encode(_, writer = BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryParamsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseQueryParamsRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseQueryParamsRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return QueryParamsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryParamsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryParamsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryParamsRequest",
            value: QueryParamsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryParamsResponse() {
    return {
        params: Params.fromPartial({})
    };
}
export const QueryParamsResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryParamsResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.params !== undefined) {
            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryParamsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.params = Params.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryParamsResponse();
        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryParamsResponse();
        if (object.params !== undefined && object.params !== null) {
            message.params = Params.fromAmino(object.params);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.params = message.params ? Params.toAmino(message.params) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryParamsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryParamsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryParamsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryParamsResponse",
            value: QueryParamsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryPriceRequest() {
    return {
        signalId: ""
    };
}
export const QueryPriceRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryPriceRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.signalId !== "") {
            writer.uint32(10).string(message.signalId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryPriceRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalId = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPriceRequest();
        message.signalId = object.signalId ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPriceRequest();
        if (object.signal_id !== undefined && object.signal_id !== null) {
            message.signalId = object.signal_id;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.signal_id = message.signalId === "" ? undefined : message.signalId;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPriceRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPriceRequest.decode(message.value);
    },
    toProto(message) {
        return QueryPriceRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryPriceRequest",
            value: QueryPriceRequest.encode(message).finish()
        };
    }
};
function createBaseQueryPriceResponse() {
    return {
        price: Price.fromPartial({})
    };
}
export const QueryPriceResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryPriceResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.price !== undefined) {
            Price.encode(message.price, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryPriceResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.price = Price.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPriceResponse();
        message.price = object.price !== undefined && object.price !== null ? Price.fromPartial(object.price) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPriceResponse();
        if (object.price !== undefined && object.price !== null) {
            message.price = Price.fromAmino(object.price);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.price = message.price ? Price.toAmino(message.price) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPriceResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPriceResponse.decode(message.value);
    },
    toProto(message) {
        return QueryPriceResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryPriceResponse",
            value: QueryPriceResponse.encode(message).finish()
        };
    }
};
function createBaseQueryPricesRequest() {
    return {
        signalIds: []
    };
}
export const QueryPricesRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryPricesRequest",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.signalIds) {
            writer.uint32(10).string(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryPricesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalIds.push(reader.string());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPricesRequest();
        message.signalIds = object.signalIds?.map(e => e) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPricesRequest();
        message.signalIds = object.signal_ids?.map(e => e) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.signalIds) {
            obj.signal_ids = message.signalIds.map(e => e);
        }
        else {
            obj.signal_ids = message.signalIds;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPricesRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPricesRequest.decode(message.value);
    },
    toProto(message) {
        return QueryPricesRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryPricesRequest",
            value: QueryPricesRequest.encode(message).finish()
        };
    }
};
function createBaseQueryPricesResponse() {
    return {
        prices: []
    };
}
export const QueryPricesResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryPricesResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.prices) {
            Price.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryPricesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.prices.push(Price.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPricesResponse();
        message.prices = object.prices?.map(e => Price.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPricesResponse();
        message.prices = object.prices?.map(e => Price.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.prices) {
            obj.prices = message.prices.map(e => e ? Price.toAmino(e) : undefined);
        }
        else {
            obj.prices = message.prices;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPricesResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPricesResponse.decode(message.value);
    },
    toProto(message) {
        return QueryPricesResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryPricesResponse",
            value: QueryPricesResponse.encode(message).finish()
        };
    }
};
function createBaseQueryAllPricesRequest() {
    return {
        pagination: undefined
    };
}
export const QueryAllPricesRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryAllPricesRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryAllPricesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryAllPricesRequest();
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryAllPricesRequest();
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryAllPricesRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryAllPricesRequest.decode(message.value);
    },
    toProto(message) {
        return QueryAllPricesRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryAllPricesRequest",
            value: QueryAllPricesRequest.encode(message).finish()
        };
    }
};
function createBaseQueryAllPricesResponse() {
    return {
        prices: [],
        pagination: undefined
    };
}
export const QueryAllPricesResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryAllPricesResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.prices) {
            Price.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryAllPricesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.prices.push(Price.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryAllPricesResponse();
        message.prices = object.prices?.map(e => Price.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryAllPricesResponse();
        message.prices = object.prices?.map(e => Price.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.prices) {
            obj.prices = message.prices.map(e => e ? Price.toAmino(e) : undefined);
        }
        else {
            obj.prices = message.prices;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryAllPricesResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryAllPricesResponse.decode(message.value);
    },
    toProto(message) {
        return QueryAllPricesResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryAllPricesResponse",
            value: QueryAllPricesResponse.encode(message).finish()
        };
    }
};
function createBaseQueryReferenceSourceConfigRequest() {
    return {};
}
export const QueryReferenceSourceConfigRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryReferenceSourceConfigRequest",
    encode(_, writer = BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryReferenceSourceConfigRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseQueryReferenceSourceConfigRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseQueryReferenceSourceConfigRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return QueryReferenceSourceConfigRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryReferenceSourceConfigRequest.decode(message.value);
    },
    toProto(message) {
        return QueryReferenceSourceConfigRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryReferenceSourceConfigRequest",
            value: QueryReferenceSourceConfigRequest.encode(message).finish()
        };
    }
};
function createBaseQueryReferenceSourceConfigResponse() {
    return {
        referenceSourceConfig: ReferenceSourceConfig.fromPartial({})
    };
}
export const QueryReferenceSourceConfigResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryReferenceSourceConfigResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.referenceSourceConfig !== undefined) {
            ReferenceSourceConfig.encode(message.referenceSourceConfig, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryReferenceSourceConfigResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.referenceSourceConfig = ReferenceSourceConfig.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryReferenceSourceConfigResponse();
        message.referenceSourceConfig = object.referenceSourceConfig !== undefined && object.referenceSourceConfig !== null ? ReferenceSourceConfig.fromPartial(object.referenceSourceConfig) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryReferenceSourceConfigResponse();
        if (object.reference_source_config !== undefined && object.reference_source_config !== null) {
            message.referenceSourceConfig = ReferenceSourceConfig.fromAmino(object.reference_source_config);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.reference_source_config = message.referenceSourceConfig ? ReferenceSourceConfig.toAmino(message.referenceSourceConfig) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryReferenceSourceConfigResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryReferenceSourceConfigResponse.decode(message.value);
    },
    toProto(message) {
        return QueryReferenceSourceConfigResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryReferenceSourceConfigResponse",
            value: QueryReferenceSourceConfigResponse.encode(message).finish()
        };
    }
};
function createBaseQuerySignalTotalPowersRequest() {
    return {
        signalIds: [],
        pagination: undefined
    };
}
export const QuerySignalTotalPowersRequest = {
    typeUrl: "/band.feeds.v1beta1.QuerySignalTotalPowersRequest",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.signalIds) {
            writer.uint32(10).string(v);
        }
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQuerySignalTotalPowersRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalIds.push(reader.string());
                    break;
                case 2:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQuerySignalTotalPowersRequest();
        message.signalIds = object.signalIds?.map(e => e) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQuerySignalTotalPowersRequest();
        message.signalIds = object.signal_ids?.map(e => e) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.signalIds) {
            obj.signal_ids = message.signalIds.map(e => e);
        }
        else {
            obj.signal_ids = message.signalIds;
        }
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QuerySignalTotalPowersRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QuerySignalTotalPowersRequest.decode(message.value);
    },
    toProto(message) {
        return QuerySignalTotalPowersRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QuerySignalTotalPowersRequest",
            value: QuerySignalTotalPowersRequest.encode(message).finish()
        };
    }
};
function createBaseQuerySignalTotalPowersResponse() {
    return {
        signalTotalPowers: [],
        pagination: undefined
    };
}
export const QuerySignalTotalPowersResponse = {
    typeUrl: "/band.feeds.v1beta1.QuerySignalTotalPowersResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.signalTotalPowers) {
            Signal.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQuerySignalTotalPowersResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalTotalPowers.push(Signal.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQuerySignalTotalPowersResponse();
        message.signalTotalPowers = object.signalTotalPowers?.map(e => Signal.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQuerySignalTotalPowersResponse();
        message.signalTotalPowers = object.signal_total_powers?.map(e => Signal.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.signalTotalPowers) {
            obj.signal_total_powers = message.signalTotalPowers.map(e => e ? Signal.toAmino(e) : undefined);
        }
        else {
            obj.signal_total_powers = message.signalTotalPowers;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QuerySignalTotalPowersResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QuerySignalTotalPowersResponse.decode(message.value);
    },
    toProto(message) {
        return QuerySignalTotalPowersResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QuerySignalTotalPowersResponse",
            value: QuerySignalTotalPowersResponse.encode(message).finish()
        };
    }
};
function createBaseQueryValidValidatorRequest() {
    return {
        validator: ""
    };
}
export const QueryValidValidatorRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryValidValidatorRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.validator !== "") {
            writer.uint32(10).string(message.validator);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryValidValidatorRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validator = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryValidValidatorRequest();
        message.validator = object.validator ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryValidValidatorRequest();
        if (object.validator !== undefined && object.validator !== null) {
            message.validator = object.validator;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.validator = message.validator === "" ? undefined : message.validator;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryValidValidatorRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryValidValidatorRequest.decode(message.value);
    },
    toProto(message) {
        return QueryValidValidatorRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryValidValidatorRequest",
            value: QueryValidValidatorRequest.encode(message).finish()
        };
    }
};
function createBaseQueryValidValidatorResponse() {
    return {
        valid: false
    };
}
export const QueryValidValidatorResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryValidValidatorResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.valid === true) {
            writer.uint32(8).bool(message.valid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryValidValidatorResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.valid = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryValidValidatorResponse();
        message.valid = object.valid ?? false;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryValidValidatorResponse();
        if (object.valid !== undefined && object.valid !== null) {
            message.valid = object.valid;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.valid = message.valid === false ? undefined : message.valid;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryValidValidatorResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryValidValidatorResponse.decode(message.value);
    },
    toProto(message) {
        return QueryValidValidatorResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryValidValidatorResponse",
            value: QueryValidValidatorResponse.encode(message).finish()
        };
    }
};
function createBaseQueryValidatorPricesRequest() {
    return {
        validator: "",
        signalIds: []
    };
}
export const QueryValidatorPricesRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryValidatorPricesRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.validator !== "") {
            writer.uint32(10).string(message.validator);
        }
        for (const v of message.signalIds) {
            writer.uint32(18).string(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryValidatorPricesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validator = reader.string();
                    break;
                case 2:
                    message.signalIds.push(reader.string());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryValidatorPricesRequest();
        message.validator = object.validator ?? "";
        message.signalIds = object.signalIds?.map(e => e) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryValidatorPricesRequest();
        if (object.validator !== undefined && object.validator !== null) {
            message.validator = object.validator;
        }
        message.signalIds = object.signal_ids?.map(e => e) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.validator = message.validator === "" ? undefined : message.validator;
        if (message.signalIds) {
            obj.signal_ids = message.signalIds.map(e => e);
        }
        else {
            obj.signal_ids = message.signalIds;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryValidatorPricesRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryValidatorPricesRequest.decode(message.value);
    },
    toProto(message) {
        return QueryValidatorPricesRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryValidatorPricesRequest",
            value: QueryValidatorPricesRequest.encode(message).finish()
        };
    }
};
function createBaseQueryValidatorPricesResponse() {
    return {
        validatorPrices: []
    };
}
export const QueryValidatorPricesResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryValidatorPricesResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.validatorPrices) {
            ValidatorPrice.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryValidatorPricesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validatorPrices.push(ValidatorPrice.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryValidatorPricesResponse();
        message.validatorPrices = object.validatorPrices?.map(e => ValidatorPrice.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryValidatorPricesResponse();
        message.validatorPrices = object.validator_prices?.map(e => ValidatorPrice.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.validatorPrices) {
            obj.validator_prices = message.validatorPrices.map(e => e ? ValidatorPrice.toAmino(e) : undefined);
        }
        else {
            obj.validator_prices = message.validatorPrices;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryValidatorPricesResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryValidatorPricesResponse.decode(message.value);
    },
    toProto(message) {
        return QueryValidatorPricesResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryValidatorPricesResponse",
            value: QueryValidatorPricesResponse.encode(message).finish()
        };
    }
};
function createBaseQueryVoteRequest() {
    return {
        voter: ""
    };
}
export const QueryVoteRequest = {
    typeUrl: "/band.feeds.v1beta1.QueryVoteRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.voter !== "") {
            writer.uint32(10).string(message.voter);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryVoteRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.voter = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryVoteRequest();
        message.voter = object.voter ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryVoteRequest();
        if (object.voter !== undefined && object.voter !== null) {
            message.voter = object.voter;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.voter = message.voter === "" ? undefined : message.voter;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryVoteRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryVoteRequest.decode(message.value);
    },
    toProto(message) {
        return QueryVoteRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryVoteRequest",
            value: QueryVoteRequest.encode(message).finish()
        };
    }
};
function createBaseQueryVoteResponse() {
    return {
        signals: []
    };
}
export const QueryVoteResponse = {
    typeUrl: "/band.feeds.v1beta1.QueryVoteResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.signals) {
            Signal.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryVoteResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signals.push(Signal.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryVoteResponse();
        message.signals = object.signals?.map(e => Signal.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryVoteResponse();
        message.signals = object.signals?.map(e => Signal.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.signals) {
            obj.signals = message.signals.map(e => e ? Signal.toAmino(e) : undefined);
        }
        else {
            obj.signals = message.signals;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryVoteResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryVoteResponse.decode(message.value);
    },
    toProto(message) {
        return QueryVoteResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.QueryVoteResponse",
            value: QueryVoteResponse.encode(message).finish()
        };
    }
};