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

TypeScript library for Cosmos SDK and BandChain

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DEGenesis = exports.Params = exports.GenesisState = void 0;
//@ts-nocheck
const tss_1 = require("./tss");
const binary_1 = require("../../../binary");
function createBaseGenesisState() {
    return {
        params: exports.Params.fromPartial({}),
        groups: [],
        members: [],
        des: []
    };
}
exports.GenesisState = {
    typeUrl: "/band.tss.v1beta1.GenesisState",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.params !== undefined) {
            exports.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.groups) {
            tss_1.Group.encode(v, writer.uint32(18).fork()).ldelim();
        }
        for (const v of message.members) {
            tss_1.Member.encode(v, writer.uint32(26).fork()).ldelim();
        }
        for (const v of message.des) {
            exports.DEGenesis.encode(v, writer.uint32(34).fork()).ldelim();
        }
        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 = createBaseGenesisState();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.params = exports.Params.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.groups.push(tss_1.Group.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.members.push(tss_1.Member.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.des.push(exports.DEGenesis.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseGenesisState();
        message.params = object.params !== undefined && object.params !== null ? exports.Params.fromPartial(object.params) : undefined;
        message.groups = object.groups?.map(e => tss_1.Group.fromPartial(e)) || [];
        message.members = object.members?.map(e => tss_1.Member.fromPartial(e)) || [];
        message.des = object.des?.map(e => exports.DEGenesis.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseGenesisState();
        if (object.params !== undefined && object.params !== null) {
            message.params = exports.Params.fromAmino(object.params);
        }
        message.groups = object.groups?.map(e => tss_1.Group.fromAmino(e)) || [];
        message.members = object.members?.map(e => tss_1.Member.fromAmino(e)) || [];
        message.des = object.des?.map(e => exports.DEGenesis.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.params = message.params ? exports.Params.toAmino(message.params) : undefined;
        if (message.groups) {
            obj.groups = message.groups.map(e => e ? tss_1.Group.toAmino(e) : undefined);
        }
        else {
            obj.groups = message.groups;
        }
        if (message.members) {
            obj.members = message.members.map(e => e ? tss_1.Member.toAmino(e) : undefined);
        }
        else {
            obj.members = message.members;
        }
        if (message.des) {
            obj.des = message.des.map(e => e ? exports.DEGenesis.toAmino(e) : undefined);
        }
        else {
            obj.des = message.des;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return exports.GenesisState.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.GenesisState.decode(message.value);
    },
    toProto(message) {
        return exports.GenesisState.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.GenesisState",
            value: exports.GenesisState.encode(message).finish()
        };
    }
};
function createBaseParams() {
    return {
        maxGroupSize: BigInt(0),
        maxDeSize: BigInt(0),
        creationPeriod: BigInt(0),
        signingPeriod: BigInt(0),
        maxSigningAttempt: BigInt(0),
        maxMemoLength: BigInt(0),
        maxMessageLength: BigInt(0)
    };
}
exports.Params = {
    typeUrl: "/band.tss.v1beta1.Params",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.maxGroupSize !== BigInt(0)) {
            writer.uint32(8).uint64(message.maxGroupSize);
        }
        if (message.maxDeSize !== BigInt(0)) {
            writer.uint32(16).uint64(message.maxDeSize);
        }
        if (message.creationPeriod !== BigInt(0)) {
            writer.uint32(24).uint64(message.creationPeriod);
        }
        if (message.signingPeriod !== BigInt(0)) {
            writer.uint32(32).uint64(message.signingPeriod);
        }
        if (message.maxSigningAttempt !== BigInt(0)) {
            writer.uint32(40).uint64(message.maxSigningAttempt);
        }
        if (message.maxMemoLength !== BigInt(0)) {
            writer.uint32(48).uint64(message.maxMemoLength);
        }
        if (message.maxMessageLength !== BigInt(0)) {
            writer.uint32(56).uint64(message.maxMessageLength);
        }
        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 = createBaseParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.maxGroupSize = reader.uint64();
                    break;
                case 2:
                    message.maxDeSize = reader.uint64();
                    break;
                case 3:
                    message.creationPeriod = reader.uint64();
                    break;
                case 4:
                    message.signingPeriod = reader.uint64();
                    break;
                case 5:
                    message.maxSigningAttempt = reader.uint64();
                    break;
                case 6:
                    message.maxMemoLength = reader.uint64();
                    break;
                case 7:
                    message.maxMessageLength = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseParams();
        message.maxGroupSize = object.maxGroupSize !== undefined && object.maxGroupSize !== null ? BigInt(object.maxGroupSize.toString()) : BigInt(0);
        message.maxDeSize = object.maxDeSize !== undefined && object.maxDeSize !== null ? BigInt(object.maxDeSize.toString()) : BigInt(0);
        message.creationPeriod = object.creationPeriod !== undefined && object.creationPeriod !== null ? BigInt(object.creationPeriod.toString()) : BigInt(0);
        message.signingPeriod = object.signingPeriod !== undefined && object.signingPeriod !== null ? BigInt(object.signingPeriod.toString()) : BigInt(0);
        message.maxSigningAttempt = object.maxSigningAttempt !== undefined && object.maxSigningAttempt !== null ? BigInt(object.maxSigningAttempt.toString()) : BigInt(0);
        message.maxMemoLength = object.maxMemoLength !== undefined && object.maxMemoLength !== null ? BigInt(object.maxMemoLength.toString()) : BigInt(0);
        message.maxMessageLength = object.maxMessageLength !== undefined && object.maxMessageLength !== null ? BigInt(object.maxMessageLength.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseParams();
        if (object.max_group_size !== undefined && object.max_group_size !== null) {
            message.maxGroupSize = BigInt(object.max_group_size);
        }
        if (object.max_de_size !== undefined && object.max_de_size !== null) {
            message.maxDeSize = BigInt(object.max_de_size);
        }
        if (object.creation_period !== undefined && object.creation_period !== null) {
            message.creationPeriod = BigInt(object.creation_period);
        }
        if (object.signing_period !== undefined && object.signing_period !== null) {
            message.signingPeriod = BigInt(object.signing_period);
        }
        if (object.max_signing_attempt !== undefined && object.max_signing_attempt !== null) {
            message.maxSigningAttempt = BigInt(object.max_signing_attempt);
        }
        if (object.max_memo_length !== undefined && object.max_memo_length !== null) {
            message.maxMemoLength = BigInt(object.max_memo_length);
        }
        if (object.max_message_length !== undefined && object.max_message_length !== null) {
            message.maxMessageLength = BigInt(object.max_message_length);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.max_group_size = message.maxGroupSize !== BigInt(0) ? message.maxGroupSize?.toString() : undefined;
        obj.max_de_size = message.maxDeSize !== BigInt(0) ? message.maxDeSize?.toString() : undefined;
        obj.creation_period = message.creationPeriod !== BigInt(0) ? message.creationPeriod?.toString() : undefined;
        obj.signing_period = message.signingPeriod !== BigInt(0) ? message.signingPeriod?.toString() : undefined;
        obj.max_signing_attempt = message.maxSigningAttempt !== BigInt(0) ? message.maxSigningAttempt?.toString() : undefined;
        obj.max_memo_length = message.maxMemoLength !== BigInt(0) ? message.maxMemoLength?.toString() : undefined;
        obj.max_message_length = message.maxMessageLength !== BigInt(0) ? message.maxMessageLength?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.Params.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.Params.decode(message.value);
    },
    toProto(message) {
        return exports.Params.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.Params",
            value: exports.Params.encode(message).finish()
        };
    }
};
function createBaseDEGenesis() {
    return {
        address: "",
        de: tss_1.DE.fromPartial({})
    };
}
exports.DEGenesis = {
    typeUrl: "/band.tss.v1beta1.DEGenesis",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        if (message.de !== undefined) {
            tss_1.DE.encode(message.de, writer.uint32(18).fork()).ldelim();
        }
        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 = createBaseDEGenesis();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.address = reader.string();
                    break;
                case 2:
                    message.de = tss_1.DE.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseDEGenesis();
        message.address = object.address ?? "";
        message.de = object.de !== undefined && object.de !== null ? tss_1.DE.fromPartial(object.de) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseDEGenesis();
        if (object.address !== undefined && object.address !== null) {
            message.address = object.address;
        }
        if (object.de !== undefined && object.de !== null) {
            message.de = tss_1.DE.fromAmino(object.de);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.address = message.address === "" ? undefined : message.address;
        obj.de = message.de ? tss_1.DE.toAmino(message.de) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.DEGenesis.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.DEGenesis.decode(message.value);
    },
    toProto(message) {
        return exports.DEGenesis.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tss.v1beta1.DEGenesis",
            value: exports.DEGenesis.encode(message).finish()
        };
    }
};