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

TypeScript library for Cosmos SDK and BandChain

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MsgUpdateParamsResponse = exports.MsgUpdateParams = exports.MsgSubmitSignatureResponse = exports.MsgSubmitSignature = exports.MsgResetDEResponse = exports.MsgResetDE = exports.MsgSubmitDEsResponse = exports.MsgSubmitDEs = exports.MsgConfirmResponse = exports.MsgConfirm = exports.MsgComplainResponse = exports.MsgComplain = exports.MsgSubmitDKGRound2Response = exports.MsgSubmitDKGRound2 = exports.MsgSubmitDKGRound1Response = exports.MsgSubmitDKGRound1 = void 0;
//@ts-nocheck
const tss_1 = require("./tss");
const genesis_1 = require("./genesis");
const binary_1 = require("../../../binary");
const helpers_1 = require("../../../helpers");
function createBaseMsgSubmitDKGRound1() {
    return {
        groupId: BigInt(0),
        round1Info: tss_1.Round1Info.fromPartial({}),
        sender: ""
    };
}
exports.MsgSubmitDKGRound1 = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound1",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.groupId !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupId);
        }
        if (message.round1Info !== undefined) {
            tss_1.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 binary_1.BinaryReader ? input : new binary_1.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 = tss_1.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 ? tss_1.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 = tss_1.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 ? tss_1.Round1Info.toAmino(message.round1Info) : undefined;
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgSubmitDKGRound1.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgSubmitDKGRound1",
            value: exports.MsgSubmitDKGRound1.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgSubmitDKGRound1.decode(message.value);
    },
    toProto(message) {
        return exports.MsgSubmitDKGRound1.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound1",
            value: exports.MsgSubmitDKGRound1.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDKGRound1Response() {
    return {};
}
exports.MsgSubmitDKGRound1Response = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound1Response",
    encode(_, writer = binary_1.BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = 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 exports.MsgSubmitDKGRound1Response.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgSubmitDKGRound1Response.decode(message.value);
    },
    toProto(message) {
        return exports.MsgSubmitDKGRound1Response.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound1Response",
            value: exports.MsgSubmitDKGRound1Response.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDKGRound2() {
    return {
        groupId: BigInt(0),
        round2Info: tss_1.Round2Info.fromPartial({}),
        sender: ""
    };
}
exports.MsgSubmitDKGRound2 = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound2",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.groupId !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupId);
        }
        if (message.round2Info !== undefined) {
            tss_1.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 binary_1.BinaryReader ? input : new binary_1.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 = tss_1.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 ? tss_1.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 = tss_1.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 ? tss_1.Round2Info.toAmino(message.round2Info) : undefined;
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgSubmitDKGRound2.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgSubmitDKGRound2",
            value: exports.MsgSubmitDKGRound2.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgSubmitDKGRound2.decode(message.value);
    },
    toProto(message) {
        return exports.MsgSubmitDKGRound2.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound2",
            value: exports.MsgSubmitDKGRound2.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDKGRound2Response() {
    return {};
}
exports.MsgSubmitDKGRound2Response = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound2Response",
    encode(_, writer = binary_1.BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = 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 exports.MsgSubmitDKGRound2Response.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgSubmitDKGRound2Response.decode(message.value);
    },
    toProto(message) {
        return exports.MsgSubmitDKGRound2Response.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDKGRound2Response",
            value: exports.MsgSubmitDKGRound2Response.encode(message).finish()
        };
    }
};
function createBaseMsgComplain() {
    return {
        groupId: BigInt(0),
        complaints: [],
        sender: ""
    };
}
exports.MsgComplain = {
    typeUrl: "/band.tss.v1beta1.MsgComplain",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.groupId !== BigInt(0)) {
            writer.uint32(8).uint64(message.groupId);
        }
        for (const v of message.complaints) {
            tss_1.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 binary_1.BinaryReader ? input : new binary_1.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(tss_1.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 => tss_1.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 => tss_1.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 ? tss_1.Complaint.toAmino(e) : undefined);
        }
        else {
            obj.complaints = message.complaints;
        }
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgComplain.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgComplaint",
            value: exports.MsgComplain.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgComplain.decode(message.value);
    },
    toProto(message) {
        return exports.MsgComplain.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgComplain",
            value: exports.MsgComplain.encode(message).finish()
        };
    }
};
function createBaseMsgComplainResponse() {
    return {};
}
exports.MsgComplainResponse = {
    typeUrl: "/band.tss.v1beta1.MsgComplainResponse",
    encode(_, writer = binary_1.BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = 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 exports.MsgComplainResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgComplainResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgComplainResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgComplainResponse",
            value: exports.MsgComplainResponse.encode(message).finish()
        };
    }
};
function createBaseMsgConfirm() {
    return {
        groupId: BigInt(0),
        memberId: BigInt(0),
        ownPubKeySig: new Uint8Array(),
        sender: ""
    };
}
exports.MsgConfirm = {
    typeUrl: "/band.tss.v1beta1.MsgConfirm",
    encode(message, writer = binary_1.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 binary_1.BinaryReader ? input : new binary_1.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 = (0, helpers_1.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 ? (0, helpers_1.base64FromBytes)(message.ownPubKeySig) : undefined;
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgConfirm.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgConfirm",
            value: exports.MsgConfirm.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgConfirm.decode(message.value);
    },
    toProto(message) {
        return exports.MsgConfirm.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgConfirm",
            value: exports.MsgConfirm.encode(message).finish()
        };
    }
};
function createBaseMsgConfirmResponse() {
    return {};
}
exports.MsgConfirmResponse = {
    typeUrl: "/band.tss.v1beta1.MsgConfirmResponse",
    encode(_, writer = binary_1.BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = 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 exports.MsgConfirmResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgConfirmResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgConfirmResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgConfirmResponse",
            value: exports.MsgConfirmResponse.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDEs() {
    return {
        des: [],
        sender: ""
    };
}
exports.MsgSubmitDEs = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDEs",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        for (const v of message.des) {
            tss_1.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 binary_1.BinaryReader ? input : new binary_1.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(tss_1.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 => tss_1.DE.fromPartial(e)) || [];
        message.sender = object.sender ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgSubmitDEs();
        message.des = object.des?.map(e => tss_1.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 ? tss_1.DE.toAmino(e) : undefined);
        }
        else {
            obj.des = message.des;
        }
        obj.sender = message.sender === "" ? undefined : message.sender;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgSubmitDEs.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgSubmitDEs",
            value: exports.MsgSubmitDEs.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgSubmitDEs.decode(message.value);
    },
    toProto(message) {
        return exports.MsgSubmitDEs.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDEs",
            value: exports.MsgSubmitDEs.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitDEsResponse() {
    return {};
}
exports.MsgSubmitDEsResponse = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitDEsResponse",
    encode(_, writer = binary_1.BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = 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 exports.MsgSubmitDEsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgSubmitDEsResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgSubmitDEsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitDEsResponse",
            value: exports.MsgSubmitDEsResponse.encode(message).finish()
        };
    }
};
function createBaseMsgResetDE() {
    return {
        sender: ""
    };
}
exports.MsgResetDE = {
    typeUrl: "/band.tss.v1beta1.MsgResetDE",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.sender !== "") {
            writer.uint32(10).string(message.sender);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = 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 exports.MsgResetDE.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgResetDE",
            value: exports.MsgResetDE.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgResetDE.decode(message.value);
    },
    toProto(message) {
        return exports.MsgResetDE.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgResetDE",
            value: exports.MsgResetDE.encode(message).finish()
        };
    }
};
function createBaseMsgResetDEResponse() {
    return {};
}
exports.MsgResetDEResponse = {
    typeUrl: "/band.tss.v1beta1.MsgResetDEResponse",
    encode(_, writer = binary_1.BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = 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 exports.MsgResetDEResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgResetDEResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgResetDEResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgResetDEResponse",
            value: exports.MsgResetDEResponse.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitSignature() {
    return {
        signingId: BigInt(0),
        memberId: BigInt(0),
        signature: new Uint8Array(),
        signer: ""
    };
}
exports.MsgSubmitSignature = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitSignature",
    encode(message, writer = binary_1.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 binary_1.BinaryReader ? input : new binary_1.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 = (0, helpers_1.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 ? (0, helpers_1.base64FromBytes)(message.signature) : undefined;
        obj.signer = message.signer === "" ? undefined : message.signer;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgSubmitSignature.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgSubmitSignature",
            value: exports.MsgSubmitSignature.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgSubmitSignature.decode(message.value);
    },
    toProto(message) {
        return exports.MsgSubmitSignature.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitSignature",
            value: exports.MsgSubmitSignature.encode(message).finish()
        };
    }
};
function createBaseMsgSubmitSignatureResponse() {
    return {};
}
exports.MsgSubmitSignatureResponse = {
    typeUrl: "/band.tss.v1beta1.MsgSubmitSignatureResponse",
    encode(_, writer = binary_1.BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = 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 exports.MsgSubmitSignatureResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgSubmitSignatureResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgSubmitSignatureResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgSubmitSignatureResponse",
            value: exports.MsgSubmitSignatureResponse.encode(message).finish()
        };
    }
};
function createBaseMsgUpdateParams() {
    return {
        params: genesis_1.Params.fromPartial({}),
        authority: ""
    };
}
exports.MsgUpdateParams = {
    typeUrl: "/band.tss.v1beta1.MsgUpdateParams",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.params !== undefined) {
            genesis_1.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 binary_1.BinaryReader ? input : new binary_1.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 = genesis_1.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 ? genesis_1.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 = genesis_1.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 ? genesis_1.Params.toAmino(message.params) : undefined;
        obj.authority = message.authority === "" ? undefined : message.authority;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgUpdateParams.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tss/MsgUpdateParams",
            value: exports.MsgUpdateParams.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgUpdateParams.decode(message.value);
    },
    toProto(message) {
        return exports.MsgUpdateParams.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgUpdateParams",
            value: exports.MsgUpdateParams.encode(message).finish()
        };
    }
};
function createBaseMsgUpdateParamsResponse() {
    return {};
}
exports.MsgUpdateParamsResponse = {
    typeUrl: "/band.tss.v1beta1.MsgUpdateParamsResponse",
    encode(_, writer = binary_1.BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = 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 exports.MsgUpdateParamsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgUpdateParamsResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgUpdateParamsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.MsgUpdateParamsResponse",
            value: exports.MsgUpdateParamsResponse.encode(message).finish()
        };
    }
};