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

TypeScript library for Cosmos SDK and BandChain

//@ts-nocheck
import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
import { GroupResult, Member, DE, SigningResult } from "./tss";
import { Params } from "./genesis";
import { BinaryReader, BinaryWriter } from "../../../binary";
function createBaseQueryCountsRequest() {
    return {};
}
export const QueryCountsRequest = {
    typeUrl: "/band.tss.v1beta1.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.tss.v1beta1.QueryCountsRequest",
            value: QueryCountsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryCountsResponse() {
    return {
        groupCount: BigInt(0),
        signingCount: BigInt(0)
    };
}
export const QueryCountsResponse = {
    typeUrl: "/band.tss.v1beta1.QueryCountsResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.groupCount !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupCount);
        }
        if (message.signingCount !== BigInt(0)) {
            writer.uint32(16).uint64(message.signingCount);
        }
        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.groupCount = reader.uint64();
                    break;
                case 2:
                    message.signingCount = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryCountsResponse();
        message.groupCount = object.groupCount !== undefined && object.groupCount !== null ? BigInt(object.groupCount.toString()) : BigInt(0);
        message.signingCount = object.signingCount !== undefined && object.signingCount !== null ? BigInt(object.signingCount.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryCountsResponse();
        if (object.group_count !== undefined && object.group_count !== null) {
            message.groupCount = BigInt(object.group_count);
        }
        if (object.signing_count !== undefined && object.signing_count !== null) {
            message.signingCount = BigInt(object.signing_count);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.group_count = message.groupCount !== BigInt(0) ? message.groupCount?.toString() : undefined;
        obj.signing_count = message.signingCount !== BigInt(0) ? message.signingCount?.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.tss.v1beta1.QueryCountsResponse",
            value: QueryCountsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryGroupRequest() {
    return {
        groupId: BigInt(0)
    };
}
export const QueryGroupRequest = {
    typeUrl: "/band.tss.v1beta1.QueryGroupRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.groupId !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupId);
        }
        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 = createBaseQueryGroupRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.groupId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryGroupRequest();
        message.groupId = object.groupId !== undefined && object.groupId !== null ? BigInt(object.groupId.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryGroupRequest();
        if (object.group_id !== undefined && object.group_id !== null) {
            message.groupId = BigInt(object.group_id);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.group_id = message.groupId !== BigInt(0) ? message.groupId?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryGroupRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryGroupRequest.decode(message.value);
    },
    toProto(message) {
        return QueryGroupRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryGroupRequest",
            value: QueryGroupRequest.encode(message).finish()
        };
    }
};
function createBaseQueryGroupResponse() {
    return {
        groupResult: GroupResult.fromPartial({})
    };
}
export const QueryGroupResponse = {
    typeUrl: "/band.tss.v1beta1.QueryGroupResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.groupResult !== undefined) {
            GroupResult.encode(message.groupResult, 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 = createBaseQueryGroupResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.groupResult = GroupResult.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryGroupResponse();
        message.groupResult = object.groupResult !== undefined && object.groupResult !== null ? GroupResult.fromPartial(object.groupResult) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryGroupResponse();
        if (object.group_result !== undefined && object.group_result !== null) {
            message.groupResult = GroupResult.fromAmino(object.group_result);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.group_result = message.groupResult ? GroupResult.toAmino(message.groupResult) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryGroupResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryGroupResponse.decode(message.value);
    },
    toProto(message) {
        return QueryGroupResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryGroupResponse",
            value: QueryGroupResponse.encode(message).finish()
        };
    }
};
function createBaseQueryGroupsRequest() {
    return {
        pagination: undefined
    };
}
export const QueryGroupsRequest = {
    typeUrl: "/band.tss.v1beta1.QueryGroupsRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryGroupsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryGroupsRequest();
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryGroupsRequest();
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryGroupsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryGroupsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryGroupsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryGroupsRequest",
            value: QueryGroupsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryGroupsResponse() {
    return {
        groups: [],
        pagination: undefined
    };
}
export const QueryGroupsResponse = {
    typeUrl: "/band.tss.v1beta1.QueryGroupsResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.groups) {
            GroupResult.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryGroupsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.groups.push(GroupResult.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryGroupsResponse();
        message.groups = object.groups?.map(e => GroupResult.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryGroupsResponse();
        message.groups = object.groups?.map(e => GroupResult.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.groups) {
            obj.groups = message.groups.map(e => e ? GroupResult.toAmino(e) : undefined);
        }
        else {
            obj.groups = message.groups;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryGroupsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryGroupsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryGroupsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryGroupsResponse",
            value: QueryGroupsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryMembersRequest() {
    return {
        groupId: BigInt(0)
    };
}
export const QueryMembersRequest = {
    typeUrl: "/band.tss.v1beta1.QueryMembersRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.groupId !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupId);
        }
        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 = createBaseQueryMembersRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.groupId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryMembersRequest();
        message.groupId = object.groupId !== undefined && object.groupId !== null ? BigInt(object.groupId.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryMembersRequest();
        if (object.group_id !== undefined && object.group_id !== null) {
            message.groupId = BigInt(object.group_id);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.group_id = message.groupId !== BigInt(0) ? message.groupId?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryMembersRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryMembersRequest.decode(message.value);
    },
    toProto(message) {
        return QueryMembersRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryMembersRequest",
            value: QueryMembersRequest.encode(message).finish()
        };
    }
};
function createBaseQueryMembersResponse() {
    return {
        members: []
    };
}
export const QueryMembersResponse = {
    typeUrl: "/band.tss.v1beta1.QueryMembersResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.members) {
            Member.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 = createBaseQueryMembersResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.members.push(Member.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryMembersResponse();
        message.members = object.members?.map(e => Member.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryMembersResponse();
        message.members = object.members?.map(e => Member.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.members) {
            obj.members = message.members.map(e => e ? Member.toAmino(e) : undefined);
        }
        else {
            obj.members = message.members;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryMembersResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryMembersResponse.decode(message.value);
    },
    toProto(message) {
        return QueryMembersResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryMembersResponse",
            value: QueryMembersResponse.encode(message).finish()
        };
    }
};
function createBaseQueryIsGranteeRequest() {
    return {
        granter: "",
        grantee: ""
    };
}
export const QueryIsGranteeRequest = {
    typeUrl: "/band.tss.v1beta1.QueryIsGranteeRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.granter !== "") {
            writer.uint32(10).string(message.granter);
        }
        if (message.grantee !== "") {
            writer.uint32(18).string(message.grantee);
        }
        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 = createBaseQueryIsGranteeRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.granter = reader.string();
                    break;
                case 2:
                    message.grantee = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryIsGranteeRequest();
        message.granter = object.granter ?? "";
        message.grantee = object.grantee ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryIsGranteeRequest();
        if (object.granter !== undefined && object.granter !== null) {
            message.granter = object.granter;
        }
        if (object.grantee !== undefined && object.grantee !== null) {
            message.grantee = object.grantee;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.granter = message.granter === "" ? undefined : message.granter;
        obj.grantee = message.grantee === "" ? undefined : message.grantee;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryIsGranteeRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryIsGranteeRequest.decode(message.value);
    },
    toProto(message) {
        return QueryIsGranteeRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryIsGranteeRequest",
            value: QueryIsGranteeRequest.encode(message).finish()
        };
    }
};
function createBaseQueryIsGranteeResponse() {
    return {
        isGrantee: false
    };
}
export const QueryIsGranteeResponse = {
    typeUrl: "/band.tss.v1beta1.QueryIsGranteeResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.isGrantee === true) {
            writer.uint32(8).bool(message.isGrantee);
        }
        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 = createBaseQueryIsGranteeResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.isGrantee = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryIsGranteeResponse();
        message.isGrantee = object.isGrantee ?? false;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryIsGranteeResponse();
        if (object.is_grantee !== undefined && object.is_grantee !== null) {
            message.isGrantee = object.is_grantee;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.is_grantee = message.isGrantee === false ? undefined : message.isGrantee;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryIsGranteeResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryIsGranteeResponse.decode(message.value);
    },
    toProto(message) {
        return QueryIsGranteeResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryIsGranteeResponse",
            value: QueryIsGranteeResponse.encode(message).finish()
        };
    }
};
function createBaseQueryDERequest() {
    return {
        address: "",
        pagination: undefined
    };
}
export const QueryDERequest = {
    typeUrl: "/band.tss.v1beta1.QueryDERequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryDERequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.address = reader.string();
                    break;
                case 2:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryDERequest();
        message.address = object.address ?? "";
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDERequest();
        if (object.address !== undefined && object.address !== null) {
            message.address = object.address;
        }
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.address = message.address === "" ? undefined : message.address;
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDERequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDERequest.decode(message.value);
    },
    toProto(message) {
        return QueryDERequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryDERequest",
            value: QueryDERequest.encode(message).finish()
        };
    }
};
function createBaseQueryDEResponse() {
    return {
        des: [],
        pagination: undefined
    };
}
export const QueryDEResponse = {
    typeUrl: "/band.tss.v1beta1.QueryDEResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.des) {
            DE.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryDEResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.des.push(DE.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryDEResponse();
        message.des = object.des?.map(e => DE.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDEResponse();
        message.des = object.des?.map(e => DE.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.des) {
            obj.des = message.des.map(e => e ? DE.toAmino(e) : undefined);
        }
        else {
            obj.des = message.des;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDEResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDEResponse.decode(message.value);
    },
    toProto(message) {
        return QueryDEResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryDEResponse",
            value: QueryDEResponse.encode(message).finish()
        };
    }
};
function createBaseQueryPendingGroupsRequest() {
    return {
        address: ""
    };
}
export const QueryPendingGroupsRequest = {
    typeUrl: "/band.tss.v1beta1.QueryPendingGroupsRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        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 = createBaseQueryPendingGroupsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.address = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPendingGroupsRequest();
        message.address = object.address ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPendingGroupsRequest();
        if (object.address !== undefined && object.address !== null) {
            message.address = object.address;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.address = message.address === "" ? undefined : message.address;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPendingGroupsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPendingGroupsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryPendingGroupsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryPendingGroupsRequest",
            value: QueryPendingGroupsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryPendingGroupsResponse() {
    return {
        pendingGroups: []
    };
}
export const QueryPendingGroupsResponse = {
    typeUrl: "/band.tss.v1beta1.QueryPendingGroupsResponse",
    encode(message, writer = BinaryWriter.create()) {
        writer.uint32(10).fork();
        for (const v of message.pendingGroups) {
            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 = createBaseQueryPendingGroupsResponse();
        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.pendingGroups.push(reader.uint64());
                        }
                    }
                    else {
                        message.pendingGroups.push(reader.uint64());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPendingGroupsResponse();
        message.pendingGroups = object.pendingGroups?.map(e => BigInt(e.toString())) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPendingGroupsResponse();
        message.pendingGroups = object.pending_groups?.map(e => BigInt(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.pendingGroups) {
            obj.pending_groups = message.pendingGroups.map(e => e.toString());
        }
        else {
            obj.pending_groups = message.pendingGroups;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPendingGroupsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPendingGroupsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryPendingGroupsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryPendingGroupsResponse",
            value: QueryPendingGroupsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryPendingSigningsRequest() {
    return {
        address: ""
    };
}
export const QueryPendingSigningsRequest = {
    typeUrl: "/band.tss.v1beta1.QueryPendingSigningsRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        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 = createBaseQueryPendingSigningsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.address = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPendingSigningsRequest();
        message.address = object.address ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPendingSigningsRequest();
        if (object.address !== undefined && object.address !== null) {
            message.address = object.address;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.address = message.address === "" ? undefined : message.address;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPendingSigningsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPendingSigningsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryPendingSigningsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryPendingSigningsRequest",
            value: QueryPendingSigningsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryPendingSigningsResponse() {
    return {
        pendingSignings: []
    };
}
export const QueryPendingSigningsResponse = {
    typeUrl: "/band.tss.v1beta1.QueryPendingSigningsResponse",
    encode(message, writer = BinaryWriter.create()) {
        writer.uint32(10).fork();
        for (const v of message.pendingSignings) {
            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 = createBaseQueryPendingSigningsResponse();
        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.pendingSignings.push(reader.uint64());
                        }
                    }
                    else {
                        message.pendingSignings.push(reader.uint64());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPendingSigningsResponse();
        message.pendingSignings = object.pendingSignings?.map(e => BigInt(e.toString())) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPendingSigningsResponse();
        message.pendingSignings = object.pending_signings?.map(e => BigInt(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.pendingSignings) {
            obj.pending_signings = message.pendingSignings.map(e => e.toString());
        }
        else {
            obj.pending_signings = message.pendingSignings;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPendingSigningsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPendingSigningsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryPendingSigningsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryPendingSigningsResponse",
            value: QueryPendingSigningsResponse.encode(message).finish()
        };
    }
};
function createBaseQuerySigningRequest() {
    return {
        signingId: BigInt(0)
    };
}
export const QuerySigningRequest = {
    typeUrl: "/band.tss.v1beta1.QuerySigningRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.signingId !== BigInt(0)) {
            writer.uint32(8).uint64(message.signingId);
        }
        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 = createBaseQuerySigningRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signingId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQuerySigningRequest();
        message.signingId = object.signingId !== undefined && object.signingId !== null ? BigInt(object.signingId.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQuerySigningRequest();
        if (object.signing_id !== undefined && object.signing_id !== null) {
            message.signingId = BigInt(object.signing_id);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.signing_id = message.signingId !== BigInt(0) ? message.signingId?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QuerySigningRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QuerySigningRequest.decode(message.value);
    },
    toProto(message) {
        return QuerySigningRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QuerySigningRequest",
            value: QuerySigningRequest.encode(message).finish()
        };
    }
};
function createBaseQuerySigningResponse() {
    return {
        signingResult: SigningResult.fromPartial({})
    };
}
export const QuerySigningResponse = {
    typeUrl: "/band.tss.v1beta1.QuerySigningResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.signingResult !== undefined) {
            SigningResult.encode(message.signingResult, 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 = createBaseQuerySigningResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signingResult = SigningResult.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQuerySigningResponse();
        message.signingResult = object.signingResult !== undefined && object.signingResult !== null ? SigningResult.fromPartial(object.signingResult) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQuerySigningResponse();
        if (object.signing_result !== undefined && object.signing_result !== null) {
            message.signingResult = SigningResult.fromAmino(object.signing_result);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.signing_result = message.signingResult ? SigningResult.toAmino(message.signingResult) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QuerySigningResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QuerySigningResponse.decode(message.value);
    },
    toProto(message) {
        return QuerySigningResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QuerySigningResponse",
            value: QuerySigningResponse.encode(message).finish()
        };
    }
};
function createBaseQuerySigningsRequest() {
    return {
        pagination: undefined
    };
}
export const QuerySigningsRequest = {
    typeUrl: "/band.tss.v1beta1.QuerySigningsRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQuerySigningsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQuerySigningsRequest();
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQuerySigningsRequest();
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QuerySigningsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QuerySigningsRequest.decode(message.value);
    },
    toProto(message) {
        return QuerySigningsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QuerySigningsRequest",
            value: QuerySigningsRequest.encode(message).finish()
        };
    }
};
function createBaseQuerySigningsResponse() {
    return {
        signingResults: [],
        pagination: undefined
    };
}
export const QuerySigningsResponse = {
    typeUrl: "/band.tss.v1beta1.QuerySigningsResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.signingResults) {
            SigningResult.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQuerySigningsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signingResults.push(SigningResult.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQuerySigningsResponse();
        message.signingResults = object.signingResults?.map(e => SigningResult.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQuerySigningsResponse();
        message.signingResults = object.signing_results?.map(e => SigningResult.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.signingResults) {
            obj.signing_results = message.signingResults.map(e => e ? SigningResult.toAmino(e) : undefined);
        }
        else {
            obj.signing_results = message.signingResults;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QuerySigningsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QuerySigningsResponse.decode(message.value);
    },
    toProto(message) {
        return QuerySigningsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QuerySigningsResponse",
            value: QuerySigningsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryParamsRequest() {
    return {};
}
export const QueryParamsRequest = {
    typeUrl: "/band.tss.v1beta1.QueryParamsRequest",
    encode(_, writer = BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryParamsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseQueryParamsRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseQueryParamsRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return QueryParamsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryParamsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryParamsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.QueryParamsRequest",
            value: QueryParamsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryParamsResponse() {
    return {
        params: Params.fromPartial({})
    };
}
export const QueryParamsResponse = {
    typeUrl: "/band.tss.v1beta1.QueryParamsResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.params !== undefined) {
            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryParamsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.params = Params.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }