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

TypeScript library for Cosmos SDK and BandChain

import { BinaryReader, BinaryWriter } from "../../../binary";
/** PriceStatus is a structure that defines the price status of a price. */
export var PriceStatus;
(function (PriceStatus) {
    /** PRICE_STATUS_UNSPECIFIED - PRICE_STATUS_UNSPECIFIED is an unspecified price status. */
    PriceStatus[PriceStatus["PRICE_STATUS_UNSPECIFIED"] = 0] = "PRICE_STATUS_UNSPECIFIED";
    /** PRICE_STATUS_UNKNOWN_SIGNAL_ID - PRICE_STATUS_UNKNOWN_SIGNAL_ID is an unknown signal id price status. */
    PriceStatus[PriceStatus["PRICE_STATUS_UNKNOWN_SIGNAL_ID"] = 1] = "PRICE_STATUS_UNKNOWN_SIGNAL_ID";
    /** PRICE_STATUS_NOT_READY - PRICE_STATUS_NOT_READY is a not ready price status. */
    PriceStatus[PriceStatus["PRICE_STATUS_NOT_READY"] = 2] = "PRICE_STATUS_NOT_READY";
    /** PRICE_STATUS_AVAILABLE - PRICE_STATUS_AVAILABLE is an available price status. */
    PriceStatus[PriceStatus["PRICE_STATUS_AVAILABLE"] = 3] = "PRICE_STATUS_AVAILABLE";
    /** PRICE_STATUS_NOT_IN_CURRENT_FEEDS - PRICE_STATUS_NOT_IN_CURRENT_FEEDS is a not in current feed price status. */
    PriceStatus[PriceStatus["PRICE_STATUS_NOT_IN_CURRENT_FEEDS"] = 4] = "PRICE_STATUS_NOT_IN_CURRENT_FEEDS";
    PriceStatus[PriceStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(PriceStatus || (PriceStatus = {}));
export const PriceStatusSDKType = PriceStatus;
export const PriceStatusAmino = PriceStatus;
export function priceStatusFromJSON(object) {
    switch (object) {
        case 0:
        case "PRICE_STATUS_UNSPECIFIED":
            return PriceStatus.PRICE_STATUS_UNSPECIFIED;
        case 1:
        case "PRICE_STATUS_UNKNOWN_SIGNAL_ID":
            return PriceStatus.PRICE_STATUS_UNKNOWN_SIGNAL_ID;
        case 2:
        case "PRICE_STATUS_NOT_READY":
            return PriceStatus.PRICE_STATUS_NOT_READY;
        case 3:
        case "PRICE_STATUS_AVAILABLE":
            return PriceStatus.PRICE_STATUS_AVAILABLE;
        case 4:
        case "PRICE_STATUS_NOT_IN_CURRENT_FEEDS":
            return PriceStatus.PRICE_STATUS_NOT_IN_CURRENT_FEEDS;
        case -1:
        case "UNRECOGNIZED":
        default:
            return PriceStatus.UNRECOGNIZED;
    }
}
export function priceStatusToJSON(object) {
    switch (object) {
        case PriceStatus.PRICE_STATUS_UNSPECIFIED:
            return "PRICE_STATUS_UNSPECIFIED";
        case PriceStatus.PRICE_STATUS_UNKNOWN_SIGNAL_ID:
            return "PRICE_STATUS_UNKNOWN_SIGNAL_ID";
        case PriceStatus.PRICE_STATUS_NOT_READY:
            return "PRICE_STATUS_NOT_READY";
        case PriceStatus.PRICE_STATUS_AVAILABLE:
            return "PRICE_STATUS_AVAILABLE";
        case PriceStatus.PRICE_STATUS_NOT_IN_CURRENT_FEEDS:
            return "PRICE_STATUS_NOT_IN_CURRENT_FEEDS";
        case PriceStatus.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
/** SignalPriceStatus is a structure that defines the price status of a signal id. */
export var SignalPriceStatus;
(function (SignalPriceStatus) {
    /** SIGNAL_PRICE_STATUS_UNSPECIFIED - SIGNAL_PRICE_STATUS_UNSPECIFIED is an unspecified signal price status. */
    SignalPriceStatus[SignalPriceStatus["SIGNAL_PRICE_STATUS_UNSPECIFIED"] = 0] = "SIGNAL_PRICE_STATUS_UNSPECIFIED";
    /** SIGNAL_PRICE_STATUS_UNSUPPORTED - SIGNAL_PRICE_STATUS_UNSUPPORTED is an unsupported signal price status. */
    SignalPriceStatus[SignalPriceStatus["SIGNAL_PRICE_STATUS_UNSUPPORTED"] = 1] = "SIGNAL_PRICE_STATUS_UNSUPPORTED";
    /** SIGNAL_PRICE_STATUS_UNAVAILABLE - SIGNAL_PRICE_STATUS_UNAVAILABLE is an unavailable signal price status. */
    SignalPriceStatus[SignalPriceStatus["SIGNAL_PRICE_STATUS_UNAVAILABLE"] = 2] = "SIGNAL_PRICE_STATUS_UNAVAILABLE";
    /** SIGNAL_PRICE_STATUS_AVAILABLE - SIGNAL_PRICE_STATUS_AVAILABLE is an available signal price status. */
    SignalPriceStatus[SignalPriceStatus["SIGNAL_PRICE_STATUS_AVAILABLE"] = 3] = "SIGNAL_PRICE_STATUS_AVAILABLE";
    SignalPriceStatus[SignalPriceStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(SignalPriceStatus || (SignalPriceStatus = {}));
export const SignalPriceStatusSDKType = SignalPriceStatus;
export const SignalPriceStatusAmino = SignalPriceStatus;
export function signalPriceStatusFromJSON(object) {
    switch (object) {
        case 0:
        case "SIGNAL_PRICE_STATUS_UNSPECIFIED":
            return SignalPriceStatus.SIGNAL_PRICE_STATUS_UNSPECIFIED;
        case 1:
        case "SIGNAL_PRICE_STATUS_UNSUPPORTED":
            return SignalPriceStatus.SIGNAL_PRICE_STATUS_UNSUPPORTED;
        case 2:
        case "SIGNAL_PRICE_STATUS_UNAVAILABLE":
            return SignalPriceStatus.SIGNAL_PRICE_STATUS_UNAVAILABLE;
        case 3:
        case "SIGNAL_PRICE_STATUS_AVAILABLE":
            return SignalPriceStatus.SIGNAL_PRICE_STATUS_AVAILABLE;
        case -1:
        case "UNRECOGNIZED":
        default:
            return SignalPriceStatus.UNRECOGNIZED;
    }
}
export function signalPriceStatusToJSON(object) {
    switch (object) {
        case SignalPriceStatus.SIGNAL_PRICE_STATUS_UNSPECIFIED:
            return "SIGNAL_PRICE_STATUS_UNSPECIFIED";
        case SignalPriceStatus.SIGNAL_PRICE_STATUS_UNSUPPORTED:
            return "SIGNAL_PRICE_STATUS_UNSUPPORTED";
        case SignalPriceStatus.SIGNAL_PRICE_STATUS_UNAVAILABLE:
            return "SIGNAL_PRICE_STATUS_UNAVAILABLE";
        case SignalPriceStatus.SIGNAL_PRICE_STATUS_AVAILABLE:
            return "SIGNAL_PRICE_STATUS_AVAILABLE";
        case SignalPriceStatus.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
function createBaseSignal() {
    return {
        id: "",
        power: BigInt(0)
    };
}
export const Signal = {
    typeUrl: "/band.feeds.v1beta1.Signal",
    encode(message, writer = BinaryWriter.create()) {
        if (message.id !== "") {
            writer.uint32(10).string(message.id);
        }
        if (message.power !== BigInt(0)) {
            writer.uint32(16).int64(message.power);
        }
        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 = createBaseSignal();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.id = reader.string();
                    break;
                case 2:
                    message.power = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseSignal();
        message.id = object.id ?? "";
        message.power = object.power !== undefined && object.power !== null ? BigInt(object.power.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseSignal();
        if (object.id !== undefined && object.id !== null) {
            message.id = object.id;
        }
        if (object.power !== undefined && object.power !== null) {
            message.power = BigInt(object.power);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.id = message.id === "" ? undefined : message.id;
        obj.power = message.power !== BigInt(0) ? message.power?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return Signal.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return Signal.decode(message.value);
    },
    toProto(message) {
        return Signal.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.Signal",
            value: Signal.encode(message).finish()
        };
    }
};
function createBaseVote() {
    return {
        voter: "",
        signals: []
    };
}
export const Vote = {
    typeUrl: "/band.feeds.v1beta1.Vote",
    encode(message, writer = BinaryWriter.create()) {
        if (message.voter !== "") {
            writer.uint32(10).string(message.voter);
        }
        for (const v of message.signals) {
            Signal.encode(v, 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 = createBaseVote();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.voter = reader.string();
                    break;
                case 2:
                    message.signals.push(Signal.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseVote();
        message.voter = object.voter ?? "";
        message.signals = object.signals?.map(e => Signal.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseVote();
        if (object.voter !== undefined && object.voter !== null) {
            message.voter = object.voter;
        }
        message.signals = object.signals?.map(e => Signal.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.voter = message.voter === "" ? undefined : message.voter;
        if (message.signals) {
            obj.signals = message.signals.map(e => e ? Signal.toAmino(e) : undefined);
        }
        else {
            obj.signals = message.signals;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return Vote.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return Vote.decode(message.value);
    },
    toProto(message) {
        return Vote.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.Vote",
            value: Vote.encode(message).finish()
        };
    }
};
function createBaseFeed() {
    return {
        signalId: "",
        power: BigInt(0),
        interval: BigInt(0)
    };
}
export const Feed = {
    typeUrl: "/band.feeds.v1beta1.Feed",
    encode(message, writer = BinaryWriter.create()) {
        if (message.signalId !== "") {
            writer.uint32(10).string(message.signalId);
        }
        if (message.power !== BigInt(0)) {
            writer.uint32(16).int64(message.power);
        }
        if (message.interval !== BigInt(0)) {
            writer.uint32(24).int64(message.interval);
        }
        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 = createBaseFeed();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalId = reader.string();
                    break;
                case 2:
                    message.power = reader.int64();
                    break;
                case 3:
                    message.interval = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseFeed();
        message.signalId = object.signalId ?? "";
        message.power = object.power !== undefined && object.power !== null ? BigInt(object.power.toString()) : BigInt(0);
        message.interval = object.interval !== undefined && object.interval !== null ? BigInt(object.interval.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseFeed();
        if (object.signal_id !== undefined && object.signal_id !== null) {
            message.signalId = object.signal_id;
        }
        if (object.power !== undefined && object.power !== null) {
            message.power = BigInt(object.power);
        }
        if (object.interval !== undefined && object.interval !== null) {
            message.interval = BigInt(object.interval);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.signal_id = message.signalId === "" ? undefined : message.signalId;
        obj.power = message.power !== BigInt(0) ? message.power?.toString() : undefined;
        obj.interval = message.interval !== BigInt(0) ? message.interval?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return Feed.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return Feed.decode(message.value);
    },
    toProto(message) {
        return Feed.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.Feed",
            value: Feed.encode(message).finish()
        };
    }
};
function createBaseFeedWithDeviation() {
    return {
        signalId: "",
        power: BigInt(0),
        interval: BigInt(0),
        deviationBasisPoint: BigInt(0)
    };
}
export const FeedWithDeviation = {
    typeUrl: "/band.feeds.v1beta1.FeedWithDeviation",
    encode(message, writer = BinaryWriter.create()) {
        if (message.signalId !== "") {
            writer.uint32(10).string(message.signalId);
        }
        if (message.power !== BigInt(0)) {
            writer.uint32(16).int64(message.power);
        }
        if (message.interval !== BigInt(0)) {
            writer.uint32(24).int64(message.interval);
        }
        if (message.deviationBasisPoint !== BigInt(0)) {
            writer.uint32(32).int64(message.deviationBasisPoint);
        }
        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 = createBaseFeedWithDeviation();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalId = reader.string();
                    break;
                case 2:
                    message.power = reader.int64();
                    break;
                case 3:
                    message.interval = reader.int64();
                    break;
                case 4:
                    message.deviationBasisPoint = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseFeedWithDeviation();
        message.signalId = object.signalId ?? "";
        message.power = object.power !== undefined && object.power !== null ? BigInt(object.power.toString()) : BigInt(0);
        message.interval = object.interval !== undefined && object.interval !== null ? BigInt(object.interval.toString()) : BigInt(0);
        message.deviationBasisPoint = object.deviationBasisPoint !== undefined && object.deviationBasisPoint !== null ? BigInt(object.deviationBasisPoint.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseFeedWithDeviation();
        if (object.signal_id !== undefined && object.signal_id !== null) {
            message.signalId = object.signal_id;
        }
        if (object.power !== undefined && object.power !== null) {
            message.power = BigInt(object.power);
        }
        if (object.interval !== undefined && object.interval !== null) {
            message.interval = BigInt(object.interval);
        }
        if (object.deviation_basis_point !== undefined && object.deviation_basis_point !== null) {
            message.deviationBasisPoint = BigInt(object.deviation_basis_point);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.signal_id = message.signalId === "" ? undefined : message.signalId;
        obj.power = message.power !== BigInt(0) ? message.power?.toString() : undefined;
        obj.interval = message.interval !== BigInt(0) ? message.interval?.toString() : undefined;
        obj.deviation_basis_point = message.deviationBasisPoint !== BigInt(0) ? message.deviationBasisPoint?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return FeedWithDeviation.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return FeedWithDeviation.decode(message.value);
    },
    toProto(message) {
        return FeedWithDeviation.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.FeedWithDeviation",
            value: FeedWithDeviation.encode(message).finish()
        };
    }
};
function createBaseCurrentFeeds() {
    return {
        feeds: [],
        lastUpdateTimestamp: BigInt(0),
        lastUpdateBlock: BigInt(0)
    };
}
export const CurrentFeeds = {
    typeUrl: "/band.feeds.v1beta1.CurrentFeeds",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.feeds) {
            Feed.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.lastUpdateTimestamp !== BigInt(0)) {
            writer.uint32(16).int64(message.lastUpdateTimestamp);
        }
        if (message.lastUpdateBlock !== BigInt(0)) {
            writer.uint32(24).int64(message.lastUpdateBlock);
        }
        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 = createBaseCurrentFeeds();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.feeds.push(Feed.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.lastUpdateTimestamp = reader.int64();
                    break;
                case 3:
                    message.lastUpdateBlock = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCurrentFeeds();
        message.feeds = object.feeds?.map(e => Feed.fromPartial(e)) || [];
        message.lastUpdateTimestamp = object.lastUpdateTimestamp !== undefined && object.lastUpdateTimestamp !== null ? BigInt(object.lastUpdateTimestamp.toString()) : BigInt(0);
        message.lastUpdateBlock = object.lastUpdateBlock !== undefined && object.lastUpdateBlock !== null ? BigInt(object.lastUpdateBlock.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseCurrentFeeds();
        message.feeds = object.feeds?.map(e => Feed.fromAmino(e)) || [];
        if (object.last_update_timestamp !== undefined && object.last_update_timestamp !== null) {
            message.lastUpdateTimestamp = BigInt(object.last_update_timestamp);
        }
        if (object.last_update_block !== undefined && object.last_update_block !== null) {
            message.lastUpdateBlock = BigInt(object.last_update_block);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.feeds) {
            obj.feeds = message.feeds.map(e => e ? Feed.toAmino(e) : undefined);
        }
        else {
            obj.feeds = message.feeds;
        }
        obj.last_update_timestamp = message.lastUpdateTimestamp !== BigInt(0) ? message.lastUpdateTimestamp?.toString() : undefined;
        obj.last_update_block = message.lastUpdateBlock !== BigInt(0) ? message.lastUpdateBlock?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return CurrentFeeds.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return CurrentFeeds.decode(message.value);
    },
    toProto(message) {
        return CurrentFeeds.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.CurrentFeeds",
            value: CurrentFeeds.encode(message).finish()
        };
    }
};
function createBaseCurrentFeedWithDeviations() {
    return {
        feeds: [],
        lastUpdateTimestamp: BigInt(0),
        lastUpdateBlock: BigInt(0)
    };
}
export const CurrentFeedWithDeviations = {
    typeUrl: "/band.feeds.v1beta1.CurrentFeedWithDeviations",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.feeds) {
            FeedWithDeviation.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.lastUpdateTimestamp !== BigInt(0)) {
            writer.uint32(16).int64(message.lastUpdateTimestamp);
        }
        if (message.lastUpdateBlock !== BigInt(0)) {
            writer.uint32(24).int64(message.lastUpdateBlock);
        }
        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 = createBaseCurrentFeedWithDeviations();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.feeds.push(FeedWithDeviation.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.lastUpdateTimestamp = reader.int64();
                    break;
                case 3:
                    message.lastUpdateBlock = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCurrentFeedWithDeviations();
        message.feeds = object.feeds?.map(e => FeedWithDeviation.fromPartial(e)) || [];
        message.lastUpdateTimestamp = object.lastUpdateTimestamp !== undefined && object.lastUpdateTimestamp !== null ? BigInt(object.lastUpdateTimestamp.toString()) : BigInt(0);
        message.lastUpdateBlock = object.lastUpdateBlock !== undefined && object.lastUpdateBlock !== null ? BigInt(object.lastUpdateBlock.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseCurrentFeedWithDeviations();
        message.feeds = object.feeds?.map(e => FeedWithDeviation.fromAmino(e)) || [];
        if (object.last_update_timestamp !== undefined && object.last_update_timestamp !== null) {
            message.lastUpdateTimestamp = BigInt(object.last_update_timestamp);
        }
        if (object.last_update_block !== undefined && object.last_update_block !== null) {
            message.lastUpdateBlock = BigInt(object.last_update_block);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.feeds) {
            obj.feeds = message.feeds.map(e => e ? FeedWithDeviation.toAmino(e) : undefined);
        }
        else {
            obj.feeds = message.feeds;
        }
        obj.last_update_timestamp = message.lastUpdateTimestamp !== BigInt(0) ? message.lastUpdateTimestamp?.toString() : undefined;
        obj.last_update_block = message.lastUpdateBlock !== BigInt(0) ? message.lastUpdateBlock?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return CurrentFeedWithDeviations.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return CurrentFeedWithDeviations.decode(message.value);
    },
    toProto(message) {
        return CurrentFeedWithDeviations.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.CurrentFeedWithDeviations",
            value: CurrentFeedWithDeviations.encode(message).finish()
        };
    }
};
function createBasePrice() {
    return {
        status: 0,
        signalId: "",
        price: BigInt(0),
        timestamp: BigInt(0)
    };
}
export const Price = {
    typeUrl: "/band.feeds.v1beta1.Price",
    encode(message, writer = BinaryWriter.create()) {
        if (message.status !== 0) {
            writer.uint32(8).int32(message.status);
        }
        if (message.signalId !== "") {
            writer.uint32(18).string(message.signalId);
        }
        if (message.price !== BigInt(0)) {
            writer.uint32(24).uint64(message.price);
        }
        if (message.timestamp !== BigInt(0)) {
            writer.uint32(32).int64(message.timestamp);
        }
        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 = createBasePrice();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.status = reader.int32();
                    break;
                case 2:
                    message.signalId = reader.string();
                    break;
                case 3:
                    message.price = reader.uint64();
                    break;
                case 4:
                    message.timestamp = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBasePrice();
        message.status = object.status ?? 0;
        message.signalId = object.signalId ?? "";
        message.price = object.price !== undefined && object.price !== null ? BigInt(object.price.toString()) : BigInt(0);
        message.timestamp = object.timestamp !== undefined && object.timestamp !== null ? BigInt(object.timestamp.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBasePrice();
        if (object.status !== undefined && object.status !== null) {
            message.status = object.status;
        }
        if (object.signal_id !== undefined && object.signal_id !== null) {
            message.signalId = object.signal_id;
        }
        if (object.price !== undefined && object.price !== null) {
            message.price = BigInt(object.price);
        }
        if (object.timestamp !== undefined && object.timestamp !== null) {
            message.timestamp = BigInt(object.timestamp);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.status = message.status === 0 ? undefined : message.status;
        obj.signal_id = message.signalId === "" ? undefined : message.signalId;
        obj.price = message.price !== BigInt(0) ? message.price?.toString() : undefined;
        obj.timestamp = message.timestamp !== BigInt(0) ? message.timestamp?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return Price.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return Price.decode(message.value);
    },
    toProto(message) {
        return Price.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.Price",
            value: Price.encode(message).finish()
        };
    }
};
function createBaseSignalPrice() {
    return {
        status: 0,
        signalId: "",
        price: BigInt(0)
    };
}
export const SignalPrice = {
    typeUrl: "/band.feeds.v1beta1.SignalPrice",
    encode(message, writer = BinaryWriter.create()) {
        if (message.status !== 0) {
            writer.uint32(8).int32(message.status);
        }
        if (message.signalId !== "") {
            writer.uint32(18).string(message.signalId);
        }
        if (message.price !== BigInt(0)) {
            writer.uint32(24).uint64(message.price);
        }
        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 = createBaseSignalPrice();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.status = reader.int32();
                    break;
                case 2:
                    message.signalId = reader.string();
                    break;
                case 3:
                    message.price = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseSignalPrice();
        message.status = object.status ?? 0;
        message.signalId = object.signalId ?? "";
        message.price = object.price !== undefined && object.price !== null ? BigInt(object.price.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseSignalPrice();
        if (object.status !== undefined && object.status !== null) {
            message.status = object.status;
        }
        if (object.signal_id !== undefined && object.signal_id !== null) {
            message.signalId = object.signal_id;
        }
        if (object.price !== undefined && object.price !== null) {
            message.price = BigInt(object.price);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.status = message.status === 0 ? undefined : message.status;
        obj.signal_id = message.signalId === "" ? undefined : message.signalId;
        obj.price = message.price !== BigInt(0) ? message.price?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return SignalPrice.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return SignalPrice.decode(message.value);
    },
    toProto(message) {
        return SignalPrice.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.SignalPrice",
            value: SignalPrice.encode(message).finish()
        };
    }
};
function createBaseValidatorPrice() {
    return {
        signalPriceStatus: 0,
        signalId: "",
        price: BigInt(0),
        timestamp: BigInt(0),
        blockHeight: BigInt(0)
    };
}
export const ValidatorPrice = {
    typeUrl: "/band.feeds.v1beta1.ValidatorPrice",
    encode(message, writer = BinaryWriter.create()) {
        if (message.signalPriceStatus !== 0) {
            writer.uint32(8).int32(message.signalPriceStatus);
        }
        if (message.signalId !== "") {
            writer.uint32(18).string(message.signalId);
        }
        if (message.price !== BigInt(0)) {
            writer.uint32(24).uint64(message.price);
        }
        if (message.timestamp !== BigInt(0)) {
            writer.uint32(32).int64(message.timestamp);
        }
        if (message.blockHeight !== BigInt(0)) {
            writer.uint32(40).int64(message.blockHeight);
        }
        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 = createBaseValidatorPrice();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalPriceStatus = reader.int32();
                    break;
                case 2:
                    message.signalId = reader.string();
                    break;
                case 3:
                    message.price = reader.uint64();
                    break;
                case 4:
                    message.timestamp = reader.int64();
                    break;
                case 5:
                    message.blockHeight = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseValidatorPrice();
        message.signalPriceStatus = object.signalPriceStatus ?? 0;
        message.signalId = object.signalId ?? "";
        message.price = object.price !== undefined && object.price !== null ? BigInt(object.price.toString()) : BigInt(0);
        message.timestamp = object.timestamp !== undefined && object.timestamp !== null ? BigInt(object.timestamp.toString()) : BigInt(0);
        message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? BigInt(object.blockHeight.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseValidatorPrice();
        if (object.signal_price_status !== undefined && object.signal_price_status !== null) {
            message.signalPriceStatus = object.signal_price_status;
        }
        if (object.signal_id !== undefined && object.signal_id !== null) {
            message.signalId = object.signal_id;
        }
        if (object.price !== undefined && object.price !== null) {
            message.price = BigInt(object.price);
        }
        if (object.timestamp !== undefined && object.timestamp !== null) {
            message.timestamp = BigInt(object.timestamp);
        }
        if (object.block_height !== undefined && object.block_height !== null) {
            message.blockHeight = BigInt(object.block_height);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.signal_price_status = message.signalPriceStatus === 0 ? undefined : message.signalPriceStatus;
        obj.signal_id = message.signalId === "" ? undefined : message.signalId;
        obj.price = message.price !== BigInt(0) ? message.price?.toString() : undefined;
        obj.timestamp = message.timestamp !== BigInt(0) ? message.timestamp?.toString() : undefined;
        obj.block_height = message.blockHeight !== BigInt(0) ? message.blockHeight?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return ValidatorPrice.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return ValidatorPrice.decode(message.value);
    },
    toProto(message) {
        return ValidatorPrice.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.ValidatorPrice",
            value: ValidatorPrice.encode(message).finish()
        };
    }
};
function createBaseValidatorPriceList() {
    return {
        validator: "",
        validatorPrices: []
    };
}
export const ValidatorPriceList = {
    typeUrl: "/band.feeds.v1beta1.ValidatorPriceList",
    encode(message, writer = BinaryWriter.create()) {
        if (message.validator !== "") {
            writer.uint32(10).string(message.validator);
        }
        for (const v of message.validatorPrices) {
            ValidatorPrice.encode(v, 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 = createBaseValidatorPriceList();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validator = reader.string();
                    break;
                case 2:
                    message.validatorPrices.push(ValidatorPrice.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseValidatorPriceList();
        message.validator = object.validator ?? "";
        message.validatorPrices = object.validatorPrices?.map(e => ValidatorPrice.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseValidatorPriceList();
        if (object.validator !== undefined && object.validator !== null) {
            message.validator = object.validator;
        }
        message.validatorPrices = object.validator_prices?.map(e => ValidatorPrice.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.validator = message.validator === "" ? undefined : message.validator;
        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 ValidatorPriceList.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return ValidatorPriceList.decode(message.value);
    },
    toProto(message) {
        return ValidatorPriceList.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.ValidatorPriceList",
            value: ValidatorPriceList.encode(message).finish()
        };
    }
};
function createBaseReferenceSourceConfig() {
    return {
        registryIpfsHash: "",
        registryVersion: ""
    };
}
export const ReferenceSourceConfig = {
    typeUrl: "/band.feeds.v1beta1.ReferenceSourceConfig",
    encode(message, writer = BinaryWriter.create()) {
        if (message.registryIpfsHash !== "") {
            writer.uint32(10).string(message.registryIpfsHash);
        }
        if (message.registryVersion !== "") {
            writer.uint32(18).string(message.registryVersion);
        }
        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 = createBaseReferenceSourceConfig();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.registryIpfsHash = reader.string();
                    break;
                case 2:
                    message.registryVersion = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseReferenceSourceConfig();
        message.registryIpfsHash = object.registryIpfsHash ?? "";
        message.registryVersion = object.registryVersion ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseReferenceSourceConfig();
        if (object.registry_ipfs_hash !== undefined && object.registry_ipfs_hash !== null) {
            message.registryIpfsHash = object.registry_ipfs_hash;
        }
        if (object.registry_version !== undefined && object.registry_version !== null) {
            message.registryVersion = object.registry_version;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.registry_ipfs_hash = message.registryIpfsHash === "" ? undefined : message.registryIpfsHash;
        obj.registry_version = message.registryVersion === "" ? undefined : message.registryVersion;
        return obj;
    },
    fromAminoMsg(object) {
        return ReferenceSourceConfig.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return ReferenceSourceConfig.decode(message.value);
    },
    toProto(message) {
        return ReferenceSourceConfig.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.ReferenceSourceConfig",
            value: ReferenceSourceConfig.encode(message).finish()
        };
    }
};
function createBaseFeedsSignatureOrder() {
    return {
        signalIds: [],
        encoder: 0
    };
}
export const FeedsSignatureOrder = {
    typeUrl: "/band.feeds.v1beta1.FeedsSignatureOrder",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.signalIds) {
            writer.uint32(10).string(v);
        }
        if (message.encoder !== 0) {
            writer.uint32(16).int32(message.encoder);
        }
        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 = createBaseFeedsSignatureOrder();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalIds.push(reader.string());
                    break;
                case 2:
                    message.encoder = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseFeedsSignatureOrder();
        message.signalIds = object.signalIds?.map(e => e) || [];
        message.encoder = object.encoder ?? 0;
        return message;
    },
    fromAmino(object) {
        const message = createBaseFeedsSignatureOrder();
        message.signalIds = object.signal_ids?.map(e => e) || [];
        if (object.encoder !== undefined && object.encoder !== null) {
            message.encoder = object.encoder;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.signalIds) {
            obj.signal_ids = message.signalIds.map(e => e);
        }
        else {
            obj.signal_ids = message.signalIds;
        }
        obj.encoder = message.encoder === 0 ? undefined : message.encoder;
        return obj;
    },
    fromAminoMsg(object) {
        return FeedsSignatureOrder.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return FeedsSignatureOrder.decode(message.value);
    },
    toProto(message) {
        return FeedsSignatureOrder.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.feeds.v1beta1.FeedsSignatureOrder",
            value: FeedsSignatureOrder.encode(message).finish()
        };
    }
};