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

TypeScript library for Cosmos SDK and BandChain

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