@bandprotocol/bandchain.js/esm/codegen/band/oracle/v1/query.js

TypeScript library for Cosmos SDK and BandChain

//@ts-nocheck
import { DataSource, OracleScript, Request, Report, Result, SigningResult, Params, ValidatorStatus, ActiveValidator, PriceResult } from "./oracle";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { bytesFromBase64, base64FromBytes } from "../../../helpers";
function createBaseQueryCountsRequest() {
    return {};
}
export const QueryCountsRequest = {
    typeUrl: "/band.oracle.v1.QueryCountsRequest",
    encode(_, writer = BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryCountsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseQueryCountsRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseQueryCountsRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return QueryCountsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryCountsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryCountsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryCountsRequest",
            value: QueryCountsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryCountsResponse() {
    return {
        dataSourceCount: BigInt(0),
        oracleScriptCount: BigInt(0),
        requestCount: BigInt(0)
    };
}
export const QueryCountsResponse = {
    typeUrl: "/band.oracle.v1.QueryCountsResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.dataSourceCount !== BigInt(0)) {
            writer.uint32(8).uint64(message.dataSourceCount);
        }
        if (message.oracleScriptCount !== BigInt(0)) {
            writer.uint32(16).uint64(message.oracleScriptCount);
        }
        if (message.requestCount !== BigInt(0)) {
            writer.uint32(24).uint64(message.requestCount);
        }
        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 = createBaseQueryCountsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dataSourceCount = reader.uint64();
                    break;
                case 2:
                    message.oracleScriptCount = reader.uint64();
                    break;
                case 3:
                    message.requestCount = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryCountsResponse();
        message.dataSourceCount = object.dataSourceCount !== undefined && object.dataSourceCount !== null ? BigInt(object.dataSourceCount.toString()) : BigInt(0);
        message.oracleScriptCount = object.oracleScriptCount !== undefined && object.oracleScriptCount !== null ? BigInt(object.oracleScriptCount.toString()) : BigInt(0);
        message.requestCount = object.requestCount !== undefined && object.requestCount !== null ? BigInt(object.requestCount.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryCountsResponse();
        if (object.data_source_count !== undefined && object.data_source_count !== null) {
            message.dataSourceCount = BigInt(object.data_source_count);
        }
        if (object.oracle_script_count !== undefined && object.oracle_script_count !== null) {
            message.oracleScriptCount = BigInt(object.oracle_script_count);
        }
        if (object.request_count !== undefined && object.request_count !== null) {
            message.requestCount = BigInt(object.request_count);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.data_source_count = message.dataSourceCount !== BigInt(0) ? message.dataSourceCount?.toString() : undefined;
        obj.oracle_script_count = message.oracleScriptCount !== BigInt(0) ? message.oracleScriptCount?.toString() : undefined;
        obj.request_count = message.requestCount !== BigInt(0) ? message.requestCount?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryCountsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryCountsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryCountsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryCountsResponse",
            value: QueryCountsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryDataRequest() {
    return {
        dataHash: ""
    };
}
export const QueryDataRequest = {
    typeUrl: "/band.oracle.v1.QueryDataRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.dataHash !== "") {
            writer.uint32(10).string(message.dataHash);
        }
        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 = createBaseQueryDataRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dataHash = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryDataRequest();
        message.dataHash = object.dataHash ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDataRequest();
        if (object.data_hash !== undefined && object.data_hash !== null) {
            message.dataHash = object.data_hash;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.data_hash = message.dataHash === "" ? undefined : message.dataHash;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDataRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDataRequest.decode(message.value);
    },
    toProto(message) {
        return QueryDataRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryDataRequest",
            value: QueryDataRequest.encode(message).finish()
        };
    }
};
function createBaseQueryDataResponse() {
    return {
        data: new Uint8Array()
    };
}
export const QueryDataResponse = {
    typeUrl: "/band.oracle.v1.QueryDataResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.data.length !== 0) {
            writer.uint32(10).bytes(message.data);
        }
        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 = createBaseQueryDataResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.data = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryDataResponse();
        message.data = object.data ?? new Uint8Array();
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDataResponse();
        if (object.data !== undefined && object.data !== null) {
            message.data = bytesFromBase64(object.data);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.data = message.data ? base64FromBytes(message.data) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDataResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDataResponse.decode(message.value);
    },
    toProto(message) {
        return QueryDataResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryDataResponse",
            value: QueryDataResponse.encode(message).finish()
        };
    }
};
function createBaseQueryDataSourceRequest() {
    return {
        dataSourceId: BigInt(0)
    };
}
export const QueryDataSourceRequest = {
    typeUrl: "/band.oracle.v1.QueryDataSourceRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.dataSourceId !== BigInt(0)) {
            writer.uint32(8).uint64(message.dataSourceId);
        }
        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 = createBaseQueryDataSourceRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dataSourceId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryDataSourceRequest();
        message.dataSourceId = object.dataSourceId !== undefined && object.dataSourceId !== null ? BigInt(object.dataSourceId.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDataSourceRequest();
        if (object.data_source_id !== undefined && object.data_source_id !== null) {
            message.dataSourceId = BigInt(object.data_source_id);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.data_source_id = message.dataSourceId !== BigInt(0) ? message.dataSourceId?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDataSourceRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDataSourceRequest.decode(message.value);
    },
    toProto(message) {
        return QueryDataSourceRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryDataSourceRequest",
            value: QueryDataSourceRequest.encode(message).finish()
        };
    }
};
function createBaseQueryDataSourceResponse() {
    return {
        dataSource: undefined
    };
}
export const QueryDataSourceResponse = {
    typeUrl: "/band.oracle.v1.QueryDataSourceResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.dataSource !== undefined) {
            DataSource.encode(message.dataSource, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryDataSourceResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dataSource = DataSource.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryDataSourceResponse();
        message.dataSource = object.dataSource !== undefined && object.dataSource !== null ? DataSource.fromPartial(object.dataSource) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDataSourceResponse();
        if (object.data_source !== undefined && object.data_source !== null) {
            message.dataSource = DataSource.fromAmino(object.data_source);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.data_source = message.dataSource ? DataSource.toAmino(message.dataSource) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDataSourceResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDataSourceResponse.decode(message.value);
    },
    toProto(message) {
        return QueryDataSourceResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryDataSourceResponse",
            value: QueryDataSourceResponse.encode(message).finish()
        };
    }
};
function createBaseQueryOracleScriptRequest() {
    return {
        oracleScriptId: BigInt(0)
    };
}
export const QueryOracleScriptRequest = {
    typeUrl: "/band.oracle.v1.QueryOracleScriptRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.oracleScriptId !== BigInt(0)) {
            writer.uint32(8).uint64(message.oracleScriptId);
        }
        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 = createBaseQueryOracleScriptRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.oracleScriptId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryOracleScriptRequest();
        message.oracleScriptId = object.oracleScriptId !== undefined && object.oracleScriptId !== null ? BigInt(object.oracleScriptId.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryOracleScriptRequest();
        if (object.oracle_script_id !== undefined && object.oracle_script_id !== null) {
            message.oracleScriptId = BigInt(object.oracle_script_id);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.oracle_script_id = message.oracleScriptId !== BigInt(0) ? message.oracleScriptId?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryOracleScriptRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryOracleScriptRequest.decode(message.value);
    },
    toProto(message) {
        return QueryOracleScriptRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryOracleScriptRequest",
            value: QueryOracleScriptRequest.encode(message).finish()
        };
    }
};
function createBaseQueryOracleScriptResponse() {
    return {
        oracleScript: undefined
    };
}
export const QueryOracleScriptResponse = {
    typeUrl: "/band.oracle.v1.QueryOracleScriptResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.oracleScript !== undefined) {
            OracleScript.encode(message.oracleScript, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryOracleScriptResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.oracleScript = OracleScript.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryOracleScriptResponse();
        message.oracleScript = object.oracleScript !== undefined && object.oracleScript !== null ? OracleScript.fromPartial(object.oracleScript) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryOracleScriptResponse();
        if (object.oracle_script !== undefined && object.oracle_script !== null) {
            message.oracleScript = OracleScript.fromAmino(object.oracle_script);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.oracle_script = message.oracleScript ? OracleScript.toAmino(message.oracleScript) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryOracleScriptResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryOracleScriptResponse.decode(message.value);
    },
    toProto(message) {
        return QueryOracleScriptResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryOracleScriptResponse",
            value: QueryOracleScriptResponse.encode(message).finish()
        };
    }
};
function createBaseQueryRequestRequest() {
    return {
        requestId: BigInt(0)
    };
}
export const QueryRequestRequest = {
    typeUrl: "/band.oracle.v1.QueryRequestRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.requestId !== BigInt(0)) {
            writer.uint32(8).uint64(message.requestId);
        }
        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 = createBaseQueryRequestRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requestId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryRequestRequest();
        message.requestId = object.requestId !== undefined && object.requestId !== null ? BigInt(object.requestId.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryRequestRequest();
        if (object.request_id !== undefined && object.request_id !== null) {
            message.requestId = BigInt(object.request_id);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.request_id = message.requestId !== BigInt(0) ? message.requestId?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryRequestRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryRequestRequest.decode(message.value);
    },
    toProto(message) {
        return QueryRequestRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryRequestRequest",
            value: QueryRequestRequest.encode(message).finish()
        };
    }
};
function createBaseQueryRequestResponse() {
    return {
        request: undefined,
        reports: [],
        result: undefined,
        signing: undefined
    };
}
export const QueryRequestResponse = {
    typeUrl: "/band.oracle.v1.QueryRequestResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.request !== undefined) {
            Request.encode(message.request, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.reports) {
            Report.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.result !== undefined) {
            Result.encode(message.result, writer.uint32(26).fork()).ldelim();
        }
        if (message.signing !== undefined) {
            SigningResult.encode(message.signing, writer.uint32(34).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 = createBaseQueryRequestResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.request = Request.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.reports.push(Report.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.result = Result.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.signing = SigningResult.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryRequestResponse();
        message.request = object.request !== undefined && object.request !== null ? Request.fromPartial(object.request) : undefined;
        message.reports = object.reports?.map(e => Report.fromPartial(e)) || [];
        message.result = object.result !== undefined && object.result !== null ? Result.fromPartial(object.result) : undefined;
        message.signing = object.signing !== undefined && object.signing !== null ? SigningResult.fromPartial(object.signing) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryRequestResponse();
        if (object.request !== undefined && object.request !== null) {
            message.request = Request.fromAmino(object.request);
        }
        message.reports = object.reports?.map(e => Report.fromAmino(e)) || [];
        if (object.result !== undefined && object.result !== null) {
            message.result = Result.fromAmino(object.result);
        }
        if (object.signing !== undefined && object.signing !== null) {
            message.signing = SigningResult.fromAmino(object.signing);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.request = message.request ? Request.toAmino(message.request) : undefined;
        if (message.reports) {
            obj.reports = message.reports.map(e => e ? Report.toAmino(e) : undefined);
        }
        else {
            obj.reports = message.reports;
        }
        obj.result = message.result ? Result.toAmino(message.result) : undefined;
        obj.signing = message.signing ? SigningResult.toAmino(message.signing) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryRequestResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryRequestResponse.decode(message.value);
    },
    toProto(message) {
        return QueryRequestResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryRequestResponse",
            value: QueryRequestResponse.encode(message).finish()
        };
    }
};
function createBaseQueryPendingRequestsRequest() {
    return {
        validatorAddress: ""
    };
}
export const QueryPendingRequestsRequest = {
    typeUrl: "/band.oracle.v1.QueryPendingRequestsRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.validatorAddress !== "") {
            writer.uint32(10).string(message.validatorAddress);
        }
        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 = createBaseQueryPendingRequestsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validatorAddress = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPendingRequestsRequest();
        message.validatorAddress = object.validatorAddress ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPendingRequestsRequest();
        if (object.validator_address !== undefined && object.validator_address !== null) {
            message.validatorAddress = object.validator_address;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPendingRequestsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPendingRequestsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryPendingRequestsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryPendingRequestsRequest",
            value: QueryPendingRequestsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryPendingRequestsResponse() {
    return {
        requestIds: []
    };
}
export const QueryPendingRequestsResponse = {
    typeUrl: "/band.oracle.v1.QueryPendingRequestsResponse",
    encode(message, writer = BinaryWriter.create()) {
        writer.uint32(10).fork();
        for (const v of message.requestIds) {
            writer.uint64(v);
        }
        writer.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 = createBaseQueryPendingRequestsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.requestIds.push(reader.uint64());
                        }
                    }
                    else {
                        message.requestIds.push(reader.uint64());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPendingRequestsResponse();
        message.requestIds = object.requestIds?.map(e => BigInt(e.toString())) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPendingRequestsResponse();
        message.requestIds = object.request_ids?.map(e => BigInt(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.requestIds) {
            obj.request_ids = message.requestIds.map(e => e.toString());
        }
        else {
            obj.request_ids = message.requestIds;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPendingRequestsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPendingRequestsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryPendingRequestsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryPendingRequestsResponse",
            value: QueryPendingRequestsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryParamsRequest() {
    return {};
}
export const QueryParamsRequest = {
    typeUrl: "/band.oracle.v1.QueryParamsRequest",
    encode(_, writer = BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryParamsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseQueryParamsRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseQueryParamsRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return QueryParamsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryParamsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryParamsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryParamsRequest",
            value: QueryParamsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryParamsResponse() {
    return {
        params: Params.fromPartial({})
    };
}
export const QueryParamsResponse = {
    typeUrl: "/band.oracle.v1.QueryParamsResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.params !== undefined) {
            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryParamsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.params = Params.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryParamsResponse();
        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryParamsResponse();
        if (object.params !== undefined && object.params !== null) {
            message.params = Params.fromAmino(object.params);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.params = message.params ? Params.toAmino(message.params) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryParamsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryParamsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryParamsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryParamsResponse",
            value: QueryParamsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryValidatorRequest() {
    return {
        validatorAddress: ""
    };
}
export const QueryValidatorRequest = {
    typeUrl: "/band.oracle.v1.QueryValidatorRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.validatorAddress !== "") {
            writer.uint32(10).string(message.validatorAddress);
        }
        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 = createBaseQueryValidatorRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validatorAddress = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryValidatorRequest();
        message.validatorAddress = object.validatorAddress ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryValidatorRequest();
        if (object.validator_address !== undefined && object.validator_address !== null) {
            message.validatorAddress = object.validator_address;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryValidatorRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryValidatorRequest.decode(message.value);
    },
    toProto(message) {
        return QueryValidatorRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryValidatorRequest",
            value: QueryValidatorRequest.encode(message).finish()
        };
    }
};
function createBaseQueryValidatorResponse() {
    return {
        status: undefined
    };
}
export const QueryValidatorResponse = {
    typeUrl: "/band.oracle.v1.QueryValidatorResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.status !== undefined) {
            ValidatorStatus.encode(message.status, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryValidatorResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.status = ValidatorStatus.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryValidatorResponse();
        message.status = object.status !== undefined && object.status !== null ? ValidatorStatus.fromPartial(object.status) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryValidatorResponse();
        if (object.status !== undefined && object.status !== null) {
            message.status = ValidatorStatus.fromAmino(object.status);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.status = message.status ? ValidatorStatus.toAmino(message.status) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryValidatorResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryValidatorResponse.decode(message.value);
    },
    toProto(message) {
        return QueryValidatorResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryValidatorResponse",
            value: QueryValidatorResponse.encode(message).finish()
        };
    }
};
function createBaseQueryIsReporterRequest() {
    return {
        validatorAddress: "",
        reporterAddress: ""
    };
}
export const QueryIsReporterRequest = {
    typeUrl: "/band.oracle.v1.QueryIsReporterRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.validatorAddress !== "") {
            writer.uint32(10).string(message.validatorAddress);
        }
        if (message.reporterAddress !== "") {
            writer.uint32(18).string(message.reporterAddress);
        }
        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 = createBaseQueryIsReporterRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validatorAddress = reader.string();
                    break;
                case 2:
                    message.reporterAddress = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryIsReporterRequest();
        message.validatorAddress = object.validatorAddress ?? "";
        message.reporterAddress = object.reporterAddress ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryIsReporterRequest();
        if (object.validator_address !== undefined && object.validator_address !== null) {
            message.validatorAddress = object.validator_address;
        }
        if (object.reporter_address !== undefined && object.reporter_address !== null) {
            message.reporterAddress = object.reporter_address;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
        obj.reporter_address = message.reporterAddress === "" ? undefined : message.reporterAddress;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryIsReporterRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryIsReporterRequest.decode(message.value);
    },
    toProto(message) {
        return QueryIsReporterRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryIsReporterRequest",
            value: QueryIsReporterRequest.encode(message).finish()
        };
    }
};
function createBaseQueryIsReporterResponse() {
    return {
        isReporter: false
    };
}
export const QueryIsReporterResponse = {
    typeUrl: "/band.oracle.v1.QueryIsReporterResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.isReporter === true) {
            writer.uint32(8).bool(message.isReporter);
        }
        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 = createBaseQueryIsReporterResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.isReporter = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryIsReporterResponse();
        message.isReporter = object.isReporter ?? false;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryIsReporterResponse();
        if (object.is_reporter !== undefined && object.is_reporter !== null) {
            message.isReporter = object.is_reporter;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.is_reporter = message.isReporter === false ? undefined : message.isReporter;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryIsReporterResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryIsReporterResponse.decode(message.value);
    },
    toProto(message) {
        return QueryIsReporterResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryIsReporterResponse",
            value: QueryIsReporterResponse.encode(message).finish()
        };
    }
};
function createBaseQueryReportersRequest() {
    return {
        validatorAddress: ""
    };
}
export const QueryReportersRequest = {
    typeUrl: "/band.oracle.v1.QueryReportersRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.validatorAddress !== "") {
            writer.uint32(10).string(message.validatorAddress);
        }
        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 = createBaseQueryReportersRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validatorAddress = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryReportersRequest();
        message.validatorAddress = object.validatorAddress ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryReportersRequest();
        if (object.validator_address !== undefined && object.validator_address !== null) {
            message.validatorAddress = object.validator_address;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryReportersRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryReportersRequest.decode(message.value);
    },
    toProto(message) {
        return QueryReportersRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryReportersRequest",
            value: QueryReportersRequest.encode(message).finish()
        };
    }
};
function createBaseQueryReportersResponse() {
    return {
        reporter: []
    };
}
export const QueryReportersResponse = {
    typeUrl: "/band.oracle.v1.QueryReportersResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.reporter) {
            writer.uint32(10).string(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryReportersResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.reporter.push(reader.string());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryReportersResponse();
        message.reporter = object.reporter?.map(e => e) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryReportersResponse();
        message.reporter = object.reporter?.map(e => e) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.reporter) {
            obj.reporter = message.reporter.map(e => e);
        }
        else {
            obj.reporter = message.reporter;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryReportersResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryReportersResponse.decode(message.value);
    },
    toProto(message) {
        return QueryReportersResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryReportersResponse",
            value: QueryReportersResponse.encode(message).finish()
        };
    }
};
function createBaseQueryActiveValidatorsRequest() {
    return {};
}
export const QueryActiveValidatorsRequest = {
    typeUrl: "/band.oracle.v1.QueryActiveValidatorsRequest",
    encode(_, writer = BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryActiveValidatorsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseQueryActiveValidatorsRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseQueryActiveValidatorsRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return QueryActiveValidatorsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryActiveValidatorsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryActiveValidatorsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.oracle.v1.QueryActiveValidatorsRequest",
            value: QueryActiveValidatorsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryActiveValidatorsResponse() {
    return {
        validators: []
    };
}
export const QueryActiveValidatorsResponse = {
    typeUrl: "/band.oracle.v1.QueryActiveValidatorsResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.validators) {
            ActiveValidator.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryActiveValidatorsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.validators.push(ActiveValidator.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryActiveValidatorsResponse();
        message.validators = object.validators?.map(e => ActiveValidator.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryActiveValidatorsResponse();
        message.validators = object.validators?.map(e => ActiveValidator.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.validators) {
            obj.validators = message.validators.map(e => e ? ActiveValidator.toAmino(e) : undefined);
        }
        else {
            obj.validators =