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

TypeScript library for Cosmos SDK and BandChain

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