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

TypeScript library for Cosmos SDK and BandChain

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RouteI_ToAmino = exports.RouteI_FromAmino = exports.RouteI_InterfaceDecoder = exports.MsgUpdateParamsResponse = exports.MsgUpdateParams = exports.MsgWithdrawFromTunnelResponse = exports.MsgWithdrawFromTunnel = exports.MsgDepositToTunnelResponse = exports.MsgDepositToTunnel = exports.MsgTriggerTunnelResponse = exports.MsgTriggerTunnel = exports.MsgDeactivateTunnelResponse = exports.MsgDeactivateTunnel = exports.MsgActivateTunnelResponse = exports.MsgActivateTunnel = exports.MsgWithdrawFeePayerFundsResponse = exports.MsgWithdrawFeePayerFunds = exports.MsgUpdateSignalsAndIntervalResponse = exports.MsgUpdateSignalsAndInterval = exports.MsgUpdateRouteResponse = exports.MsgUpdateRoute = exports.MsgCreateTunnelResponse = exports.MsgCreateTunnel = void 0;
//@ts-nocheck
const tunnel_1 = require("./tunnel");
const any_1 = require("../../../google/protobuf/any");
const coin_1 = require("../../../cosmos/base/v1beta1/coin");
const params_1 = require("./params");
const route_1 = require("./route");
const binary_1 = require("../../../binary");
function createBaseMsgCreateTunnel() {
    return {
        signalDeviations: [],
        interval: BigInt(0),
        route: undefined,
        initialDeposit: [],
        creator: ""
    };
}
exports.MsgCreateTunnel = {
    typeUrl: "/band.tunnel.v1beta1.MsgCreateTunnel",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        for (const v of message.signalDeviations) {
            tunnel_1.SignalDeviation.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.interval !== BigInt(0)) {
            writer.uint32(16).uint64(message.interval);
        }
        if (message.route !== undefined) {
            any_1.Any.encode(message.route, writer.uint32(26).fork()).ldelim();
        }
        for (const v of message.initialDeposit) {
            coin_1.Coin.encode(v, writer.uint32(34).fork()).ldelim();
        }
        if (message.creator !== "") {
            writer.uint32(42).string(message.creator);
        }
        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 = createBaseMsgCreateTunnel();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalDeviations.push(tunnel_1.SignalDeviation.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.interval = reader.uint64();
                    break;
                case 3:
                    message.route = (0, exports.RouteI_InterfaceDecoder)(reader);
                    break;
                case 4:
                    message.initialDeposit.push(coin_1.Coin.decode(reader, reader.uint32()));
                    break;
                case 5:
                    message.creator = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgCreateTunnel();
        message.signalDeviations = object.signalDeviations?.map(e => tunnel_1.SignalDeviation.fromPartial(e)) || [];
        message.interval = object.interval !== undefined && object.interval !== null ? BigInt(object.interval.toString()) : BigInt(0);
        message.route = object.route !== undefined && object.route !== null ? any_1.Any.fromPartial(object.route) : undefined;
        message.initialDeposit = object.initialDeposit?.map(e => coin_1.Coin.fromPartial(e)) || [];
        message.creator = object.creator ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgCreateTunnel();
        message.signalDeviations = object.signal_deviations?.map(e => tunnel_1.SignalDeviation.fromAmino(e)) || [];
        if (object.interval !== undefined && object.interval !== null) {
            message.interval = BigInt(object.interval);
        }
        if (object.route !== undefined && object.route !== null) {
            message.route = (0, exports.RouteI_FromAmino)(object.route);
        }
        message.initialDeposit = object.initial_deposit?.map(e => coin_1.Coin.fromAmino(e)) || [];
        if (object.creator !== undefined && object.creator !== null) {
            message.creator = object.creator;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.signalDeviations) {
            obj.signal_deviations = message.signalDeviations.map(e => e ? tunnel_1.SignalDeviation.toAmino(e) : undefined);
        }
        else {
            obj.signal_deviations = message.signalDeviations;
        }
        obj.interval = message.interval !== BigInt(0) ? message.interval?.toString() : undefined;
        obj.route = message.route ? (0, exports.RouteI_ToAmino)(message.route) : undefined;
        if (message.initialDeposit) {
            obj.initial_deposit = message.initialDeposit.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
        }
        else {
            obj.initial_deposit = message.initialDeposit;
        }
        obj.creator = message.creator === "" ? undefined : message.creator;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgCreateTunnel.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tunnel/MsgCreateTunnel",
            value: exports.MsgCreateTunnel.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgCreateTunnel.decode(message.value);
    },
    toProto(message) {
        return exports.MsgCreateTunnel.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgCreateTunnel",
            value: exports.MsgCreateTunnel.encode(message).finish()
        };
    }
};
function createBaseMsgCreateTunnelResponse() {
    return {
        tunnelId: BigInt(0)
    };
}
exports.MsgCreateTunnelResponse = {
    typeUrl: "/band.tunnel.v1beta1.MsgCreateTunnelResponse",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        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 = createBaseMsgCreateTunnelResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgCreateTunnelResponse();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgCreateTunnelResponse();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgCreateTunnelResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgCreateTunnelResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgCreateTunnelResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgCreateTunnelResponse",
            value: exports.MsgCreateTunnelResponse.encode(message).finish()
        };
    }
};
function createBaseMsgUpdateRoute() {
    return {
        tunnelId: BigInt(0),
        route: undefined,
        creator: ""
    };
}
exports.MsgUpdateRoute = {
    typeUrl: "/band.tunnel.v1beta1.MsgUpdateRoute",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        if (message.route !== undefined) {
            any_1.Any.encode(message.route, writer.uint32(18).fork()).ldelim();
        }
        if (message.creator !== "") {
            writer.uint32(26).string(message.creator);
        }
        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 = createBaseMsgUpdateRoute();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.route = (0, exports.RouteI_InterfaceDecoder)(reader);
                    break;
                case 3:
                    message.creator = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgUpdateRoute();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.route = object.route !== undefined && object.route !== null ? any_1.Any.fromPartial(object.route) : undefined;
        message.creator = object.creator ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgUpdateRoute();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.route !== undefined && object.route !== null) {
            message.route = (0, exports.RouteI_FromAmino)(object.route);
        }
        if (object.creator !== undefined && object.creator !== null) {
            message.creator = object.creator;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.route = message.route ? (0, exports.RouteI_ToAmino)(message.route) : undefined;
        obj.creator = message.creator === "" ? undefined : message.creator;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgUpdateRoute.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tunnel/MsgUpdateRoute",
            value: exports.MsgUpdateRoute.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgUpdateRoute.decode(message.value);
    },
    toProto(message) {
        return exports.MsgUpdateRoute.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgUpdateRoute",
            value: exports.MsgUpdateRoute.encode(message).finish()
        };
    }
};
function createBaseMsgUpdateRouteResponse() {
    return {};
}
exports.MsgUpdateRouteResponse = {
    typeUrl: "/band.tunnel.v1beta1.MsgUpdateRouteResponse",
    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 = createBaseMsgUpdateRouteResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgUpdateRouteResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgUpdateRouteResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgUpdateRouteResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgUpdateRouteResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgUpdateRouteResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgUpdateRouteResponse",
            value: exports.MsgUpdateRouteResponse.encode(message).finish()
        };
    }
};
function createBaseMsgUpdateSignalsAndInterval() {
    return {
        tunnelId: BigInt(0),
        signalDeviations: [],
        interval: BigInt(0),
        creator: ""
    };
}
exports.MsgUpdateSignalsAndInterval = {
    typeUrl: "/band.tunnel.v1beta1.MsgUpdateSignalsAndInterval",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        for (const v of message.signalDeviations) {
            tunnel_1.SignalDeviation.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.interval !== BigInt(0)) {
            writer.uint32(24).uint64(message.interval);
        }
        if (message.creator !== "") {
            writer.uint32(34).string(message.creator);
        }
        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 = createBaseMsgUpdateSignalsAndInterval();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.signalDeviations.push(tunnel_1.SignalDeviation.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.interval = reader.uint64();
                    break;
                case 4:
                    message.creator = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgUpdateSignalsAndInterval();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.signalDeviations = object.signalDeviations?.map(e => tunnel_1.SignalDeviation.fromPartial(e)) || [];
        message.interval = object.interval !== undefined && object.interval !== null ? BigInt(object.interval.toString()) : BigInt(0);
        message.creator = object.creator ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgUpdateSignalsAndInterval();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        message.signalDeviations = object.signal_deviations?.map(e => tunnel_1.SignalDeviation.fromAmino(e)) || [];
        if (object.interval !== undefined && object.interval !== null) {
            message.interval = BigInt(object.interval);
        }
        if (object.creator !== undefined && object.creator !== null) {
            message.creator = object.creator;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        if (message.signalDeviations) {
            obj.signal_deviations = message.signalDeviations.map(e => e ? tunnel_1.SignalDeviation.toAmino(e) : undefined);
        }
        else {
            obj.signal_deviations = message.signalDeviations;
        }
        obj.interval = message.interval !== BigInt(0) ? message.interval?.toString() : undefined;
        obj.creator = message.creator === "" ? undefined : message.creator;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgUpdateSignalsAndInterval.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tunnel/MsgUpdateSignalsAndInterval",
            value: exports.MsgUpdateSignalsAndInterval.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgUpdateSignalsAndInterval.decode(message.value);
    },
    toProto(message) {
        return exports.MsgUpdateSignalsAndInterval.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgUpdateSignalsAndInterval",
            value: exports.MsgUpdateSignalsAndInterval.encode(message).finish()
        };
    }
};
function createBaseMsgUpdateSignalsAndIntervalResponse() {
    return {};
}
exports.MsgUpdateSignalsAndIntervalResponse = {
    typeUrl: "/band.tunnel.v1beta1.MsgUpdateSignalsAndIntervalResponse",
    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 = createBaseMsgUpdateSignalsAndIntervalResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgUpdateSignalsAndIntervalResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgUpdateSignalsAndIntervalResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgUpdateSignalsAndIntervalResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgUpdateSignalsAndIntervalResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgUpdateSignalsAndIntervalResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgUpdateSignalsAndIntervalResponse",
            value: exports.MsgUpdateSignalsAndIntervalResponse.encode(message).finish()
        };
    }
};
function createBaseMsgWithdrawFeePayerFunds() {
    return {
        tunnelId: BigInt(0),
        amount: [],
        creator: ""
    };
}
exports.MsgWithdrawFeePayerFunds = {
    typeUrl: "/band.tunnel.v1beta1.MsgWithdrawFeePayerFunds",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.creator !== "") {
            writer.uint32(26).string(message.creator);
        }
        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 = createBaseMsgWithdrawFeePayerFunds();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.creator = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgWithdrawFeePayerFunds();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.amount = object.amount?.map(e => coin_1.Coin.fromPartial(e)) || [];
        message.creator = object.creator ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgWithdrawFeePayerFunds();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        message.amount = object.amount?.map(e => coin_1.Coin.fromAmino(e)) || [];
        if (object.creator !== undefined && object.creator !== null) {
            message.creator = object.creator;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        if (message.amount) {
            obj.amount = message.amount.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
        }
        else {
            obj.amount = message.amount;
        }
        obj.creator = message.creator === "" ? undefined : message.creator;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgWithdrawFeePayerFunds.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tunnel/MsgWithdrawFeePayerFunds",
            value: exports.MsgWithdrawFeePayerFunds.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgWithdrawFeePayerFunds.decode(message.value);
    },
    toProto(message) {
        return exports.MsgWithdrawFeePayerFunds.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgWithdrawFeePayerFunds",
            value: exports.MsgWithdrawFeePayerFunds.encode(message).finish()
        };
    }
};
function createBaseMsgWithdrawFeePayerFundsResponse() {
    return {};
}
exports.MsgWithdrawFeePayerFundsResponse = {
    typeUrl: "/band.tunnel.v1beta1.MsgWithdrawFeePayerFundsResponse",
    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 = createBaseMsgWithdrawFeePayerFundsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgWithdrawFeePayerFundsResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgWithdrawFeePayerFundsResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgWithdrawFeePayerFundsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgWithdrawFeePayerFundsResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgWithdrawFeePayerFundsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgWithdrawFeePayerFundsResponse",
            value: exports.MsgWithdrawFeePayerFundsResponse.encode(message).finish()
        };
    }
};
function createBaseMsgActivateTunnel() {
    return {
        tunnelId: BigInt(0),
        creator: ""
    };
}
exports.MsgActivateTunnel = {
    typeUrl: "/band.tunnel.v1beta1.MsgActivateTunnel",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        if (message.creator !== "") {
            writer.uint32(18).string(message.creator);
        }
        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 = createBaseMsgActivateTunnel();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.creator = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgActivateTunnel();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.creator = object.creator ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgActivateTunnel();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.creator !== undefined && object.creator !== null) {
            message.creator = object.creator;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.creator = message.creator === "" ? undefined : message.creator;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgActivateTunnel.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tunnel/MsgActivateTunnel",
            value: exports.MsgActivateTunnel.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgActivateTunnel.decode(message.value);
    },
    toProto(message) {
        return exports.MsgActivateTunnel.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgActivateTunnel",
            value: exports.MsgActivateTunnel.encode(message).finish()
        };
    }
};
function createBaseMsgActivateTunnelResponse() {
    return {};
}
exports.MsgActivateTunnelResponse = {
    typeUrl: "/band.tunnel.v1beta1.MsgActivateTunnelResponse",
    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 = createBaseMsgActivateTunnelResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgActivateTunnelResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgActivateTunnelResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgActivateTunnelResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgActivateTunnelResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgActivateTunnelResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgActivateTunnelResponse",
            value: exports.MsgActivateTunnelResponse.encode(message).finish()
        };
    }
};
function createBaseMsgDeactivateTunnel() {
    return {
        tunnelId: BigInt(0),
        creator: ""
    };
}
exports.MsgDeactivateTunnel = {
    typeUrl: "/band.tunnel.v1beta1.MsgDeactivateTunnel",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        if (message.creator !== "") {
            writer.uint32(18).string(message.creator);
        }
        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 = createBaseMsgDeactivateTunnel();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.creator = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgDeactivateTunnel();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.creator = object.creator ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgDeactivateTunnel();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.creator !== undefined && object.creator !== null) {
            message.creator = object.creator;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.creator = message.creator === "" ? undefined : message.creator;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgDeactivateTunnel.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tunnel/MsgDeactivateTunnel",
            value: exports.MsgDeactivateTunnel.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgDeactivateTunnel.decode(message.value);
    },
    toProto(message) {
        return exports.MsgDeactivateTunnel.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgDeactivateTunnel",
            value: exports.MsgDeactivateTunnel.encode(message).finish()
        };
    }
};
function createBaseMsgDeactivateTunnelResponse() {
    return {};
}
exports.MsgDeactivateTunnelResponse = {
    typeUrl: "/band.tunnel.v1beta1.MsgDeactivateTunnelResponse",
    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 = createBaseMsgDeactivateTunnelResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgDeactivateTunnelResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgDeactivateTunnelResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgDeactivateTunnelResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgDeactivateTunnelResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgDeactivateTunnelResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgDeactivateTunnelResponse",
            value: exports.MsgDeactivateTunnelResponse.encode(message).finish()
        };
    }
};
function createBaseMsgTriggerTunnel() {
    return {
        tunnelId: BigInt(0),
        creator: ""
    };
}
exports.MsgTriggerTunnel = {
    typeUrl: "/band.tunnel.v1beta1.MsgTriggerTunnel",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        if (message.creator !== "") {
            writer.uint32(18).string(message.creator);
        }
        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 = createBaseMsgTriggerTunnel();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.creator = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgTriggerTunnel();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.creator = object.creator ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgTriggerTunnel();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.creator !== undefined && object.creator !== null) {
            message.creator = object.creator;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.creator = message.creator === "" ? undefined : message.creator;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgTriggerTunnel.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tunnel/MsgTriggerTunnel",
            value: exports.MsgTriggerTunnel.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgTriggerTunnel.decode(message.value);
    },
    toProto(message) {
        return exports.MsgTriggerTunnel.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgTriggerTunnel",
            value: exports.MsgTriggerTunnel.encode(message).finish()
        };
    }
};
function createBaseMsgTriggerTunnelResponse() {
    return {};
}
exports.MsgTriggerTunnelResponse = {
    typeUrl: "/band.tunnel.v1beta1.MsgTriggerTunnelResponse",
    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 = createBaseMsgTriggerTunnelResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgTriggerTunnelResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgTriggerTunnelResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgTriggerTunnelResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgTriggerTunnelResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgTriggerTunnelResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgTriggerTunnelResponse",
            value: exports.MsgTriggerTunnelResponse.encode(message).finish()
        };
    }
};
function createBaseMsgDepositToTunnel() {
    return {
        tunnelId: BigInt(0),
        amount: [],
        depositor: ""
    };
}
exports.MsgDepositToTunnel = {
    typeUrl: "/band.tunnel.v1beta1.MsgDepositToTunnel",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.depositor !== "") {
            writer.uint32(26).string(message.depositor);
        }
        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 = createBaseMsgDepositToTunnel();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.depositor = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgDepositToTunnel();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.amount = object.amount?.map(e => coin_1.Coin.fromPartial(e)) || [];
        message.depositor = object.depositor ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgDepositToTunnel();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        message.amount = object.amount?.map(e => coin_1.Coin.fromAmino(e)) || [];
        if (object.depositor !== undefined && object.depositor !== null) {
            message.depositor = object.depositor;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        if (message.amount) {
            obj.amount = message.amount.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
        }
        else {
            obj.amount = message.amount;
        }
        obj.depositor = message.depositor === "" ? undefined : message.depositor;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgDepositToTunnel.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tunnel/MsgDepositToTunnel",
            value: exports.MsgDepositToTunnel.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgDepositToTunnel.decode(message.value);
    },
    toProto(message) {
        return exports.MsgDepositToTunnel.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgDepositToTunnel",
            value: exports.MsgDepositToTunnel.encode(message).finish()
        };
    }
};
function createBaseMsgDepositToTunnelResponse() {
    return {};
}
exports.MsgDepositToTunnelResponse = {
    typeUrl: "/band.tunnel.v1beta1.MsgDepositToTunnelResponse",
    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 = createBaseMsgDepositToTunnelResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgDepositToTunnelResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgDepositToTunnelResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgDepositToTunnelResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgDepositToTunnelResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgDepositToTunnelResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgDepositToTunnelResponse",
            value: exports.MsgDepositToTunnelResponse.encode(message).finish()
        };
    }
};
function createBaseMsgWithdrawFromTunnel() {
    return {
        tunnelId: BigInt(0),
        amount: [],
        withdrawer: ""
    };
}
exports.MsgWithdrawFromTunnel = {
    typeUrl: "/band.tunnel.v1beta1.MsgWithdrawFromTunnel",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        for (const v of message.amount) {
            coin_1.Coin.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.withdrawer !== "") {
            writer.uint32(26).string(message.withdrawer);
        }
        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 = createBaseMsgWithdrawFromTunnel();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.withdrawer = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgWithdrawFromTunnel();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.amount = object.amount?.map(e => coin_1.Coin.fromPartial(e)) || [];
        message.withdrawer = object.withdrawer ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseMsgWithdrawFromTunnel();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        message.amount = object.amount?.map(e => coin_1.Coin.fromAmino(e)) || [];
        if (object.withdrawer !== undefined && object.withdrawer !== null) {
            message.withdrawer = object.withdrawer;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        if (message.amount) {
            obj.amount = message.amount.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
        }
        else {
            obj.amount = message.amount;
        }
        obj.withdrawer = message.withdrawer === "" ? undefined : message.withdrawer;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgWithdrawFromTunnel.fromAmino(object.value);
    },
    toAminoMsg(message) {
        return {
            type: "tunnel/MsgWithdrawFromTunnel",
            value: exports.MsgWithdrawFromTunnel.toAmino(message)
        };
    },
    fromProtoMsg(message) {
        return exports.MsgWithdrawFromTunnel.decode(message.value);
    },
    toProto(message) {
        return exports.MsgWithdrawFromTunnel.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgWithdrawFromTunnel",
            value: exports.MsgWithdrawFromTunnel.encode(message).finish()
        };
    }
};
function createBaseMsgWithdrawFromTunnelResponse() {
    return {};
}
exports.MsgWithdrawFromTunnelResponse = {
    typeUrl: "/band.tunnel.v1beta1.MsgWithdrawFromTunnelResponse",
    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 = createBaseMsgWithdrawFromTunnelResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseMsgWithdrawFromTunnelResponse();
        return message;
    },
    fromAmino(_) {
        const message = createBaseMsgWithdrawFromTunnelResponse();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MsgWithdrawFromTunnelResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MsgWithdrawFromTunnelResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MsgWithdrawFromTunnelResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.MsgWithdrawFromTunnelResponse",
            value: exports.MsgWithdrawFromTunnelResponse.encode(message).finish()
        };
    }
};
function createBaseMsgUpdateParams() {
    return {
        authority: "",
        params: params_1.Params.fromPartial({})
    };
}
exports.MsgUpdateParams = {
    typeUrl: "/band.tunnel.v1beta1.MsgUpdateParams",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.authority !== "") {
            writer.uint32(10).string(message.authority);
        }
        if (message.params !== undefined) {
            params_1.Params.encode(message.params, 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 = createBaseMsgUpdateParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.authority = reader.string();
                    break;
                case 2:
                    message.params = params_1.Params.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMsgUpdateParams();
        message.authority = object.authority ?? "";
        message.params