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

TypeScript library for Cosmos SDK and BandChain

//@ts-nocheck
import { Round1Info, Round2Info, Complaint, DE } from "./tss";
import { Params } from "./genesis";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { bytesFromBase64, base64FromBytes } from "../../../helpers";
function createBaseMsgSubmitDKGRound1() {
    return {
        groupId: BigInt(0),
        round1Info: Round1Info.fromPartial({}),
        sender: ""
    };
}
export const MsgSubmitDKGRound1 = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound1",
    encode(message, writer = BinaryWriter.create()) {
        if (message.groupId !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupId);
        }
        if (message.round1Info !== undefined) {
            Round1Info.encode(message.round1Info, writer.uint32(18).fork()).ldelim();
        }
        if (message.sender !== "") {
            writer.uint32(26).string(message.sender);
        }
        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 = createBaseMsgSubmitDKGRound1();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.groupId = reader.uint64();
                    break;
                case 2:
                    message.round1Info = Round1Info.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.sender = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgSubmitDKGRound1();
        message.groupId = object.groupId !== undefined && object.groupId !== null ? BigInt(object.groupId.toString()) : BigInt(0);
        message.round1Info = object.round1Info !== undefined && object.round1Info !== null ? Round1Info.fromPartial(object.round1Info) : undefined;
        message.sender = object.sender ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgSubmitDKGRound1();
        if (object.group_id !== undefined && object.group_id !== null) {
            message.groupId = BigInt(object.group_id);
        }
        if (object.round1_info !== undefined && object.round1_info !== null) {
            message.round1Info = Round1Info.fromAmino(object.round1_info);
        }
        if (object.sender !== undefined && object.sender !== null) {
            message.sender = object.sender;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.group_id = message.groupId !== BigInt(0) ? message.groupId?.toString() : undefined;
        obj.round1_info = message.round1Info ? Round1Info.toAmino(message.round1Info) : undefined;
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return MsgSubmitDKGRound1.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgSubmitDKGRound1",
            value: MsgSubmitDKGRound1.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return MsgSubmitDKGRound1.decode(message.value);
    },
    toProto(message) {
        return MsgSubmitDKGRound1.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound1",
            value: MsgSubmitDKGRound1.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDKGRound1Response() {
    return {};
}
export const MsgSubmitDKGRound1Response = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound1Response",
    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 = createBaseMsgSubmitDKGRound1Response();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgSubmitDKGRound1Response();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgSubmitDKGRound1Response();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return MsgSubmitDKGRound1Response.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MsgSubmitDKGRound1Response.decode(message.value);
    },
    toProto(message) {
        return MsgSubmitDKGRound1Response.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound1Response",
            value: MsgSubmitDKGRound1Response.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDKGRound2() {
    return {
        groupId: BigInt(0),
        round2Info: Round2Info.fromPartial({}),
        sender: ""
    };
}
export const MsgSubmitDKGRound2 = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound2",
    encode(message, writer = BinaryWriter.create()) {
        if (message.groupId !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupId);
        }
        if (message.round2Info !== undefined) {
            Round2Info.encode(message.round2Info, writer.uint32(18).fork()).ldelim();
        }
        if (message.sender !== "") {
            writer.uint32(26).string(message.sender);
        }
        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 = createBaseMsgSubmitDKGRound2();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.groupId = reader.uint64();
                    break;
                case 2:
                    message.round2Info = Round2Info.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.sender = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgSubmitDKGRound2();
        message.groupId = object.groupId !== undefined && object.groupId !== null ? BigInt(object.groupId.toString()) : BigInt(0);
        message.round2Info = object.round2Info !== undefined && object.round2Info !== null ? Round2Info.fromPartial(object.round2Info) : undefined;
        message.sender = object.sender ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgSubmitDKGRound2();
        if (object.group_id !== undefined && object.group_id !== null) {
            message.groupId = BigInt(object.group_id);
        }
        if (object.round2_info !== undefined && object.round2_info !== null) {
            message.round2Info = Round2Info.fromAmino(object.round2_info);
        }
        if (object.sender !== undefined && object.sender !== null) {
            message.sender = object.sender;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.group_id = message.groupId !== BigInt(0) ? message.groupId?.toString() : undefined;
        obj.round2_info = message.round2Info ? Round2Info.toAmino(message.round2Info) : undefined;
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return MsgSubmitDKGRound2.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgSubmitDKGRound2",
            value: MsgSubmitDKGRound2.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return MsgSubmitDKGRound2.decode(message.value);
    },
    toProto(message) {
        return MsgSubmitDKGRound2.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound2",
            value: MsgSubmitDKGRound2.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDKGRound2Response() {
    return {};
}
export const MsgSubmitDKGRound2Response = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound2Response",
    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 = createBaseMsgSubmitDKGRound2Response();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgSubmitDKGRound2Response();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgSubmitDKGRound2Response();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return MsgSubmitDKGRound2Response.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MsgSubmitDKGRound2Response.decode(message.value);
    },
    toProto(message) {
        return MsgSubmitDKGRound2Response.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound2Response",
            value: MsgSubmitDKGRound2Response.encode(message).finish()
        };
    }
};
function createBaseMsgComplain() {
    return {
        groupId: BigInt(0),
        complaints: [],
        sender: ""
    };
}
export const MsgComplain = {
    typeUrl: "/band.tss.v1beta1.MsgComplain",
    encode(message, writer = BinaryWriter.create()) {
        if (message.groupId !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupId);
        }
        for (const v of message.complaints) {
            Complaint.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.sender !== "") {
            writer.uint32(26).string(message.sender);
        }
        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 = createBaseMsgComplain();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.groupId = reader.uint64();
                    break;
                case 2:
                    message.complaints.push(Complaint.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.sender = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgComplain();
        message.groupId = object.groupId !== undefined && object.groupId !== null ? BigInt(object.groupId.toString()) : BigInt(0);
        message.complaints = object.complaints?.map(e => Complaint.fromPartial(e)) || [];
        message.sender = object.sender ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgComplain();
        if (object.group_id !== undefined && object.group_id !== null) {
            message.groupId = BigInt(object.group_id);
        }
        message.complaints = object.complaints?.map(e => Complaint.fromAmino(e)) || [];
        if (object.sender !== undefined && object.sender !== null) {
            message.sender = object.sender;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.group_id = message.groupId !== BigInt(0) ? message.groupId?.toString() : undefined;
        if (message.complaints) {
            obj.complaints = message.complaints.map(e => e ? Complaint.toAmino(e) : undefined);
        }
        else {
            obj.complaints = message.complaints;
        }
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return MsgComplain.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgComplaint",
            value: MsgComplain.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return MsgComplain.decode(message.value);
    },
    toProto(message) {
        return MsgComplain.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgComplain",
            value: MsgComplain.encode(message).finish()
        };
    }
};
function createBaseMsgComplainResponse() {
    return {};
}
export const MsgComplainResponse = {
    typeUrl: "/band.tss.v1beta1.MsgComplainResponse",
    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 = createBaseMsgComplainResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgComplainResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgComplainResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return MsgComplainResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MsgComplainResponse.decode(message.value);
    },
    toProto(message) {
        return MsgComplainResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgComplainResponse",
            value: MsgComplainResponse.encode(message).finish()
        };
    }
};
function createBaseMsgConfirm() {
    return {
        groupId: BigInt(0),
        memberId: BigInt(0),
        ownPubKeySig: new Uint8Array(),
        sender: ""
    };
}
export const MsgConfirm = {
    typeUrl: "/band.tss.v1beta1.MsgConfirm",
    encode(message, writer = BinaryWriter.create()) {
        if (message.groupId !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupId);
        }
        if (message.memberId !== BigInt(0)) {
            writer.uint32(16).uint64(message.memberId);
        }
        if (message.ownPubKeySig.length !== 0) {
            writer.uint32(26).bytes(message.ownPubKeySig);
        }
        if (message.sender !== "") {
            writer.uint32(34).string(message.sender);
        }
        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 = createBaseMsgConfirm();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.groupId = reader.uint64();
                    break;
                case 2:
                    message.memberId = reader.uint64();
                    break;
                case 3:
                    message.ownPubKeySig = reader.bytes();
                    break;
                case 4:
                    message.sender = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgConfirm();
        message.groupId = object.groupId !== undefined && object.groupId !== null ? BigInt(object.groupId.toString()) : BigInt(0);
        message.memberId = object.memberId !== undefined && object.memberId !== null ? BigInt(object.memberId.toString()) : BigInt(0);
        message.ownPubKeySig = object.ownPubKeySig ?? new Uint8Array();
        message.sender = object.sender ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgConfirm();
        if (object.group_id !== undefined && object.group_id !== null) {
            message.groupId = BigInt(object.group_id);
        }
        if (object.member_id !== undefined && object.member_id !== null) {
            message.memberId = BigInt(object.member_id);
        }
        if (object.own_pub_key_sig !== undefined && object.own_pub_key_sig !== null) {
            message.ownPubKeySig = bytesFromBase64(object.own_pub_key_sig);
        }
        if (object.sender !== undefined && object.sender !== null) {
            message.sender = object.sender;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.group_id = message.groupId !== BigInt(0) ? message.groupId?.toString() : undefined;
        obj.member_id = message.memberId !== BigInt(0) ? message.memberId?.toString() : undefined;
        obj.own_pub_key_sig = message.ownPubKeySig ? base64FromBytes(message.ownPubKeySig) : undefined;
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return MsgConfirm.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgConfirm",
            value: MsgConfirm.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return MsgConfirm.decode(message.value);
    },
    toProto(message) {
        return MsgConfirm.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgConfirm",
            value: MsgConfirm.encode(message).finish()
        };
    }
};
function createBaseMsgConfirmResponse() {
    return {};
}
export const MsgConfirmResponse = {
    typeUrl: "/band.tss.v1beta1.MsgConfirmResponse",
    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 = createBaseMsgConfirmResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgConfirmResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgConfirmResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return MsgConfirmResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MsgConfirmResponse.decode(message.value);
    },
    toProto(message) {
        return MsgConfirmResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgConfirmResponse",
            value: MsgConfirmResponse.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDEs() {
    return {
        des: [],
        sender: ""
    };
}
export const MsgSubmitDEs = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDEs",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.des) {
            DE.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.sender !== "") {
            writer.uint32(18).string(message.sender);
        }
        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 = createBaseMsgSubmitDEs();
        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.sender = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgSubmitDEs();
        message.des = object.des?.map(e => DE.fromPartial(e)) || [];
        message.sender = object.sender ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgSubmitDEs();
        message.des = object.des?.map(e => DE.fromAmino(e)) || [];
        if (object.sender !== undefined && object.sender !== null) {
            message.sender = object.sender;
        }
        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.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return MsgSubmitDEs.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgSubmitDEs",
            value: MsgSubmitDEs.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return MsgSubmitDEs.decode(message.value);
    },
    toProto(message) {
        return MsgSubmitDEs.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDEs",
            value: MsgSubmitDEs.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDEsResponse() {
    return {};
}
export const MsgSubmitDEsResponse = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDEsResponse",
    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 = createBaseMsgSubmitDEsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgSubmitDEsResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgSubmitDEsResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return MsgSubmitDEsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MsgSubmitDEsResponse.decode(message.value);
    },
    toProto(message) {
        return MsgSubmitDEsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDEsResponse",
            value: MsgSubmitDEsResponse.encode(message).finish()
        };
    }
};
function createBaseMsgResetDE() {
    return {
        sender: ""
    };
}
export const MsgResetDE = {
    typeUrl: "/band.tss.v1beta1.MsgResetDE",
    encode(message, writer = BinaryWriter.create()) {
        if (message.sender !== "") {
            writer.uint32(10).string(message.sender);
        }
        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 = createBaseMsgResetDE();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sender = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgResetDE();
        message.sender = object.sender ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgResetDE();
        if (object.sender !== undefined && object.sender !== null) {
            message.sender = object.sender;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return MsgResetDE.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgResetDE",
            value: MsgResetDE.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return MsgResetDE.decode(message.value);
    },
    toProto(message) {
        return MsgResetDE.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgResetDE",
            value: MsgResetDE.encode(message).finish()
        };
    }
};
function createBaseMsgResetDEResponse() {
    return {};
}
export const MsgResetDEResponse = {
    typeUrl: "/band.tss.v1beta1.MsgResetDEResponse",
    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 = createBaseMsgResetDEResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgResetDEResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgResetDEResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return MsgResetDEResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MsgResetDEResponse.decode(message.value);
    },
    toProto(message) {
        return MsgResetDEResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgResetDEResponse",
            value: MsgResetDEResponse.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitSignature() {
    return {
        signingId: BigInt(0),
        memberId: BigInt(0),
        signature: new Uint8Array(),
        signer: ""
    };
}
export const MsgSubmitSignature = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitSignature",
    encode(message, writer = BinaryWriter.create()) {
        if (message.signingId !== BigInt(0)) {
            writer.uint32(8).uint64(message.signingId);
        }
        if (message.memberId !== BigInt(0)) {
            writer.uint32(16).uint64(message.memberId);
        }
        if (message.signature.length !== 0) {
            writer.uint32(26).bytes(message.signature);
        }
        if (message.signer !== "") {
            writer.uint32(34).string(message.signer);
        }
        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 = createBaseMsgSubmitSignature();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signingId = reader.uint64();
                    break;
                case 2:
                    message.memberId = reader.uint64();
                    break;
                case 3:
                    message.signature = reader.bytes();
                    break;
                case 4:
                    message.signer = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgSubmitSignature();
        message.signingId = object.signingId !== undefined && object.signingId !== null ? BigInt(object.signingId.toString()) : BigInt(0);
        message.memberId = object.memberId !== undefined && object.memberId !== null ? BigInt(object.memberId.toString()) : BigInt(0);
        message.signature = object.signature ?? new Uint8Array();
        message.signer = object.signer ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgSubmitSignature();
        if (object.signing_id !== undefined && object.signing_id !== null) {
            message.signingId = BigInt(object.signing_id);
        }
        if (object.member_id !== undefined && object.member_id !== null) {
            message.memberId = BigInt(object.member_id);
        }
        if (object.signature !== undefined && object.signature !== null) {
            message.signature = bytesFromBase64(object.signature);
        }
        if (object.signer !== undefined && object.signer !== null) {
            message.signer = object.signer;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.signing_id = message.signingId !== BigInt(0) ? message.signingId?.toString() : undefined;
        obj.member_id = message.memberId !== BigInt(0) ? message.memberId?.toString() : undefined;
        obj.signature = message.signature ? base64FromBytes(message.signature) : undefined;
        obj.signer = message.signer === "" ? undefined : message.signer;
        return obj;
    },
    fromAminoMsg(object) {
        return MsgSubmitSignature.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgSubmitSignature",
            value: MsgSubmitSignature.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return MsgSubmitSignature.decode(message.value);
    },
    toProto(message) {
        return MsgSubmitSignature.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitSignature",
            value: MsgSubmitSignature.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitSignatureResponse() {
    return {};
}
export const MsgSubmitSignatureResponse = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitSignatureResponse",
    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 = createBaseMsgSubmitSignatureResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgSubmitSignatureResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgSubmitSignatureResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return MsgSubmitSignatureResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MsgSubmitSignatureResponse.decode(message.value);
    },
    toProto(message) {
        return MsgSubmitSignatureResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitSignatureResponse",
            value: MsgSubmitSignatureResponse.encode(message).finish()
        };
    }
};
function createBaseMsgUpdateParams() {
    return {
        params: Params.fromPartial({}),
        authority: ""
    };
}
export const MsgUpdateParams = {
    typeUrl: "/band.tss.v1beta1.MsgUpdateParams",
    encode(message, writer = BinaryWriter.create()) {
        if (message.params !== undefined) {
            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
        }
        if (message.authority !== "") {
            writer.uint32(18).string(message.authority);
        }
        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 = createBaseMsgUpdateParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.params = Params.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.authority = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgUpdateParams();
        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
        message.authority = object.authority ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgUpdateParams();
        if (object.params !== undefined && object.params !== null) {
            message.params = Params.fromAmino(object.params);
        }
        if (object.authority !== undefined && object.authority !== null) {
            message.authority = object.authority;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.params = message.params ? Params.toAmino(message.params) : undefined;
        obj.authority = message.authority === "" ? undefined : message.authority;
        return obj;
    },
    fromAminoMsg(object) {
        return MsgUpdateParams.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgUpdateParams",
            value: MsgUpdateParams.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return MsgUpdateParams.decode(message.value);
    },
    toProto(message) {
        return MsgUpdateParams.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgUpdateParams",
            value: MsgUpdateParams.encode(message).finish()
        };
    }
};
function createBaseMsgUpdateParamsResponse() {
    return {};
}
export const MsgUpdateParamsResponse = {
    typeUrl: "/band.tss.v1beta1.MsgUpdateParamsResponse",
    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 = createBaseMsgUpdateParamsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgUpdateParamsResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgUpdateParamsResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return MsgUpdateParamsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MsgUpdateParamsResponse.decode(message.value);
    },
    toProto(message) {
        return MsgUpdateParamsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgUpdateParamsResponse",
            value: MsgUpdateParamsResponse.encode(message).finish()
        };
    }
};